From ecf1c08f8b3eb30903f13214a191ffa34747f2f9 Mon Sep 17 00:00:00 2001
From: Karan Anand <119553199+anandkaranubc@users.noreply.github.com>
Date: Thu, 14 Aug 2025 23:58:10 +0530
Subject: [PATCH 01/32] feat: add `math/base/special/cscdf`

PR-URL: https://github.com/stdlib-js/stdlib/pull/7868
Ref: https://github.com/stdlib-js/stdlib/issues/649

Co-authored-by: Philipp Burckhardt <pburckhardt@outlook.com>
Reviewed-by: Philipp Burckhardt <pburckhardt@outlook.com>
Signed-off-by: Karan Anand <119553199+anandkaranubc@users.noreply.github.com>
---
 .../@stdlib/math/base/special/cscdf/README.md | 192 ++++++++++++++++++
 .../base/special/cscdf/benchmark/benchmark.js |  54 +++++
 .../cscdf/benchmark/benchmark.native.js       |  63 ++++++
 .../special/cscdf/benchmark/c/native/Makefile | 146 +++++++++++++
 .../cscdf/benchmark/c/native/benchmark.c      | 138 +++++++++++++
 .../math/base/special/cscdf/binding.gyp       | 170 ++++++++++++++++
 .../math/base/special/cscdf/docs/repl.txt     |  29 +++
 .../base/special/cscdf/docs/types/index.d.ts  |  56 +++++
 .../base/special/cscdf/docs/types/test.ts     |  44 ++++
 .../base/special/cscdf/examples/c/Makefile    | 146 +++++++++++++
 .../base/special/cscdf/examples/c/example.c   |  31 +++
 .../math/base/special/cscdf/examples/index.js |  30 +++
 .../math/base/special/cscdf/include.gypi      |  53 +++++
 .../include/stdlib/math/base/special/cscdf.h  |  38 ++++
 .../math/base/special/cscdf/lib/index.js      |  55 +++++
 .../math/base/special/cscdf/lib/main.js       |  66 ++++++
 .../math/base/special/cscdf/lib/native.js     |  66 ++++++
 .../math/base/special/cscdf/manifest.json     |  72 +++++++
 .../math/base/special/cscdf/package.json      |  67 ++++++
 .../math/base/special/cscdf/src/Makefile      |  70 +++++++
 .../math/base/special/cscdf/src/addon.c       |  22 ++
 .../math/base/special/cscdf/src/main.c        |  34 ++++
 .../special/cscdf/test/fixtures/julia/REQUIRE |   2 +
 .../cscdf/test/fixtures/julia/negative.json   |   1 +
 .../cscdf/test/fixtures/julia/positive.json   |   1 +
 .../cscdf/test/fixtures/julia/runner.jl       |  70 +++++++
 .../math/base/special/cscdf/test/test.js      | 118 +++++++++++
 .../base/special/cscdf/test/test.native.js    | 127 ++++++++++++
 28 files changed, 1961 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/README.md
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/benchmark.js
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/benchmark.native.js
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/c/native/Makefile
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/c/native/benchmark.c
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/binding.gyp
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/docs/types/index.d.ts
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/docs/types/test.ts
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/examples/c/Makefile
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/examples/c/example.c
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/include.gypi
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/include/stdlib/math/base/special/cscdf.h
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/lib/native.js
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/manifest.json
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/package.json
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/src/Makefile
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/src/addon.c
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/src/main.c
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/REQUIRE
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/negative.json
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/positive.json
 create mode 100755 lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/runner.jl
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/test/test.js
 create mode 100644 lib/node_modules/@stdlib/math/base/special/cscdf/test/test.native.js

diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/README.md b/lib/node_modules/@stdlib/math/base/special/cscdf/README.md
new file mode 100644
index 000000000000..e595d7a1b2a3
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/README.md
@@ -0,0 +1,192 @@
+<!--
+
+@license Apache-2.0
+
+Copyright (c) 2025 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.
+
+-->
+
+# cscdf
+
+> Compute the [cosecant][cosecant] of a single-precision floating-point number (in degrees).
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var cscdf = require( '@stdlib/math/base/special/cscdf' );
+```
+
+#### cscdf( x )
+
+Computes the [cosecant][cosecant] of a single-precision floating-point number (in degrees).
+
+```javascript
+var v = cscdf( 30.0 );
+// returns ~2.0
+
+v = cscdf( 45.0 );
+// returns ~1.41
+
+v = cscdf( 60.0 );
+// returns ~1.15
+
+v = cscdf( 90.0 );
+// returns 1.0
+
+v = cscdf( 0.0 );
+// returns Infinity
+
+v = cscdf( NaN );
+// returns NaN
+```
+
+</section>
+
+<!-- /.usage -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var uniform = require( '@stdlib/random/array/uniform' );
+var logEachMap = require( '@stdlib/console/log-each-map' );
+var cscdf = require( '@stdlib/math/base/special/cscdf' );
+
+var opts = {
+    'dtype': 'float32'
+};
+var x = uniform( 100, -180.0, 180.0, opts );
+
+logEachMap( 'cscdf(%0.4f) = %0.4f', x, cscdf );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- C interface documentation. -->
+
+* * *
+
+<section class="c">
+
+## C APIs
+
+<!-- Section to include introductory text. Make sure to keep an empty line after the intro `section` element and another before the `/section` close. -->
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<!-- C usage documentation. -->
+
+<section class="usage">
+
+### Usage
+
+```c
+#include "stdlib/math/base/special/cscdf.h"
+```
+
+#### stdlib_base_cscdf( x )
+
+Computes the [cosecant][cosecant] of a single-precision floating-point number (in degrees).
+
+```c
+float out = stdlib_base_cscdf( 30.0f );
+// returns ~2.0f
+
+out = stdlib_base_cscdf( 45.0f );
+// returns ~1.41f
+```
+
+The function accepts the following arguments:
+
+-   **x**: `[in] float` input value.
+
+```c
+float stdlib_base_cscdf( const float x );
+```
+
+</section>
+
+<!-- /.usage -->
+
+<!-- C API usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="notes">
+
+</section>
+
+<!-- /.notes -->
+
+<!-- C API usage examples. -->
+
+<section class="examples">
+
+### Examples
+
+```c
+#include "stdlib/math/base/special/cscdf.h"
+#include <stdio.h>
+
+int main( void ) {
+    const float x[] = { 30.0f, 45.0f, 60.0f, 90.0f };
+
+    float y;
+    int i;
+    for ( i = 0; i < 4; i++ ) {
+        y = stdlib_base_cscdf( x[ i ] );
+        printf( "cscdf(%f) = %f\n", x[ i ], y );
+    }
+}
+```
+
+</section>
+
+<!-- /.examples -->
+
+</section>
+
+<!-- /.c -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<!-- Section for all links. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="links">
+
+[cosecant]: https://en.wikipedia.org/wiki/Inverse_trigonometric_functions
+
+<!-- <related-links> -->
+
+<!-- </related-links> -->
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/benchmark.js b/lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/benchmark.js
new file mode 100644
index 000000000000..9710e7ce4f6b
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/benchmark.js
@@ -0,0 +1,54 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var pkg = require( './../package.json' ).name;
+var cscdf = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+	var x;
+	var y;
+	var i;
+
+	x = uniform( 100, -180.0, 180.0, {
+		'dtype': 'float32'
+	});
+
+	b.tic();
+	for ( i = 0; i < b.iterations; i++ ) {
+		y = cscdf( x[ i%x.length ] );
+		if ( isnanf( y ) ) {
+			b.fail( 'should not return NaN' );
+		}
+	}
+	b.toc();
+	if ( isnanf( y ) ) {
+		b.fail( 'should not return NaN' );
+	}
+	b.pass( 'benchmark finished' );
+	b.end();
+});
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/benchmark.native.js
new file mode 100644
index 000000000000..65670f064cf0
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/benchmark.native.js
@@ -0,0 +1,63 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+var pkg = require( './../package.json' ).name;
+
+
+// VARIABLES //
+
+var cscdf = tryRequire( resolve( __dirname, './../lib/native.js' ) );
+var opts = {
+	'skip': ( cscdf instanceof Error )
+};
+
+
+// MAIN //
+
+bench( pkg+'::native', opts, function benchmark( b ) {
+	var x;
+	var y;
+	var i;
+
+	x = uniform( 100, -180.0, 180.0, {
+		'dtype': 'float32'
+	});
+
+	b.tic();
+	for ( i = 0; i < b.iterations; i++ ) {
+		y = cscdf( x[ i%x.length ] );
+		if ( isnanf( y ) ) {
+			b.fail( 'should not return NaN' );
+		}
+	}
+	b.toc();
+	if ( isnanf( y ) ) {
+		b.fail( 'should not return NaN' );
+	}
+	b.pass( 'benchmark finished' );
+	b.end();
+});
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/c/native/Makefile b/lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/c/native/Makefile
new file mode 100644
index 000000000000..a4bd7b38fd74
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/c/native/Makefile
@@ -0,0 +1,146 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+	CC := $(C_COMPILER)
+else
+	CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+	-std=c99 \
+	-O3 \
+	-Wall \
+	-pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+	fPIC ?=
+else
+	fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := benchmark.out
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`)
+# @param {string} [CFLAGS] - C compiler options
+# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} CC - C compiler (e.g., `gcc`)
+# @param {string} CFLAGS - C compiler options
+# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(c_targets): %.out: %.c
+	$(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled benchmarks.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+	$(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+	$(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/c/native/benchmark.c b/lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/c/native/benchmark.c
new file mode 100644
index 000000000000..c1bd47644ca9
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/benchmark/c/native/benchmark.c
@@ -0,0 +1,138 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+#include "stdlib/math/base/special/cscdf.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <time.h>
+#include <sys/time.h>
+
+#define NAME "cscdf"
+#define ITERATIONS 1000000
+#define REPEATS 3
+
+/**
+* Prints the TAP version.
+*/
+static void print_version( void ) {
+	printf( "TAP version 13\n" );
+}
+
+/**
+* Prints the TAP summary.
+*
+* @param total     total number of tests
+* @param passing   total number of passing tests
+*/
+static void print_summary( int total, int passing ) {
+	printf( "#\n" );
+	printf( "1..%d\n", total ); // TAP plan
+	printf( "# total %d\n", total );
+	printf( "# pass  %d\n", passing );
+	printf( "#\n" );
+	printf( "# ok\n" );
+}
+
+/**
+* Prints benchmarks results.
+*
+* @param elapsed   elapsed time in seconds
+*/
+static void print_results( double elapsed ) {
+	double rate = (double)ITERATIONS / elapsed;
+	printf( "  ---\n" );
+	printf( "  iterations: %d\n", ITERATIONS );
+	printf( "  elapsed: %0.9f\n", elapsed );
+	printf( "  rate: %0.9f\n", rate );
+	printf( "  ...\n" );
+}
+
+/**
+* Returns a clock time.
+*
+* @return clock time
+*/
+static double tic( void ) {
+	struct timeval now;
+	gettimeofday( &now, NULL );
+	return (double)now.tv_sec + (double)now.tv_usec/1.0e6;
+}
+
+/**
+* Generates a random number on the interval [min,max).
+*
+* @param min    minimum value (inclusive)
+* @param max    maximum value (exclusive)
+* @return       random number
+*/
+static float random_uniform( const float min, const float max ) {
+	float v = (float)rand() / ( (float)RAND_MAX + 1.0f );
+	return min + ( v*(max-min) );
+}
+
+/**
+* Runs a benchmark.
+*
+* @return elapsed time in seconds
+*/
+static double benchmark( void ) {
+	float x[ 100 ];
+	double elapsed;
+	double t;
+	float y;
+	int i;
+
+	for ( i = 0; i < 100; i++ ) {
+		x[ i ] = random_uniform( -180.0f, 180.0f );
+	}
+
+	t = tic();
+	for ( i = 0; i < ITERATIONS; i++ ) {
+		y = stdlib_base_cscdf( x[ i%100 ] );
+		if ( y != y ) {
+			printf( "should not return NaN\n" );
+			break;
+		}
+	}
+	elapsed = tic() - t;
+	if ( y != y ) {
+		printf( "should not return NaN\n" );
+	}
+	return elapsed;
+}
+
+/**
+* Main execution sequence.
+*/
+int main( void ) {
+	double elapsed;
+	int i;
+
+	// Use the current time to seed the random number generator:
+	srand( time( NULL ) );
+
+	print_version();
+	for ( i = 0; i < REPEATS; i++ ) {
+		printf( "# c::native::%s\n", NAME );
+		elapsed = benchmark();
+		print_results( elapsed );
+		printf( "ok %d benchmark finished\n", i+1 );
+	}
+	print_summary( REPEATS, REPEATS );
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/binding.gyp b/lib/node_modules/@stdlib/math/base/special/cscdf/binding.gyp
new file mode 100644
index 000000000000..68a1ca11d160
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/binding.gyp
@@ -0,0 +1,170 @@
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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.
+
+# A `.gyp` file for building a Node.js native add-on.
+#
+# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md
+# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md
+{
+  # List of files to include in this file:
+  'includes': [
+    './include.gypi',
+  ],
+
+  # Define variables to be used throughout the configuration for all targets:
+  'variables': {
+    # Target name should match the add-on export name:
+    'addon_target_name%': 'addon',
+
+    # Set variables based on the host OS:
+    'conditions': [
+      [
+        'OS=="win"',
+        {
+          # Define the object file suffix:
+          'obj': 'obj',
+        },
+        {
+          # Define the object file suffix:
+          'obj': 'o',
+        }
+      ], # end condition (OS=="win")
+    ], # end conditions
+  }, # end variables
+
+  # Define compile targets:
+  'targets': [
+
+    # Target to generate an add-on:
+    {
+      # The target name should match the add-on export name:
+      'target_name': '<(addon_target_name)',
+
+      # Define dependencies:
+      'dependencies': [],
+
+      # Define directories which contain relevant include headers:
+      'include_dirs': [
+        # Local include directory:
+        '<@(include_dirs)',
+      ],
+
+      # List of source files:
+      'sources': [
+        '<@(src_files)',
+      ],
+
+      # Settings which should be applied when a target's object files are used as linker input:
+      'link_settings': {
+        # Define libraries:
+        'libraries': [
+          '<@(libraries)',
+        ],
+
+        # Define library directories:
+        'library_dirs': [
+          '<@(library_dirs)',
+        ],
+      },
+
+      # C/C++ compiler flags:
+      'cflags': [
+        # Enable commonly used warning options:
+        '-Wall',
+
+        # Aggressive optimization:
+        '-O3',
+      ],
+
+      # C specific compiler flags:
+      'cflags_c': [
+        # Specify the C standard to which a program is expected to conform:
+        '-std=c99',
+      ],
+
+      # C++ specific compiler flags:
+      'cflags_cpp': [
+        # Specify the C++ standard to which a program is expected to conform:
+        '-std=c++11',
+      ],
+
+      # Linker flags:
+      'ldflags': [],
+
+      # Apply conditions based on the host OS:
+      'conditions': [
+        [
+          'OS=="mac"',
+          {
+            # Linker flags:
+            'ldflags': [
+              '-undefined dynamic_lookup',
+              '-Wl,-no-pie',
+              '-Wl,-search_paths_first',
+            ],
+          },
+        ], # end condition (OS=="mac")
+        [
+          'OS!="win"',
+          {
+            # C/C++ flags:
+            'cflags': [
+              # Generate platform-independent code:
+              '-fPIC',
+            ],
+          },
+        ], # end condition (OS!="win")
+      ], # end conditions
+    }, # end target <(addon_target_name)
+
+    # Target to copy a generated add-on to a standard location:
+    {
+      'target_name': 'copy_addon',
+
+      # Declare that the output of this target is not linked:
+      'type': 'none',
+
+      # Define dependencies:
+      'dependencies': [
+        # Require that the add-on be generated before building this target:
+        '<(addon_target_name)',
+      ],
+
+      # Define a list of actions:
+      'actions': [
+        {
+          'action_name': 'copy_addon',
+          'message': 'Copying addon...',
+
+          # Explicitly list the inputs in the command-line invocation below:
+          'inputs': [],
+
+          # Declare the expected outputs:
+          'outputs': [
+            '<(addon_output_dir)/<(addon_target_name).node',
+          ],
+
+          # Define the command-line invocation:
+          'action': [
+            'cp',
+            '<(PRODUCT_DIR)/<(addon_target_name).node',
+            '<(addon_output_dir)/<(addon_target_name).node',
+          ],
+        },
+      ], # end actions
+    }, # end target copy_addon
+  ], # end targets
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/docs/repl.txt b/lib/node_modules/@stdlib/math/base/special/cscdf/docs/repl.txt
new file mode 100644
index 000000000000..6949afd2076d
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/docs/repl.txt
@@ -0,0 +1,29 @@
+
+{{alias}}( x )
+    Computes the cosecant of a single-precision floating-point number (in
+    degrees).
+
+    Parameters
+    ----------
+    x: number
+        Input value (in degrees).
+
+    Returns
+    -------
+    y: number
+        Cosecant.
+
+    Examples
+    --------
+    > var y = {{alias}}( 1.0 )
+    ~57.30
+    > y = {{alias}}( {{alias:@stdlib/constants/float32/pi}} )
+    ~18.25
+    > y = {{alias}}( -{{alias:@stdlib/constants/float32/pi}} )
+    ~-18.25
+    > y = {{alias}}( NaN )
+    NaN
+
+    See Also
+    --------
+
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/special/cscdf/docs/types/index.d.ts
new file mode 100644
index 000000000000..52ba74cb20f7
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/docs/types/index.d.ts
@@ -0,0 +1,56 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+// TypeScript Version: 4.1
+
+/**
+* Computes the cosecant of a single-precision floating-point number (in degrees).
+*
+* @param x - input value (in degrees)
+* @returns cosecant
+*
+* @example
+* var v = cscdf( 30.0 );
+* // returns ~2.0
+*
+* @example
+* var v = cscdf( 45.0 );
+* // returns ~1.41
+*
+* @example
+* var v = cscdf( 60.0 );
+* // returns ~1.15
+*
+* @example
+* var v = cscdf( 90.0 );
+* // returns 1.0
+*
+* @example
+* var v = cscdf( 0.0 );
+* // returns Infinity
+*
+* @example
+* var v = cscdf( NaN );
+* // returns NaN
+*/
+declare function cscdf( x: number ): number;
+
+
+// EXPORTS //
+
+export = cscdf;
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/docs/types/test.ts b/lib/node_modules/@stdlib/math/base/special/cscdf/docs/types/test.ts
new file mode 100644
index 000000000000..53942f27eab0
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/docs/types/test.ts
@@ -0,0 +1,44 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+import cscdf = require( './index' );
+
+
+// TESTS //
+
+// The function returns a number...
+{
+	cscdf( 8.0 ); // $ExpectType number
+}
+
+// The compiler throws an error if the function is provided a value other than a number...
+{
+	cscdf( true ); // $ExpectError
+	cscdf( false ); // $ExpectError
+	cscdf( null ); // $ExpectError
+	cscdf( undefined ); // $ExpectError
+	cscdf( '5' ); // $ExpectError
+	cscdf( [] ); // $ExpectError
+	cscdf( {} ); // $ExpectError
+	cscdf( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided insufficient arguments...
+{
+	cscdf(); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/examples/c/Makefile b/lib/node_modules/@stdlib/math/base/special/cscdf/examples/c/Makefile
new file mode 100644
index 000000000000..25ced822f96a
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/examples/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+	CC := $(C_COMPILER)
+else
+	CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+	-std=c99 \
+	-O3 \
+	-Wall \
+	-pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+	fPIC ?=
+else
+	fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := example.out
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`)
+# @param {string} [CFLAGS] - C compiler options
+# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} CC - C compiler (e.g., `gcc`)
+# @param {string} CFLAGS - C compiler options
+# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(c_targets): %.out: %.c
+	$(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled examples.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+	$(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+	$(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/examples/c/example.c b/lib/node_modules/@stdlib/math/base/special/cscdf/examples/c/example.c
new file mode 100644
index 000000000000..dc4f62b6ca9d
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/examples/c/example.c
@@ -0,0 +1,31 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+#include "stdlib/math/base/special/cscdf.h"
+#include <stdio.h>
+
+int main( void ) {
+	const float x[] = { 30.0f, 45.0f, 60.0f, 90.0f };
+
+	float y;
+	int i;
+	for ( i = 0; i < 4; i++ ) {
+		y = stdlib_base_cscdf( x[ i ] );
+		printf( "cscdf(%f) = %f\n", x[ i ], y );
+	}
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/examples/index.js b/lib/node_modules/@stdlib/math/base/special/cscdf/examples/index.js
new file mode 100644
index 000000000000..babcdcfd9f72
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/examples/index.js
@@ -0,0 +1,30 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+var uniform = require( '@stdlib/random/array/uniform' );
+var logEachMap = require( '@stdlib/console/log-each-map' );
+var cscdf = require( './../lib' );
+
+var opts = {
+	'dtype': 'float32'
+};
+var x = uniform( 100, -180.0, 180.0, opts );
+
+logEachMap( 'cscdf(%0.4f) = %0.4f', x, cscdf );
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/include.gypi b/lib/node_modules/@stdlib/math/base/special/cscdf/include.gypi
new file mode 100644
index 000000000000..ecfaf82a3279
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/include.gypi
@@ -0,0 +1,53 @@
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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.
+
+# A GYP include file for building a Node.js native add-on.
+#
+# Main documentation:
+#
+# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md
+# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md
+{
+  # Define variables to be used throughout the configuration for all targets:
+  'variables': {
+    # Source directory:
+    'src_dir': './src',
+
+    # Include directories:
+    'include_dirs': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).include; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Add-on destination directory:
+    'addon_output_dir': './src',
+
+    # Source files:
+    'src_files': [
+      '<(src_dir)/addon.c',
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).src; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Library dependencies:
+    'libraries': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libraries; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Library directories:
+    'library_dirs': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libpath; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+  }, # end variables
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/include/stdlib/math/base/special/cscdf.h b/lib/node_modules/@stdlib/math/base/special/cscdf/include/stdlib/math/base/special/cscdf.h
new file mode 100644
index 000000000000..a43fd02cd3f0
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/include/stdlib/math/base/special/cscdf.h
@@ -0,0 +1,38 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+#ifndef STDLIB_MATH_BASE_SPECIAL_CSCDF_H
+#define STDLIB_MATH_BASE_SPECIAL_CSCDF_H
+
+/*
+* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Computes the cosecant of a single-precision floating-point number (in degrees).
+*/
+float stdlib_base_cscdf( const float x );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_MATH_BASE_SPECIAL_CSCDF_H
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/lib/index.js b/lib/node_modules/@stdlib/math/base/special/cscdf/lib/index.js
new file mode 100644
index 000000000000..8ffef3e6a06a
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/lib/index.js
@@ -0,0 +1,55 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+/**
+* Compute the cosecant of a single-precision floating-point number (in degrees).
+*
+* @module @stdlib/math/base/special/cscdf
+*
+* @example
+* var cscdf = require( '@stdlib/math/base/special/cscdf' );
+*
+* var v = cscdf( 30.0 );
+* // returns ~2.0
+*
+* var v = cscdf( 45.0 );
+* // returns ~1.41
+*
+* var v = cscdf( 60.0 );
+* // returns ~1.15
+*
+* var v = cscdf( 90.0 );
+* // returns 1.0
+*
+* var v = cscdf( 0.0 );
+* // returns Infinity
+*
+* var v = cscdf( NaN );
+* // returns NaN
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/lib/main.js b/lib/node_modules/@stdlib/math/base/special/cscdf/lib/main.js
new file mode 100644
index 000000000000..39df2262cf30
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/lib/main.js
@@ -0,0 +1,66 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var f32 = require( '@stdlib/number/float64/base/to-float32' );
+var sindf = require( '@stdlib/math/base/special/sindf' );
+
+
+// MAIN //
+
+/**
+* Computes the cosecant of a single-precision floating-point number (in degrees).
+*
+* @param {number} x - input value (in degrees)
+* @returns {number} cosecant
+*
+* @example
+* var v = cscdf( 30.0 );
+* // returns ~2.0
+*
+* @example
+* var v = cscdf( 45.0 );
+* // returns ~1.41
+*
+* @example
+* var v = cscdf( 60.0 );
+* // returns ~1.15
+*
+* @example
+* var v = cscdf( 90.0 );
+* // returns 1.0
+*
+* @example
+* var v = cscdf( 0.0 );
+* // returns Infinity
+*
+* @example
+* var v = cscdf( NaN );
+* // returns NaN
+*/
+function cscdf( x ) {
+	return f32( f32( 1.0 ) / sindf( f32( x ) ) );
+}
+
+
+// EXPORTS //
+
+module.exports = cscdf;
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/lib/native.js b/lib/node_modules/@stdlib/math/base/special/cscdf/lib/native.js
new file mode 100644
index 000000000000..0197accca54e
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/lib/native.js
@@ -0,0 +1,66 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Computes the cosecant of a single-precision floating-point number (in degrees).
+*
+* @private
+* @param {number} x - input value (in degrees)
+* @returns {number} cosecant
+*
+* @example
+* var v = cscdf( 30.0 );
+* // returns ~2.0
+*
+* @example
+* var v = cscdf( 45.0 );
+* // returns ~1.41
+*
+* @example
+* var v = cscdf( 60.0 );
+* // returns ~1.15
+*
+* @example
+* var v = cscdf( 90.0 );
+* // returns 1.0
+*
+* @example
+* var v = cscdf( 0.0 );
+* // returns Infinity
+*
+* @example
+* var v = cscdf( NaN );
+* // returns NaN
+*/
+function cscdf( x ) {
+	return addon( x );
+}
+
+
+// EXPORTS //
+
+module.exports = cscdf;
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/manifest.json b/lib/node_modules/@stdlib/math/base/special/cscdf/manifest.json
new file mode 100644
index 000000000000..ed643483e3fb
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/manifest.json
@@ -0,0 +1,72 @@
+{
+  "options": {
+    "task": "build"
+  },
+  "fields": [
+    {
+      "field": "src",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "include",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "libraries",
+      "resolve": false,
+      "relative": false
+    },
+    {
+      "field": "libpath",
+      "resolve": true,
+      "relative": false
+    }
+  ],
+  "confs": [
+    {
+      "task": "build",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math/base/napi/unary",
+        "@stdlib/math/base/special/sindf"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math/base/special/sindf"
+      ]
+    },
+    {
+      "task": "examples",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math/base/special/sindf"
+      ]
+    }
+  ]
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/package.json b/lib/node_modules/@stdlib/math/base/special/cscdf/package.json
new file mode 100644
index 000000000000..bd44820edec6
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/package.json
@@ -0,0 +1,67 @@
+{
+  "name": "@stdlib/math/base/special/cscdf",
+  "version": "0.0.0",
+  "description": "Compute the cosecant of a single-precision floating-point number (in degrees).",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "The Stdlib Authors",
+    "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+  },
+  "contributors": [
+    {
+      "name": "The Stdlib Authors",
+      "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+    }
+  ],
+  "main": "./lib",
+  "gypfile": true,
+  "directories": {
+    "benchmark": "./benchmark",
+    "doc": "./docs",
+    "example": "./examples",
+    "include": "./include",
+    "lib": "./lib",
+    "src": "./src",
+    "test": "./test"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://github.com/stdlib-js/stdlib",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/stdlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "stdmath",
+    "mathematics",
+    "math",
+    "cosecant",
+    "degree",
+    "sine",
+    "inverse",
+    "trig",
+    "trigonometry",
+    "angle"
+  ]
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/src/Makefile b/lib/node_modules/@stdlib/math/base/special/cscdf/src/Makefile
new file mode 100644
index 000000000000..7733b6180cb4
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/src/Makefile
@@ -0,0 +1,70 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+
+# RULES #
+
+#/
+# Removes generated files for building an add-on.
+#
+# @example
+# make clean-addon
+#/
+clean-addon:
+	$(QUIET) -rm -f *.o *.node
+
+.PHONY: clean-addon
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean: clean-addon
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/src/addon.c b/lib/node_modules/@stdlib/math/base/special/cscdf/src/addon.c
new file mode 100644
index 000000000000..9bb7e6d1b8d4
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/src/addon.c
@@ -0,0 +1,22 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+#include "stdlib/math/base/special/cscdf.h"
+#include "stdlib/math/base/napi/unary.h"
+
+STDLIB_MATH_BASE_NAPI_MODULE_F_F( stdlib_base_cscdf )
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/src/main.c b/lib/node_modules/@stdlib/math/base/special/cscdf/src/main.c
new file mode 100644
index 000000000000..eadfd371a0d2
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/src/main.c
@@ -0,0 +1,34 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+#include "stdlib/math/base/special/cscdf.h"
+#include "stdlib/math/base/special/sindf.h"
+
+/**
+* Computes the cosecant of a single-precision floating-point number (in degrees).
+*
+* @param x    input value (in degrees)
+* @return     cosecant
+*
+* @example
+* float y = stdlib_base_cscdf( 30.0f );
+* // returns ~2.0f
+*/
+float stdlib_base_cscdf( const float x ) {
+	return 1.0f / stdlib_base_sindf( x );
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/REQUIRE b/lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/REQUIRE
new file mode 100644
index 000000000000..308c3be89c85
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/REQUIRE
@@ -0,0 +1,2 @@
+julia 1.5
+JSON 0.21
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/negative.json b/lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/negative.json
new file mode 100644
index 000000000000..50ec47737c97
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/negative.json
@@ -0,0 +1 @@
+{"expected":[572.9231,124.46061,69.81491,48.514317,37.17471,30.132753,25.334305,21.855167,19.21689,17.147575,15.481017,14.110321,12.9630785,11.988724,11.151077,10.423225,9.78493,9.220599,8.718179,8.267991,7.8622775,7.4948306,7.160467,6.854922,6.5746126,6.316588,6.0782824,5.85751,5.652446,5.461462,5.283165,5.1163235,4.9599,4.8129425,4.674611,4.5441947,4.4210277,4.3045273,4.194161,4.08948,3.9900503,3.8954842,3.8054512,3.719629,3.637734,3.5594983,3.4846983,3.4131093,3.3445268,3.2787786,3.2156904,3.1551015,3.0968785,3.0408838,2.986994,2.9350908,2.8850768,2.836849,2.7903118,2.7453876,2.701992,2.6600506,2.6194901,2.5802517,2.5422704,2.505486,2.4698498,2.4353085,2.4018135,2.3693168,2.3377821,2.3071656,2.2774272,2.2485359,2.2204552,2.193153,2.1665962,2.1407607,2.115617,2.0911367,2.0672994,2.0440793,2.021454,1.9994006,1.9779023,1.9569381,1.9364877,1.9165368,1.8970673,1.8780628,1.8595066,1.8413873,1.823689,1.8063971,1.7895014,1.7729886,1.7568463,1.7410623,1.7256285,1.7105329,1.6957644,1.6813158,1.6671767,1.6533386,1.6397911,1.6265291,1.6135429,1.6008244,1.588368,1.576166,1.5642104,1.5524968,1.5410178,1.5297674,1.5187386,1.5079281,1.4973291,1.4869356,1.4767443,1.4667492,1.4569459,1.4473288,1.437895,1.4286398,1.4195578,1.4106469,1.4019022,1.3933201,1.384896,1.3766282,1.3685122,1.3605441,1.3527223,1.3450427,1.3375025,1.3300979,1.3228276,1.315688,1.3086761,1.3017904,1.2950276,1.2883854,1.281861,1.275453,1.2691587,1.2629755,1.2569021,1.2509362,1.2450756,1.239318,1.2336626,1.2281067,1.2226484,1.2172868,1.2120198,1.2068456,1.2017624,1.1967694,1.1918647,1.1870464,1.1823138,1.1776652,1.1730989,1.1686143,1.1642097,1.1598839,1.1556352,1.1514634,1.1473668,1.1433439,1.1393945,1.1355169,1.1317103,1.1279733,1.1243056,1.1207057,1.1171726,1.113706,1.1103046,1.1069674,1.1036936,1.1004828,1.0973339,1.0942459,1.0912185,1.0882506,1.0853417,1.0824908,1.0796977,1.0769615,1.0742812,1.0716568,1.0690873,1.0665722,1.0641108,1.0617027,1.0593473,1.0570439,1.0547924,1.0525918,1.0504421,1.0483421,1.0462922,1.0442914,1.0423392,1.0404356,1.0385798,1.0367718,1.0350106,1.0332963,1.0316286,1.0300068,1.0284307,1.0269,1.0254145,1.0239735,1.022577,1.0212247,1.0199162,1.0186514,1.0174298,1.0162513,1.0151157,1.0140227,1.0129721,1.0119636,1.010997,1.0100724,1.0091891,1.0083474,1.0075469,1.0067873,1.0060687,1.0053909,1.0047538,1.0041571,1.0036007,1.0030848,1.0026089,1.0021732,1.0017773,1.0014215,1.0011054,1.0008292,1.0005926,1.0003958,1.0002385,1.000121,1.0000429,1.0000044,1.0000055,1.0000461,1.0001264,1.0002462,1.0004056,1.0006046,1.0008433,1.0011218,1.0014399,1.001798,1.0021961,1.002634,1.0031121,1.0036304,1.0041889,1.0047877,1.0054271,1.0061072,1.0068281,1.0075898,1.0083926,1.0092367,1.0101221,1.0110492,1.012018,1.0130287,1.0140817,1.0151771,1.0163151,1.0174959,1.0187199,1.0199871,1.0212979,1.0226526,1.0240517,1.0254949,1.026983,1.0285163,1.0300949,1.0317191,1.0333894,1.0351063,1.0368699,1.0386808,1.040539,1.0424454,1.0444,1.0464036,1.0484563,1.0505588,1.0527116,1.0549148,1.0571693,1.0594754,1.0618337,1.0642447,1.066709,1.0692272,1.0717996,1.0744274,1.0771104,1.0798498,1.0826461,1.0855001,1.0884124,1.0913835,1.0944142,1.0975055,1.1006578,1.1038722,1.1071492,1.11049,1.1138949,1.1173654,1.1209018,1.1245055,1.1281772,1.1319177,1.1357284,1.1396098,1.1435635,1.14759,1.151691,1.1558671,1.1601195,1.1644499,1.1688588,1.1733481,1.1779186,1.1825719,1.1873093,1.192132,1.1970417,1.2020397,1.2071277,1.2123071,1.2175792,1.2229464,1.2284095,1.233971,1.239632,1.2453951,1.2512616,1.2572334,1.2633129,1.2695018,1.2758025,1.2822168,1.2887474,1.2953964,1.3021659,1.3090588,1.3160771,1.3232241,1.3305017,1.3379133,1.3454614,1.3531487,1.360979,1.3689543,1.3770789,1.3853556,1.3937875,1.4023789,1.4111327,1.4200534,1.4291439,1.4384094,1.4478533,1.4574798,1.467294,1.4772996,1.4875023,1.4979062,1.5085171,1.5193402,1.5303799,1.5416433,1.553135,1.5648621,1.5768301,1.5890466,1.6015176,1.6142496,1.6272513,1.6405288,1.6540914,1.6679466,1.6821024,1.6965687,1.711354,1.7264686,1.7419213,1.757724,1.773887,1.7904207,1.8073385,1.8246511,1.8423728,1.8605158,1.8790957,1.8981259,1.9176216,1.9376001,1.9580767,1.9790708,2.000599,2.0226824,2.0453408,2.0685942,2.0924673,2.1169815,2.1421638,2.168038,2.1946337,2.2219791,2.2501037,2.2790418,2.3088253,2.3394923,2.3710804,2.4036279,2.4371808,2.4717813,2.5074804,2.5443265,2.5823767,2.621688,2.6623192,2.7043407,2.7478182,2.7928307,2.839455,2.8877804,2.9378977,2.9899032,3.043908,3.100022,3.1583736,3.2190914,3.2823246,3.3482265,3.4169643,3.4887273,3.56371,3.6421378,3.7242455,3.810291,3.9005687,3.9953856,4.0950975,4.20008,4.310766,4.427624,4.551174,4.682013,4.8207884,4.96825,5.1252203,5.2926564,5.471626,5.6633453,5.8692384,6.0909066,6.330247,6.5894256,6.8710294,7.1780744,7.5141397,7.8835635,8.291515,8.744378,9.249954,9.8179655,10.460772,11.194088,12.038517,13.021254,14.179363,15.564263,17.24965,19.345325,22.021492,25.558304,30.449753,37.658844,49.342915,71.541275,130.06038,714.54565,-204.49576,-89.451965,-57.247154,-42.093998,-33.285187,-27.525837,-23.466513,-20.451193,-18.123178,-16.271654,-14.763849,-13.512325,-12.456816,-11.554718,-10.77482,-10.093921,-9.49434,-8.962309,-8.487077,-8.059992,-7.674136,-7.323798,-7.0043163,-6.7118087,-6.4429855,-6.195114,-5.965825,-5.753131,-5.5552855,-5.3708,-5.1983805,-5.036873,-4.885292,-4.742745,-4.6084633,-4.481743,-4.3619733,-4.2486067,-4.1411386,-4.0391335,-3.9421809,-3.8499222,-3.762032,-3.678204,-3.5981731,-3.521684,-3.4485152,-3.3784535,-3.31131,-3.246912,-3.185092,-3.125706,-3.0686107,-3.013683,-2.9608002,-2.9098547,-2.8607457,-2.813374,-2.7676556,-2.7235036,-2.680844,-2.6396015,-2.59971,-2.5611076,-2.5237317,-2.4875295,-2.4524455,-2.4184315,-2.3854427,-2.3534322,-2.3223615,-2.2921886,-2.2628794,-2.2343962,-2.2067075,-2.1797829,-2.1535904,-2.128104,-2.103295,-2.0791404,-2.0556135,-2.0326927,-2.010357,-1.9885836,-1.9673545,-1.9466494,-1.9264519,-1.9067429,-1.8875071,-1.8687295,-1.8503934,-1.8324863,-1.8149928,-1.7979007,-1.7811978,-1.7648711,-1.7489101,-1.7333026,-1.718039,-1.7031081,-1.6885008,-1.6742082,-1.66022,-1.6465287,-1.6331251,-1.6200019,-1.6071506,-1.594564,-1.5822357,-1.5701578,-1.5583243,-1.5467284,-1.5353643,-1.5242256,-1.5133066,-1.5026025,-1.4921068,-1.4818155,-1.4717225,-1.4618235,-1.4521143,-1.4425895,-1.4332454,-1.4240774,-1.4150817,-1.4062539,-1.3975906,-1.3890884,-1.3807429,-1.3725513,-1.3645097,-1.3566155,-1.3488648,-1.3412551,-1.3337833,-1.3264463,-1.3192416,-1.3121662,-1.305218,-1.2983937,-1.2916913,-1.2851086,-1.2786427,-1.2722918,-1.2660532,-1.2599254,-1.2539058,-1.2479928,-1.242184,-1.2364777,-1.2308722,-1.2253654,-1.2199558,-1.2146417,-1.2094212,-1.2042927,-1.1992548,-1.194306,-1.1894448,-1.1846696,-1.1799791,-1.1753719,-1.1708466,-1.166402,-1.1620369,-1.1577499,-1.1535399,-1.1494057,-1.1453462,-1.1413603,-1.1374468,-1.1336048,-1.1298332,-1.1261309,-1.1224972,-1.1189309,-1.1154312,-1.1119971,-1.1086279,-1.1053226,-1.1020805,-1.0989007,-1.0957823,-1.0927247,-1.089727,-1.0867888,-1.083909,-1.0810872,-1.0783224,-1.0756143,-1.0729622,-1.0703652,-1.0678229,-1.0653348,-1.0629002,-1.0605184,-1.0581892,-1.0559118,-1.0536857,-1.0515106,-1.0493859,-1.047311,-1.0452856,-1.0433092,-1.0413815,-1.0395018,-1.0376698,-1.0358853,-1.0341477,-1.0324568,-1.0308119,-1.0292131,-1.0276598,-1.0261517,-1.0246884,-1.0232697,-1.0218953,-1.020565,-1.0192784,-1.0180352,-1.0168352,-1.0156783,-1.0145639,-1.0134921,-1.0124626,-1.0114752,-1.0105295,-1.0096256,-1.0087631,-1.007942,-1.007162,-1.0064229,-1.0057248,-1.0050672,-1.0044503,-1.0038738,-1.0033377,-1.0028418,-1.002386,-1.0019702,-1.0015944,-1.0012585,-1.0009624,-1.000706,-1.0004892,-1.0003122,-1.0001748,-1.000077,-1.0000187,-1.0,-1.0000209,-1.0000813,-1.0001813,-1.0003209,-1.0005002,-1.000719,-1.0009776,-1.0012759,-1.0016141,-1.0019921,-1.00241,-1.002868,-1.0033662,-1.0039046,-1.0044832,-1.0051024,-1.0057621,-1.0064626,-1.0072038,-1.0079861,-1.0088094,-1.0096742,-1.0105804,-1.0115284,-1.0125182,-1.01355,-1.0146241,-1.0157408,-1.0169002,-1.0181025,-1.019348,-1.020637,-1.0219698,-1.0233467,-1.0247676,-1.0262333,-1.027744,-1.0292999,-1.0309012,-1.0325485,-1.034242,-1.0359823,-1.0377694,-1.039604,-1.0414863,-1.0434166,-1.0453957,-1.0474237,-1.0495013,-1.051629,-1.0538068,-1.0560358,-1.0583159,-1.0606481,-1.0630326,-1.0654702,-1.0679613,-1.0705066,-1.0731066,-1.0757618,-1.0784731,-1.0812409,-1.0840659,-1.0869489,-1.0898905,-1.0928913,-1.0959523,-1.0990739,-1.1022571,-1.1055028,-1.1088116,-1.1121843,-1.1156219,-1.1191252,-1.1226953,-1.1263328,-1.1300387,-1.1338142,-1.1376601,-1.1415775,-1.1455675,-1.1496311,-1.1537695,-1.1579837,-1.162275,-1.1666445,-1.1710933,-1.175623,-1.1802349,-1.18493,-1.1897099,-1.1945759,-1.1995296,-1.2045724,-1.2097058,-1.2149314,-1.2202508,-1.2256658,-1.2311779,-1.2367889,-1.2425008,-1.2483152,-1.2542341,-1.2602596,-1.2663935,-1.272638,-1.2789953,-1.2854675,-1.2920569,-1.2987659,-1.3055967,-1.3125521,-1.3196344,-1.3268464,-1.3341906,-1.34167,-1.3492875,-1.3570459,-1.3649483,-1.3729979,-1.381198,-1.3895519,-1.398063,-1.4067353,-1.4155719,-1.4245771,-1.4337547,-1.4431087,-1.4526434,-1.4623631,-1.4722726,-1.4823761,-1.4926789,-1.5031856,-1.5139017,-1.5248322,-1.5359832,-1.5473601,-1.5589689,-1.5708158,-1.5829071,-1.5952495,-1.6078503,-1.6207163,-1.6338549,-1.6472743,-1.6609818,-1.6749861,-1.6892961,-1.703921,-1.7188694,-1.734152,-1.7497785,-1.7657597,-1.7821065,-1.798831,-1.8159446,-1.8334601,-1.851391,-1.8697506,-1.8885533,-1.9078145,-1.9275496,-1.947775,-1.968508,-1.989767,-2.0115705,-2.0339384,-2.0568917,-2.080452,-2.1046426,-2.1294878,-2.1550128,-2.1812444,-2.2082107,-2.235942,-2.2644691,-2.2938256,-2.3240464,-2.3551686,-2.3872313,-2.420276,-2.454347,-2.4894905,-2.5257568,-2.563198,-2.6018705,-2.641834,-2.683152,-2.7258925,-2.7701285,-2.8159363,-2.8634002,-2.9126086,-2.9636574,-3.016649,-3.0716937,-3.1289108,-3.1884286,-3.2503848,-3.3149312,-3.382229,-3.4524558,-3.5258029,-3.6024797,-3.6827147,-3.7667577,-3.8548818,-3.947388,-4.0446076,-4.1469045,-4.254683,-4.368391,-4.488526,-4.6156435,-4.750364,-4.8933845,-5.0454907,-5.2075686,-5.3806252,-5.5658064,-5.764425,-5.977989,-6.208241,-6.4572067,-6.727252,-7.021159,-7.342226,-7.694381,-8.0823555,-8.5118885,-8.990013,-9.525448,-10.1291275,-10.814958,-11.6009,-12.510559,-13.575597,-14.839483,-16.36358,-18.237381,-20.59674,-23.658337,-27.790323,-33.67267,-42.716003,-58.403515,-92.30705,-220.06412,572.95807],"x":[-359.9,-359.53964,-359.1793,-358.8189,-358.45856,-358.0982,-357.73782,-357.37747,-357.01712,-356.65677,-356.2964,-355.93604,-355.57568,-355.2153,-354.85495,-354.4946,-354.13425,-353.77386,-353.4135,-353.05316,-352.69278,-352.33243,-351.97208,-351.61172,-351.25134,-350.891,-350.53064,-350.17026,-349.8099,-349.44955,-349.0892,-348.72882,-348.36847,-348.00812,-347.64774,-347.28738,-346.92703,-346.56668,-346.2063,-345.84595,-345.4856,-345.1252,-344.76486,-344.4045,-344.04416,-343.68378,-343.32343,-342.96307,-342.6027,-342.24234,-341.882,-341.5216,-341.16125,-340.8009,-340.44055,-340.08017,-339.71982,-339.35947,-338.99908,-338.63873,-338.27838,-337.91803,-337.55765,-337.1973,-336.83694,-336.47656,-336.1162,-335.75586,-335.3955,-335.03513,-334.67477,-334.31442,-333.95404,-333.5937,-333.23334,-332.873,-332.5126,-332.15225,-331.7919,-331.43152,-331.07117,-330.71082,-330.35046,-329.99008,-329.62973,-329.26938,-328.909,-328.54865,-328.1883,-327.82794,-327.46756,-327.1072,-326.74686,-326.38647,-326.02612,-325.66577,-325.30542,-324.94504,-324.5847,-324.22433,-323.86395,-323.5036,-323.14325,-322.7829,-322.42252,-322.06216,-321.7018,-321.34143,-320.98108,-320.62073,-320.26035,-319.9,-319.53964,-319.1793,-318.8189,-318.45856,-318.0982,-317.73782,-317.37747,-317.01712,-316.65677,-316.2964,-315.93604,-315.57568,-315.2153,-314.85495,-314.4946,-314.13425,-313.77386,-313.4135,-313.05316,-312.69278,-312.33243,-311.97208,-311.61172,-311.25134,-310.891,-310.53064,-310.17026,-309.8099,-309.44955,-309.0892,-308.72882,-308.36847,-308.00812,-307.64774,-307.28738,-306.92703,-306.56668,-306.2063,-305.84595,-305.4856,-305.1252,-304.76486,-304.4045,-304.04416,-303.68378,-303.32343,-302.96307,-302.6027,-302.24234,-301.882,-301.5216,-301.16125,-300.8009,-300.44055,-300.08017,-299.71982,-299.35947,-298.99908,-298.63873,-298.27838,-297.91803,-297.55765,-297.1973,-296.83694,-296.47656,-296.1162,-295.75586,-295.3955,-295.03513,-294.67477,-294.31442,-293.95404,-293.5937,-293.23334,-292.873,-292.5126,-292.15225,-291.7919,-291.43152,-291.07117,-290.71082,-290.35046,-289.99008,-289.62973,-289.26938,-288.909,-288.54865,-288.1883,-287.82794,-287.46756,-287.1072,-286.74686,-286.38647,-286.02612,-285.66577,-285.30542,-284.94504,-284.5847,-284.22433,-283.86395,-283.5036,-283.14325,-282.7829,-282.42252,-282.06216,-281.7018,-281.34143,-280.98108,-280.62073,-280.26035,-279.9,-279.53964,-279.1793,-278.8189,-278.45856,-278.0982,-277.73782,-277.37747,-277.01712,-276.65677,-276.2964,-275.93604,-275.57568,-275.2153,-274.85495,-274.4946,-274.13425,-273.77386,-273.4135,-273.05316,-272.69278,-272.33243,-271.97208,-271.61172,-271.25134,-270.891,-270.53064,-270.17026,-269.8099,-269.44955,-269.0892,-268.72882,-268.36847,-268.00812,-267.64774,-267.28738,-266.92703,-266.56668,-266.2063,-265.84595,-265.4856,-265.1252,-264.76486,-264.4045,-264.04416,-263.68378,-263.32343,-262.96307,-262.6027,-262.24234,-261.882,-261.5216,-261.16125,-260.8009,-260.44055,-260.08017,-259.71982,-259.35947,-258.99908,-258.63873,-258.27838,-257.91803,-257.55765,-257.1973,-256.83694,-256.47656,-256.1162,-255.75586,-255.3955,-255.03514,-254.67477,-254.3144,-253.95406,-253.59369,-253.23334,-252.87297,-252.51262,-252.15225,-251.79189,-251.43153,-251.07117,-250.71082,-250.35045,-249.9901,-249.62973,-249.26936,-248.90901,-248.54865,-248.1883,-247.82793,-247.46758,-247.10721,-246.74684,-246.38649,-246.02612,-245.66577,-245.3054,-244.94504,-244.58469,-244.22432,-243.86397,-243.5036,-243.14325,-242.78288,-242.42252,-242.06216,-241.7018,-241.34145,-240.98108,-240.62073,-240.26036,-239.9,-239.53964,-239.17928,-238.81892,-238.45856,-238.0982,-237.73784,-237.37747,-237.01712,-236.65675,-236.2964,-235.93604,-235.57567,-235.21532,-234.85495,-234.4946,-234.13423,-233.77388,-233.41351,-233.05315,-232.6928,-232.33243,-231.97208,-231.61171,-231.25136,-230.89099,-230.53062,-230.17027,-229.8099,-229.44955,-229.08919,-228.72884,-228.36847,-228.0081,-227.64775,-227.28738,-226.92703,-226.56667,-226.2063,-225.84595,-225.48558,-225.12523,-224.76486,-224.40451,-224.04414,-223.68378,-223.32343,-222.96306,-222.6027,-222.24234,-221.88199,-221.52162,-221.16125,-220.8009,-220.44054,-220.08018,-219.71982,-219.35947,-218.9991,-218.63873,-218.27838,-217.91801,-217.55766,-217.1973,-216.83693,-216.47658,-216.11621,-215.75586,-215.3955,-215.03514,-214.67477,-214.3144,-213.95406,-213.59369,-213.23334,-212.87297,-212.51262,-212.15225,-211.79189,-211.43153,-211.07117,-210.71082,-210.35045,-209.9901,-209.62973,-209.26936,-208.90901,-208.54865,-208.1883,-207.82793,-207.46758,-207.10721,-206.74684,-206.38649,-206.02612,-205.66577,-205.3054,-204.94504,-204.58469,-204.22432,-203.86397,-203.5036,-203.14325,-202.78288,-202.42252,-202.06216,-201.7018,-201.34145,-200.98108,-200.62073,-200.26036,-199.9,-199.53964,-199.17928,-198.81892,-198.45856,-198.0982,-197.73784,-197.37747,-197.01712,-196.65675,-196.2964,-195.93604,-195.57567,-195.21532,-194.85495,-194.4946,-194.13423,-193.77388,-193.41351,-193.05315,-192.6928,-192.33243,-191.97208,-191.61171,-191.25136,-190.89099,-190.53062,-190.17027,-189.8099,-189.44955,-189.08919,-188.72884,-188.36847,-188.0081,-187.64775,-187.28738,-186.92703,-186.56667,-186.2063,-185.84595,-185.48558,-185.12523,-184.76486,-184.40451,-184.04414,-183.68378,-183.32343,-182.96306,-182.6027,-182.24234,-181.88199,-181.52162,-181.16125,-180.8009,-180.44054,-180.08018,-179.71982,-179.35947,-178.9991,-178.63873,-178.27838,-177.91801,-177.55766,-177.1973,-176.83693,-176.47658,-176.11621,-175.75586,-175.3955,-175.03514,-174.67477,-174.3144,-173.95406,-173.59369,-173.23334,-172.87297,-172.51262,-172.15225,-171.79189,-171.43153,-171.07117,-170.71082,-170.35045,-169.9901,-169.62973,-169.26936,-168.90901,-168.54865,-168.1883,-167.82793,-167.46758,-167.10721,-166.74684,-166.38649,-166.02612,-165.66577,-165.3054,-164.94504,-164.58469,-164.22432,-163.86397,-163.5036,-163.14325,-162.78288,-162.42252,-162.06216,-161.7018,-161.34145,-160.98108,-160.62073,-160.26036,-159.9,-159.53964,-159.17928,-158.81892,-158.45856,-158.0982,-157.73784,-157.37747,-157.01712,-156.65675,-156.2964,-155.93604,-155.57567,-155.21532,-154.85495,-154.4946,-154.13423,-153.77388,-153.41351,-153.05315,-152.6928,-152.33243,-151.97208,-151.61171,-151.25136,-150.89099,-150.53062,-150.17027,-149.8099,-149.44955,-149.08919,-148.72884,-148.36847,-148.0081,-147.64775,-147.28738,-146.92703,-146.56667,-146.2063,-145.84595,-145.48558,-145.12523,-144.76486,-144.40451,-144.04414,-143.68378,-143.32343,-142.96306,-142.6027,-142.24234,-141.88199,-141.52162,-141.16125,-140.8009,-140.44054,-140.08018,-139.71982,-139.35947,-138.9991,-138.63873,-138.27838,-137.91801,-137.55766,-137.1973,-136.83693,-136.47658,-136.11621,-135.75586,-135.3955,-135.03514,-134.67477,-134.3144,-133.95406,-133.59369,-133.23334,-132.87297,-132.51262,-132.15225,-131.79189,-131.43153,-131.07117,-130.71082,-130.35045,-129.9901,-129.62973,-129.26936,-128.90901,-128.54865,-128.1883,-127.82793,-127.46757,-127.10721,-126.74685,-126.38649,-126.02612,-125.665764,-125.305405,-124.945045,-124.58469,-124.22433,-123.86396,-123.5036,-123.14324,-122.78288,-122.42252,-122.062164,-121.701805,-121.34144,-120.98108,-120.62072,-120.26036,-119.9,-119.53964,-119.179276,-118.81892,-118.45856,-118.0982,-117.73784,-117.37748,-117.01712,-116.65675,-116.296394,-115.936035,-115.575676,-115.21532,-114.85496,-114.4946,-114.13423,-113.77387,-113.41351,-113.053154,-112.692795,-112.332436,-111.97207,-111.61171,-111.25135,-110.89099,-110.53063,-110.17027,-109.80991,-109.44955,-109.08919,-108.72883,-108.36847,-108.00811,-107.64775,-107.287384,-106.927025,-106.566666,-106.20631,-105.84595,-105.48559,-105.12523,-104.76486,-104.4045,-104.04414,-103.683784,-103.323425,-102.963066,-102.6027,-102.24234,-101.88198,-101.52162,-101.16126,-100.8009,-100.440544,-100.08018,-99.71982,-99.35946,-98.9991,-98.63874,-98.27838,-97.918015,-97.557655,-97.197296,-96.83694,-96.47658,-96.11622,-95.75586,-95.39549,-95.03513,-94.674774,-94.314415,-93.954056,-93.5937,-93.23333,-92.87297,-92.51261,-92.15225,-91.79189,-91.43153,-91.071175,-90.71081,-90.35045,-89.99009,-89.62973,-89.26937,-88.90901,-88.548645,-88.188286,-87.82793,-87.46757,-87.10721,-86.74685,-86.38649,-86.02612,-85.665764,-85.305405,-84.945045,-84.58469,-84.22433,-83.86396,-83.5036,-83.14324,-82.78288,-82.42252,-82.062164,-81.701805,-81.34144,-80.98108,-80.62072,-80.26036,-79.9,-79.53964,-79.179276,-78.81892,-78.45856,-78.0982,-77.73784,-77.37748,-77.01712,-76.65675,-76.296394,-75.936035,-75.575676,-75.21532,-74.85496,-74.4946,-74.13423,-73.77387,-73.41351,-73.053154,-72.692795,-72.332436,-71.97207,-71.61171,-71.25135,-70.89099,-70.53063,-70.17027,-69.80991,-69.44955,-69.08919,-68.72883,-68.36847,-68.00811,-67.64775,-67.287384,-66.927025,-66.566666,-66.20631,-65.84595,-65.48559,-65.12523,-64.76486,-64.4045,-64.04414,-63.683784,-63.323425,-62.963062,-62.602703,-62.242344,-61.88198,-61.52162,-61.161263,-60.8009,-60.44054,-60.08018,-59.71982,-59.35946,-58.9991,-58.63874,-58.278378,-57.91802,-57.55766,-57.197296,-56.836937,-56.476578,-56.116215,-55.755856,-55.395496,-55.035133,-54.674774,-54.314415,-53.954056,-53.593693,-53.233334,-52.872974,-52.51261,-52.152252,-51.791893,-51.43153,-51.07117,-50.71081,-50.35045,-49.99009,-49.62973,-49.26937,-48.909008,-48.54865,-48.18829,-47.827927,-47.467567,-47.10721,-46.746845,-46.386486,-46.026127,-45.665768,-45.305405,-44.945045,-44.584686,-44.224323,-43.863964,-43.503605,-43.14324,-42.782883,-42.422523,-42.06216,-41.7018,-41.341442,-40.981083,-40.62072,-40.26036,-39.9,-39.53964,-39.17928,-38.81892,-38.458557,-38.098198,-37.73784,-37.377476,-37.017117,-36.656757,-36.2964,-35.936035,-35.575676,-35.215317,-34.854954,-34.494595,-34.134235,-33.773872,-33.413513,-33.053154,-32.69279,-32.33243,-31.972073,-31.611712,-31.25135,-30.890991,-30.53063,-30.17027,-29.80991,-29.449549,-29.08919,-28.728828,-28.36847,-28.008108,-27.647747,-27.287388,-26.927027,-26.566668,-26.206306,-25.845945,-25.485586,-25.125225,-24.764864,-24.404505,-24.044144,-23.683784,-23.323423,-22.963062,-22.602703,-22.242342,-21.881983,-21.521622,-21.16126,-20.800901,-20.44054,-20.080181,-19.71982,-19.359459,-18.9991,-18.638739,-18.278378,-17.918018,-17.557657,-17.197298,-16.836937,-16.476576,-16.116217,-15.755856,-15.395495,-15.035135,-14.674775,-14.314414,-13.954054,-13.593694,-13.233334,-12.872973,-12.512612,-12.152252,-11.791892,-11.431532,-11.071171,-10.710811,-10.3504505,-9.99009,-9.629729,-9.269369,-8.909009,-8.548649,-8.188289,-7.827928,-7.4675674,-7.1072073,-6.7468467,-6.3864865,-6.026126,-5.665766,-5.3054056,-4.945045,-4.584685,-4.224324,-3.863964,-3.5036037,-3.1432433,-2.782883,-2.4225225,-2.0621622,-1.7018018,-1.3414414,-0.98108107,-0.62072074,-0.26036036,0.1]}
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/positive.json b/lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/positive.json
new file mode 100644
index 000000000000..5ed83eafc889
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/positive.json
@@ -0,0 +1 @@
+{"expected":[572.95807,124.51402,69.84801,48.539417,37.194065,30.148499,25.347918,21.86689,19.227184,17.15675,15.489418,14.117962,12.970084,11.995268,11.15715,10.428889,9.790237,9.2256365,8.72293,8.272489,7.866579,7.498923,7.164368,6.8586493,6.578203,6.320031,6.0815897,5.8607087,5.6555257,5.4644327,5.2860327,5.119109,4.9625955,4.8155527,4.6771526,4.5466604,4.423422,4.306854,4.196433,4.0916905,3.9922032,3.8975892,3.8075035,3.7216313,3.639688,3.5614128,3.4865685,3.4149375,3.3463202,3.2805328,3.2174075,3.1567874,3.0985298,3.042502,2.9885795,2.9366493,2.8866057,2.8383489,2.7917876,2.7468362,2.7034144,2.6614478,2.6208658,2.5816035,2.5435996,2.5067954,2.4711375,2.4365747,2.4030592,2.3705456,2.3389912,2.3083558,2.2786014,2.2496922,2.2215939,2.1942742,2.1677034,2.1418517,2.116692,2.0921984,2.0683458,2.045111,2.0224712,2.0004056,1.9788935,1.9579158,1.9374537,1.9174901,1.898008,1.878991,1.8604244,1.8422931,1.8245832,1.8072813,1.7903743,1.7738503,1.7576973,1.7419044,1.7264599,1.7113541,1.6965767,1.6821183,1.6679697,1.6541219,1.6405662,1.6272948,1.6142998,1.6015733,1.5891081,1.5768976,1.5649346,1.5532125,1.5417253,1.5304667,1.5194311,1.5086125,1.4980057,1.4876053,1.4774064,1.4674039,1.4575933,1.4479698,1.4385289,1.4292665,1.4201783,1.4112604,1.402509,1.3939201,1.3854901,1.3772155,1.3690931,1.3611194,1.353291,1.3456053,1.3380587,1.3306487,1.3233722,1.3162268,1.3092095,1.3023179,1.2955492,1.2889012,1.2823715,1.275958,1.269658,1.2634697,1.2573909,1.2514193,1.2455534,1.2397909,1.23413,1.2285689,1.2231058,1.2177389,1.2124667,1.2072874,1.2021995,1.1972014,1.1922916,1.1874686,1.1827312,1.1780776,1.1735066,1.1690171,1.1646076,1.160277,1.156024,1.1518474,1.147746,1.1437187,1.1397644,1.1358823,1.1320709,1.1283296,1.124657,1.1210527,1.1175152,1.1140441,1.110638,1.1072963,1.1040183,1.1008029,1.0976495,1.0945572,1.0915252,1.088553,1.0856395,1.0827844,1.0799868,1.0772461,1.0745616,1.0719328,1.0693588,1.0668392,1.0643735,1.061961,1.0596012,1.0572935,1.0550375,1.0528326,1.0506784,1.0485742,1.0465198,1.0445145,1.0425581,1.04065,1.0387899,1.0369772,1.0352117,1.033493,1.0318208,1.0301945,1.0286139,1.0270787,1.0255886,1.0241432,1.0227423,1.0213854,1.0200723,1.018803,1.0175768,1.0163938,1.0152534,1.0141559,1.0131005,1.0120873,1.0111161,1.0101867,1.0092988,1.0084522,1.0076468,1.0068825,1.0061591,1.0054764,1.0048343,1.0042326,1.0036714,1.0031503,1.0026696,1.0022287,1.0018278,1.0014669,1.0011456,1.0008641,1.0006224,1.0004202,1.0002577,1.0001347,1.0000513,1.0000074,1.000003,1.0000381,1.0001128,1.0002269,1.0003806,1.000574,1.0008069,1.0010796,1.001392,1.001744,1.0021361,1.002568,1.00304,1.0035521,1.0041044,1.0046971,1.0053301,1.0060037,1.0067182,1.0074733,1.0082695,1.0091069,1.0099857,1.0109059,1.0118679,1.0128716,1.0139176,1.0150057,1.0161365,1.01731,1.0185266,1.0197864,1.0210897,1.0224367,1.0238279,1.0252634,1.0267435,1.0282687,1.0298392,1.0314552,1.0331173,1.0348256,1.0365807,1.0383828,1.0402322,1.0421296,1.0440753,1.0460696,1.0481131,1.0502062,1.0523492,1.0545429,1.0567875,1.0590836,1.0614318,1.0638325,1.0662863,1.0687939,1.0713556,1.0739723,1.0766443,1.0793725,1.0821575,1.0849997,1.0879,1.0908592,1.0938778,1.0969566,1.1000963,1.103298,1.106562,1.1098894,1.1132811,1.1167377,1.1202604,1.1238499,1.1275071,1.1312331,1.1350287,1.138895,1.1428331,1.146844,1.1509289,1.1550887,1.1593246,1.163638,1.1680298,1.1725014,1.1770542,1.1816893,1.1864079,1.1912118,1.1961021,1.2010804,1.2061483,1.2113072,1.2165586,1.2219043,1.2273458,1.232885,1.2385235,1.2442632,1.250106,1.2560538,1.2621086,1.2682724,1.2745473,1.2809354,1.2874392,1.2940606,1.3008024,1.3076663,1.3146557,1.3217723,1.3290194,1.3363994,1.3439155,1.3515699,1.3593664,1.3673074,1.3753964,1.3836371,1.3920319,1.4005854,1.4093002,1.4181811,1.4272307,1.4364543,1.4458549,1.4554377,1.4652061,1.4751655,1.4853204,1.4956753,1.5062361,1.5170069,1.5279939,1.5392023,1.5506384,1.5623076,1.5742167,1.5863715,1.5987792,1.6114471,1.6243817,1.6375912,1.6510828,1.664865,1.6789459,1.6933349,1.7080404,1.7230725,1.7384405,1.7541549,1.7702273,1.7866673,1.8034884,1.8207011,1.8383195,1.8563558,1.8748248,1.8937397,1.9131178,1.9329726,1.9533218,1.9741838,1.995575,2.0175164,2.040026,2.0631273,2.08684,2.1111896,2.1361985,2.1618946,2.1883025,2.2154539,2.2433755,2.2721012,2.3016653,2.3321009,2.3634484,2.3957446,2.4290342,2.4633596,2.4987702,2.535314,2.5730476,2.6120243,2.6523063,2.6939604,2.7370512,2.7816572,2.8278522,2.8757253,2.9253628,2.9768658,3.030334,3.085885,3.1436348,3.2037163,3.266273,3.331453,3.3994274,3.4703705,3.5444837,3.6219745,3.7030826,3.788056,3.8771806,3.9707572,4.0691276,4.172669,4.2817864,4.396947,4.5186515,4.6474805,4.784059,4.9291153,5.083443,5.2479687,5.4237137,5.6118674,5.813791,6.0310254,6.265392,6.5189667,6.7942243,7.0940323,7.4218407,7.7817197,8.178635,8.618555,9.108894,9.658773,10.279739,10.986531,11.798156,12.739847,13.845449,15.161898,16.755646,18.724728,21.219072,24.481373,28.930159,35.356606,45.45634,63.635902,106.058235,318.16153,-318.16153,-106.058235,-63.635902,-45.45634,-35.356606,-28.930159,-24.481373,-21.219072,-18.724728,-16.755646,-15.161898,-13.845449,-12.739847,-11.798156,-10.986531,-10.279739,-9.658773,-9.108894,-8.618555,-8.178635,-7.7817197,-7.4218407,-7.0940323,-6.7942243,-6.5189667,-6.265392,-6.0310254,-5.813791,-5.6118674,-5.4237137,-5.2479687,-5.083443,-4.9291153,-4.784059,-4.6474805,-4.5186515,-4.396947,-4.2817864,-4.172669,-4.0691276,-3.9707572,-3.8771806,-3.788056,-3.7030826,-3.6219745,-3.5444837,-3.4703705,-3.3994274,-3.331453,-3.266273,-3.2037163,-3.1436348,-3.085885,-3.030334,-2.9768658,-2.9253628,-2.8757253,-2.8278522,-2.7816572,-2.7370512,-2.6939604,-2.6523063,-2.6120243,-2.5730476,-2.535314,-2.4987702,-2.4633596,-2.4290342,-2.3957446,-2.3634484,-2.3321009,-2.3016653,-2.2721012,-2.2433755,-2.2154539,-2.1883025,-2.1618946,-2.1361985,-2.1111896,-2.08684,-2.0631273,-2.040026,-2.0175164,-1.995575,-1.9741838,-1.9533218,-1.9329726,-1.9131178,-1.8937397,-1.8748248,-1.8563558,-1.8383195,-1.8207011,-1.8034884,-1.7866673,-1.7702273,-1.7541549,-1.7384405,-1.7230725,-1.7080404,-1.6933349,-1.6789459,-1.664865,-1.6510828,-1.6375912,-1.6243817,-1.6114471,-1.5987792,-1.5863715,-1.5742167,-1.5623076,-1.5506384,-1.5392023,-1.5279939,-1.5170069,-1.5062361,-1.4956753,-1.4853204,-1.4751655,-1.4652061,-1.4554377,-1.4458549,-1.4364543,-1.4272307,-1.4181811,-1.4093002,-1.4005854,-1.3920319,-1.3836371,-1.3753964,-1.3673074,-1.3593664,-1.3515699,-1.3439155,-1.3363994,-1.3290194,-1.3217723,-1.3146557,-1.3076663,-1.3008024,-1.2940606,-1.2874392,-1.2809354,-1.2745473,-1.2682726,-1.2621086,-1.2560539,-1.250106,-1.2442632,-1.2385234,-1.232885,-1.2273456,-1.2219043,-1.2165585,-1.2113072,-1.2061484,-1.2010804,-1.1961021,-1.1912118,-1.186408,-1.1816891,-1.1770542,-1.1725014,-1.1680298,-1.1636379,-1.1593246,-1.1550888,-1.1509289,-1.1468441,-1.1428331,-1.138895,-1.1350286,-1.1312331,-1.127507,-1.1238499,-1.1202604,-1.1167377,-1.1132811,-1.1098894,-1.106562,-1.103298,-1.1000965,-1.0969566,-1.0938778,-1.0908592,-1.0879,-1.0849997,-1.0821575,-1.0793724,-1.0766443,-1.0739723,-1.0713556,-1.0687939,-1.0662863,-1.0638325,-1.0614318,-1.0590836,-1.0567875,-1.0545429,-1.0523492,-1.0502062,-1.0481131,-1.0460696,-1.0440754,-1.0421296,-1.0402322,-1.0383826,-1.0365807,-1.0348256,-1.0331173,-1.0314552,-1.0298393,-1.0282688,-1.0267435,-1.0252634,-1.0238279,-1.0224367,-1.0210897,-1.0197864,-1.0185266,-1.01731,-1.0161365,-1.0150057,-1.0139176,-1.0128716,-1.0118678,-1.0109059,-1.0099857,-1.0091069,-1.0082695,-1.0074733,-1.0067182,-1.0060037,-1.0053301,-1.0046971,-1.0041044,-1.0035521,-1.0030401,-1.002568,-1.0021361,-1.001744,-1.001392,-1.0010796,-1.0008069,-1.000574,-1.0003806,-1.0002269,-1.0001128,-1.0000381,-1.000003,-1.0000074,-1.0000513,-1.0001347,-1.0002577,-1.0004202,-1.0006224,-1.0008641,-1.0011456,-1.0014669,-1.0018277,-1.0022287,-1.0026696,-1.0031503,-1.0036714,-1.0042326,-1.0048343,-1.0054764,-1.0061591,-1.0068825,-1.0076468,-1.0084522,-1.0092988,-1.0101867,-1.0111161,-1.0120873,-1.0131005,-1.0141559,-1.0152535,-1.0163938,-1.0175768,-1.018803,-1.0200723,-1.0213854,-1.0227423,-1.0241432,-1.0255886,-1.0270787,-1.028614,-1.0301946,-1.0318208,-1.033493,-1.0352118,-1.0369772,-1.0387897,-1.04065,-1.0425581,-1.0445144,-1.0465198,-1.0485742,-1.0506784,-1.0528325,-1.0550375,-1.0572935,-1.0596011,-1.0619609,-1.0643735,-1.0668393,-1.0693587,-1.0719327,-1.0745616,-1.0772462,-1.0799867,-1.0827844,-1.0856396,-1.0885527,-1.0915251,-1.0945572,-1.0976495,-1.1008028,-1.1040182,-1.1072965,-1.1106381,-1.114044,-1.1175152,-1.1210527,-1.1246573,-1.1283295,-1.1320709,-1.1358824,-1.1397643,-1.1437186,-1.147746,-1.1518474,-1.1560237,-1.160277,-1.1646078,-1.1690173,-1.1735065,-1.1780776,-1.1827312,-1.1874685,-1.1922915,-1.1972015,-1.2021997,-1.2072873,-1.2124667,-1.2177391,-1.2231059,-1.2285688,-1.23413,-1.239791,-1.2455531,-1.2514193,-1.2573909,-1.2634699,-1.2696577,-1.2759578,-1.2823716,-1.2889016,-1.295549,-1.3023179,-1.3092096,-1.3162266,-1.3233721,-1.3306488,-1.338059,-1.345605,-1.353291,-1.3611195,-1.3690934,-1.3772154,-1.3854901,-1.3939202,-1.4025086,-1.4112602,-1.4201784,-1.4292667,-1.4385285,-1.4479697,-1.4575933,-1.4674044,-1.4774061,-1.4876053,-1.4980059,-1.5086119,-1.5194308,-1.5304668,-1.5417255,-1.553212,-1.5649344,-1.5768977,-1.5891087,-1.601573,-1.6142998,-1.6272951,-1.6405658,-1.6541216,-1.6679697,-1.6821188,-1.6965764,-1.711354,-1.7264601,-1.7419049,-1.757697,-1.7738503,-1.7903746,-1.8072804,-1.8245828,-1.8422931,-1.8604248,-1.8789904,-1.8980078,-1.9174904,-1.9374546,-1.9579151,-1.9788935,-2.000406,-2.0224705,-2.0451105,-2.0683458,-2.092199,-2.116691,-2.1418514,-2.1677036,-2.1942754,-2.221593,-2.249692,-2.278602,-2.308357,-2.3389904,-2.3705456,-2.40306,-2.4365735,-2.471137,-2.506796,-2.5436006,-2.5816026,-2.6208656,-2.6614485,-2.7034163,-2.7468355,-2.7917879,-2.8383503,-2.8866038,-2.9366488,-2.98858,-3.0425034,-3.0985281,-3.1567872,-3.2174084,-3.2805355,-3.3463187,-3.4149375,-3.4865704,-3.56141,-3.6396868,-3.721632,-3.807506,-3.8975866,-3.9922028,-4.0916924,-4.1964374,-4.3068514,-4.423422,-4.5466638,-4.677148,-4.815551,-4.962597,-5.1191144,-5.2860274,-5.4644313,-5.655529,-5.860717,-6.081584,-6.320031,-6.57821,-6.858638,-7.1643624,-7.498925,-7.866591,-8.272475,-8.722927,-9.225644,-9.79026,-10.428873,-11.15715,-11.995288,-12.970042,-14.117941,-15.4894285,-17.156803,-19.22711,-21.866863,-25.347975,-30.148712,-37.19385,-48.539394,-69.84867,-124.51014,-572.9231],"x":[0.1,0.46016017,0.8203203,1.1804805,1.5406406,1.9008008,2.260961,2.6211212,2.9812813,3.3414414,3.7016015,4.061762,4.4219217,4.782082,5.1422424,5.5024023,5.8625627,6.2227225,6.582883,6.943043,7.303203,7.6633635,8.023523,8.383684,8.743844,9.104004,9.464164,9.824325,10.1844845,10.544644,10.904805,11.264965,11.625125,11.985286,12.345446,12.7056055,13.065765,13.425926,13.786086,14.146246,14.506407,14.866567,15.226727,15.586887,15.947047,16.307207,16.667368,17.027527,17.387688,17.747849,18.108007,18.468168,18.82833,19.188488,19.548649,19.90881,20.268969,20.62913,20.98929,21.34945,21.70961,22.069769,22.42993,22.79009,23.15025,23.51041,23.870571,24.23073,24.59089,24.951052,25.31121,25.671371,26.031532,26.391691,26.751852,27.112013,27.472172,27.832333,28.192493,28.552652,28.912813,29.272972,29.633133,29.993294,30.353453,30.713614,31.073774,31.433933,31.794094,32.154255,32.514416,32.874573,33.234734,33.594894,33.955055,34.315216,34.675377,35.035534,35.395695,35.755856,36.116016,36.476177,36.836338,37.196495,37.556656,37.916817,38.276978,38.63714,38.9973,39.357456,39.717617,40.077778,40.43794,40.7981,41.158257,41.518417,41.87858,42.23874,42.5989,42.95906,43.319218,43.67938,44.03954,44.3997,44.75986,45.12002,45.48018,45.84034,46.2005,46.56066,46.920822,47.28098,47.64114,48.0013,48.36146,48.721622,49.081783,49.44194,49.8021,50.162262,50.522423,50.882584,51.242744,51.6029,51.963062,52.323223,52.683384,53.043545,53.403706,53.763863,54.124023,54.484184,54.844345,55.204506,55.564663,55.924824,56.284985,56.645145,57.005306,57.365467,57.725624,58.085785,58.445946,58.806107,59.166267,59.52643,59.886585,60.246746,60.606907,60.967068,61.32723,61.687386,62.047546,62.407707,62.767868,63.12803,63.48819,63.848347,64.20851,64.56867,64.928825,65.28899,65.64915,66.00931,66.36947,66.72963,67.08979,67.44995,67.81011,68.17027,68.53043,68.89059,69.25075,69.61091,69.97107,70.33123,70.69139,71.05155,71.41171,71.77187,72.132034,72.492195,72.852356,73.21251,73.57267,73.93283,74.29299,74.65315,75.01331,75.373474,75.733635,76.093796,76.45396,76.81412,77.17427,77.53443,77.89459,78.25475,78.614914,78.975075,79.335236,79.6954,80.05556,80.41572,80.77588,81.13604,81.49619,81.85635,82.216515,82.576675,82.93684,83.297,83.65716,84.01732,84.37748,84.73764,85.0978,85.457954,85.818115,86.178276,86.53844,86.8986,87.25876,87.61892,87.97908,88.33924,88.6994,89.05956,89.41972,89.77988,90.14004,90.5002,90.86036,91.22052,91.58068,91.94084,92.301,92.66116,93.021324,93.381485,93.74164,94.1018,94.46196,94.82212,95.18228,95.54244,95.9026,96.262764,96.622925,96.983086,97.34325,97.7034,98.06356,98.42372,98.78388,99.14404,99.5042,99.864365,100.224525,100.58469,100.94485,101.30501,101.66517,102.02532,102.38548,102.74564,103.105804,103.465965,103.826126,104.18629,104.54645,104.90661,105.26677,105.62693,105.98708,106.347244,106.707405,107.067566,107.42773,107.78789,108.14805,108.50821,108.86837,109.22853,109.58869,109.94885,110.309006,110.66917,111.02933,111.38949,111.74965,112.10981,112.46997,112.83013,113.19029,113.55045,113.910614,114.27077,114.63093,114.99109,115.35125,115.71141,116.07157,116.43173,116.79189,117.152054,117.512215,117.872375,118.23254,118.59269,118.95285,119.31301,119.67317,120.03333,120.39349,120.753654,121.113815,121.473976,121.83414,122.1943,122.55445,122.91461,123.27477,123.63493,123.995094,124.355255,124.715416,125.07558,125.43574,125.7959,126.15606,126.51621,126.87637,127.236534,127.596695,127.956856,128.31702,128.67717,129.03734,129.39749,129.75766,130.11781,130.47798,130.83813,131.1983,131.55846,131.91862,132.27878,132.63895,132.9991,133.35925,133.71942,134.07957,134.43974,134.7999,135.16006,135.52022,135.88039,136.24054,136.60071,136.96086,137.32101,137.68118,138.04134,138.4015,138.76166,139.12183,139.48198,139.84215,140.2023,140.56247,140.92262,141.28278,141.64294,142.0031,142.36327,142.72342,143.08359,143.44374,143.80391,144.16406,144.52423,144.88438,145.24454,145.6047,145.96486,146.32503,146.68518,147.04535,147.4055,147.76567,148.12582,148.486,148.84615,149.2063,149.56647,149.92662,150.28679,150.64694,151.00711,151.36726,151.72743,152.08759,152.44775,152.8079,153.16808,153.52823,153.88838,154.24855,154.6087,154.96887,155.32903,155.6892,156.04935,156.40952,156.76967,157.12984,157.48999,157.85014,158.21031,158.57047,158.93063,159.29079,159.65096,160.01111,160.37128,160.73143,161.0916,161.45175,161.8119,162.17207,162.53223,162.8924,163.25255,163.61272,163.97287,164.33304,164.69319,165.05336,165.41351,165.77367,166.13383,166.49399,166.85416,167.21431,167.57448,167.93463,168.2948,168.65495,169.01512,169.37527,169.73543,170.0956,170.45575,170.81592,171.17607,171.53624,171.8964,172.25656,172.61671,172.97688,173.33704,173.6972,174.05736,174.41751,174.77768,175.13783,175.498,175.85815,176.21832,176.57848,176.93864,177.2988,177.65897,178.01912,178.37927,178.73944,179.0996,179.45976,179.81992,180.18008,180.54024,180.9004,181.26056,181.62073,181.98088,182.34103,182.7012,183.06136,183.42152,183.78168,184.14185,184.502,184.86217,185.22232,185.58249,185.94264,186.3028,186.66296,187.02312,187.38329,187.74344,188.1036,188.46376,188.82393,189.18408,189.54425,189.9044,190.26457,190.62473,190.98488,191.34505,191.7052,192.06537,192.42552,192.78569,193.14584,193.50601,193.86617,194.22633,194.58649,194.94664,195.30681,195.66696,196.02713,196.38728,196.74745,197.1076,197.46777,197.82793,198.1881,198.54825,198.9084,199.26857,199.62872,199.98889,200.34904,200.70921,201.06937,201.42953,201.78969,202.14986,202.51001,202.87016,203.23033,203.59048,203.95065,204.3108,204.67097,205.03113,205.3913,205.75145,206.11162,206.47177,206.83192,207.1921,207.55225,207.91241,208.27257,208.63274,208.99289,209.35306,209.71321,210.07338,210.43353,210.7937,211.15385,211.514,211.87418,212.23433,212.5945,212.95465,213.31482,213.67497,214.03514,214.3953,214.75546,215.11562,215.47577,215.83594,216.19609,216.55626,216.91641,217.27658,217.63673,217.9969,218.35706,218.71722,219.07738,219.43753,219.7977,220.15785,220.51802,220.87817,221.23834,221.5985,221.95866,222.31882,222.67899,223.03914,223.39929,223.75946,224.11961,224.47978,224.83994,225.2001,225.56026,225.92043,226.28058,226.64075,227.0009,227.36105,227.72122,228.08138,228.44154,228.8017,229.16187,229.52202,229.88219,230.24234,230.60251,230.96266,231.32283,231.68298,232.04314,232.4033,232.76346,233.12363,233.48378,233.84395,234.2041,234.56427,234.92442,235.28459,235.64474,236.0049,236.36507,236.72522,237.08539,237.44554,237.80571,238.16586,238.52603,238.88618,239.24635,239.6065,239.96666,240.32683,240.68698,241.04715,241.4073,241.76747,242.12762,242.4878,242.84795,243.20811,243.56827,243.92842,244.28859,244.64874,245.00891,245.36906,245.72923,246.08939,246.44955,246.80971,247.16988,247.53003,247.8902,248.25035,248.6105,248.97067,249.33083,249.691,250.05115,250.41132,250.77147,251.13164,251.49179,251.85196,252.21211,252.57227,252.93243,253.29259,253.65276,254.01291,254.37308,254.73323,255.0934,255.45355,255.81372,256.17386,256.53403,256.8942,257.25436,257.6145,257.97467,258.33484,258.695,259.05515,259.4153,259.77548,260.13565,260.4958,260.85596,261.21613,261.57626,261.93643,262.2966,262.65677,263.0169,263.37708,263.73724,264.0974,264.45755,264.81772,265.1779,265.53802,265.8982,266.25836,266.61853,266.97867,267.33884,267.699,268.05917,268.4193,268.77948,269.13965,269.4998,269.85995,270.22012,270.5803,270.94043,271.3006,271.66077,272.02094,272.38107,272.74124,273.1014,273.46155,273.82172,274.1819,274.54205,274.9022,275.26236,275.62253,275.9827,276.34283,276.703,277.06317,277.4233,277.78348,278.14365,278.5038,278.86395,279.22412,279.5843,279.94446,280.3046,280.66476,281.02493,281.38507,281.74524,282.1054,282.46558,282.8257,283.18588,283.54605,283.90622,284.26636,284.62653,284.9867,285.34683,285.707,286.06717,286.42734,286.78748,287.14764,287.5078,287.86798,288.22812,288.5883,288.94846,289.3086,289.66876,290.02893,290.3891,290.74924,291.1094,291.46957,291.82974,292.18988,292.55005,292.91022,293.27036,293.63052,293.9907,294.35086,294.711,295.07117,295.43134,295.7915,296.15164,296.5118,296.87198,297.23215,297.5923,297.95245,298.31262,298.67276,299.03293,299.3931,299.75327,300.1134,300.47357,300.83374,301.1939,301.55405,301.9142,302.27438,302.63452,302.9947,303.35486,303.71503,304.07516,304.43533,304.7955,305.15567,305.5158,305.87598,306.23615,306.59628,306.95645,307.31662,307.6768,308.03693,308.3971,308.75726,309.11743,309.47757,309.83774,310.1979,310.55804,310.9182,311.27838,311.63855,311.9987,312.35886,312.71902,313.0792,313.43933,313.7995,314.15967,314.5198,314.87997,315.24014,315.6003,315.96045,316.32062,316.6808,317.04095,317.4011,317.76126,318.12143,318.48157,318.84174,319.2019,319.56207,319.9222,320.28238,320.64255,321.00272,321.36285,321.72302,322.0832,322.44333,322.8035,323.16367,323.52383,323.88397,324.24414,324.6043,324.96448,325.32462,325.68478,326.04495,326.4051,326.76526,327.12543,327.4856,327.84573,328.2059,328.56607,328.92624,329.28638,329.64655,330.0067,330.36685,330.72702,331.0872,331.44736,331.8075,332.16766,332.52783,332.888,333.24814,333.6083,333.96848,334.32864,334.68878,335.04895,335.40912,335.76926,336.12943,336.4896,336.84976,337.2099,337.57007,337.93024,338.2904,338.65054,339.0107,339.37088,339.73102,340.0912,340.45135,340.81152,341.17166,341.53183,341.892,342.25217,342.6123,342.97247,343.33264,343.69278,344.05295,344.41312,344.7733,345.13342,345.4936,345.85376,346.21393,346.57407,346.93423,347.2944,347.65454,348.0147,348.37488,348.73505,349.09518,349.45535,349.81552,350.1757,350.53583,350.896,351.25616,351.6163,351.97647,352.33664,352.6968,353.05695,353.4171,353.77728,354.13745,354.4976,354.85776,355.21793,355.57806,355.93823,356.2984,356.65857,357.0187,357.37888,357.73904,358.0992,358.45935,358.81952,359.1797,359.53983,359.9]}
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/runner.jl b/lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/runner.jl
new file mode 100755
index 000000000000..9888bc6b6545
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/test/fixtures/julia/runner.jl
@@ -0,0 +1,70 @@
+#!/usr/bin/env julia
+#
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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.
+
+import JSON
+
+"""
+	gen( domain, name )
+
+Generate fixture data and write to file.
+
+# Arguments
+
+* `domain`: domain
+* `name::AbstractString`: output filename
+
+# Examples
+
+``` julia
+julia> x = range( -1, stop = 1, length = 2001 );
+julia> gen( x, \"data.json\" );
+```
+"""
+function gen( domain, name )
+	x = collect( domain );
+	y = cscd.( x );
+
+	# Store data to be written to file as a collection:
+	data = Dict([
+		("x", x),
+		("expected", y)
+	]);
+
+	# Based on the script directory, create an output filepath:
+	filepath = joinpath( dir, name );
+
+	# Write the data to the output filepath as JSON:
+	outfile = open( filepath, "w" );
+	write( outfile, JSON.json(data) );
+	write( outfile, "\n" );
+	close( outfile );
+end
+
+# Get the filename:
+file = @__FILE__;
+
+# Extract the directory in which this file resides:
+dir = dirname( file );
+
+# Generate fixture data for negative values:
+x = Float32.( range( -359.9, stop = 0.1, length = 1000 ) );
+gen( x, "negative.json" );
+
+# Generate fixture data for positive values:
+x = Float32.( range( 0.1, stop = 359.9, length = 1000 ) );
+gen( x, "positive.json" );
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/test/test.js b/lib/node_modules/@stdlib/math/base/special/cscdf/test/test.js
new file mode 100644
index 000000000000..fc46e62301f0
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/test/test.js
@@ -0,0 +1,118 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var f32 = require( '@stdlib/number/float64/base/to-float32' );
+var ulpdiff = require( '@stdlib/number/float32/base/ulp-difference' );
+var PINF = require( '@stdlib/constants/float32/pinf' );
+var NINF = require( '@stdlib/constants/float32/ninf' );
+var cscdf = require( './../lib' );
+
+
+// FIXTURES //
+
+var negative = require( './fixtures/julia/negative.json' );
+var positive = require( './fixtures/julia/positive.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof cscdf, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
+	var v = cscdf( NaN );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'if provided a positive multiple of `180.0`, the function returns `+infinity`', function test( t ) {
+	var v = cscdf( f32( 180.0 ) );
+	t.strictEqual( PINF, v, 'returns expected value' );
+
+	v = cscdf( f32( 360.0 ) );
+	t.strictEqual( PINF, v, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided a negative multiple of `180.0`, the function returns `-infinity`', function test( t ) {
+	var v = cscdf( f32( -180.0 ) );
+	t.strictEqual( NINF, v, 'returns expected value' );
+
+	v = cscdf( f32( -360.0 ) );
+	t.strictEqual( NINF, v, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns `-0` if provided `-infinity`', function test( t ) {
+	var v = cscdf( f32( -0.0 ) );
+	t.strictEqual( NINF, v, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns `+0` if provided `+infinity`', function test( t ) {
+	var v = cscdf( f32( 0.0 ) );
+	t.strictEqual( PINF, v, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function computes the cosecant in degrees (negative values)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+	var i;
+
+	x = negative.x;
+	expected = negative.expected;
+
+	for ( i = 0; i < x.length; i++ ) {
+		x[ i ] = f32( x[ i ] );
+		expected[ i ] = f32( expected[ i ] );
+		y = cscdf( x[ i ] );
+		t.strictEqual( ulpdiff( y, expected[ i ] ) <= 2, true, 'returns expected value' );
+	}
+	t.end();
+});
+
+tape( 'the function computes the cosecant in degrees (positive values)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+	var i;
+
+	x = positive.x;
+	expected = positive.expected;
+
+	for ( i = 0; i < x.length; i++ ) {
+		x[ i ] = f32( x[ i ] );
+		expected[ i ] = f32( expected[ i ] );
+		y = cscdf( x[ i ] );
+		t.strictEqual( ulpdiff( y, expected[ i ] ) <= 2, true, 'returns expected value' );
+	}
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/math/base/special/cscdf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/cscdf/test/test.native.js
new file mode 100644
index 000000000000..35bc20be474a
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cscdf/test/test.native.js
@@ -0,0 +1,127 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var tape = require( 'tape' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var f32 = require( '@stdlib/number/float64/base/to-float32' );
+var ulpdiff = require( '@stdlib/number/float32/base/ulp-difference' );
+var PINF = require( '@stdlib/constants/float32/pinf' );
+var NINF = require( '@stdlib/constants/float32/ninf' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+
+
+// VARIABLES //
+
+var cscdf = tryRequire( resolve( __dirname, './../lib/native.js' ) );
+var opts = {
+	'skip': ( cscdf instanceof Error )
+};
+
+
+// FIXTURES //
+
+var negative = require( './fixtures/julia/negative.json' );
+var positive = require( './fixtures/julia/positive.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', opts, function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof cscdf, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
+	var v = cscdf( NaN );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'if provided a positive multiple of `180.0`, the function returns `+infinity`', opts, function test( t ) {
+	var v = cscdf( f32( 180.0 ) );
+	t.strictEqual( PINF, v, 'returns expected value' );
+
+	v = cscdf( f32( 360.0 ) );
+	t.strictEqual( PINF, v, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided a negative multiple of `180.0`, the function returns `-infinity`', opts, function test( t ) {
+	var v = cscdf( f32( -180.0 ) );
+	t.strictEqual( NINF, v, 'returns expected value' );
+
+	v = cscdf( f32( -360.0 ) );
+	t.strictEqual( NINF, v, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns `-0` if provided `-infinity`', opts, function test( t ) {
+	var v = cscdf( f32( -0.0 ) );
+	t.strictEqual( NINF, v, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns `+0` if provided `+infinity`', opts, function test( t ) {
+	var v = cscdf( f32( 0.0 ) );
+	t.strictEqual( PINF, v, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function computes the cosecant in degrees (negative values)', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+	var i;
+
+	x = negative.x;
+	expected = negative.expected;
+
+	for ( i = 0; i < x.length; i++ ) {
+		x[ i ] = f32( x[ i ] );
+		expected[ i ] = f32( expected[ i ] );
+		y = cscdf( x[ i ] );
+		t.strictEqual( ulpdiff( y, expected[ i ] ) <= 2, true, 'returns expected value' );
+	}
+	t.end();
+});
+
+tape( 'the function computes the cosecant in degrees (positive values)', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+	var i;
+
+	x = positive.x;
+	expected = positive.expected;
+
+	for ( i = 0; i < x.length; i++ ) {
+		x[ i ] = f32( x[ i ] );
+		expected[ i ] = f32( expected[ i ] );
+		y = cscdf( x[ i ] );
+		t.strictEqual( ulpdiff( y, expected[ i ] ) <= 2, true, 'returns expected value' );
+	}
+	t.end();
+});

From 54da28610f5ee6b2aa181addb1775d32f79043ee Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Tue, 12 Aug 2025 21:08:30 -0500
Subject: [PATCH 02/32] test: use .strictEqual() instead of .equal() and fix
 lint errors

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/random/array/arcsine/test/test.js |  12 +-
 .../random/array/bernoulli/test/test.js       |  12 +-
 .../@stdlib/random/array/beta/test/test.js    |  12 +-
 .../random/array/betaprime/test/test.js       |  12 +-
 .../random/array/binomial/test/test.js        |  12 +-
 .../@stdlib/random/array/cauchy/test/test.js  |  12 +-
 .../@stdlib/random/array/chi/test/test.js     |  12 +-
 .../random/array/chisquare/test/test.js       |  12 +-
 .../@stdlib/random/array/cosine/test/test.js  |  12 +-
 .../array/discrete-uniform/test/test.js       |  12 +-
 .../@stdlib/random/array/erlang/test/test.js  |  12 +-
 .../random/array/exponential/test/test.js     |  12 +-
 .../@stdlib/random/array/f/test/test.js       |  12 +-
 .../@stdlib/random/array/frechet/test/test.js |  12 +-
 .../@stdlib/random/array/gamma/test/test.js   |  12 +-
 .../random/array/geometric/test/test.js       |  12 +-
 .../@stdlib/random/array/gumbel/test/test.js  |  12 +-
 .../random/array/hypergeometric/test/test.js  |  12 +-
 .../random/array/invgamma/test/test.js        |  12 +-
 .../random/array/kumaraswamy/test/test.js     |  12 +-
 .../@stdlib/random/array/laplace/test/test.js |  12 +-
 .../@stdlib/random/array/levy/test/test.js    |  12 +-
 .../random/array/logistic/test/test.js        |  12 +-
 .../random/array/lognormal/test/test.js       |  12 +-
 .../random/array/minstd-shuffle/test/test.js  |  12 +-
 .../minstd-shuffle/test/test.validate.js      |  26 +--
 .../@stdlib/random/array/minstd/test/test.js  |  12 +-
 .../random/array/minstd/test/test.validate.js |  26 +--
 .../@stdlib/random/array/mt19937/test/test.js |  12 +-
 .../array/mt19937/test/test.validate.js       |  26 +--
 .../array/negative-binomial/test/test.js      |  12 +-
 .../@stdlib/random/array/normal/test/test.js  |  12 +-
 .../random/array/pareto-type1/test/test.js    |  12 +-
 .../@stdlib/random/array/poisson/test/test.js |  12 +-
 .../@stdlib/random/array/randu/test/test.js   |  12 +-
 .../random/array/randu/test/test.validate.js  |   8 +-
 .../random/array/rayleigh/test/test.js        |  12 +-
 .../@stdlib/random/array/t/test/test.js       |  12 +-
 .../@stdlib/random/array/test/test.js         |   2 +-
 .../@stdlib/random/array/tools/test/test.js   |   2 +-
 .../random/array/triangular/test/test.js      |  12 +-
 .../@stdlib/random/array/uniform/test/test.js |  12 +-
 .../@stdlib/random/array/weibull/test/test.js |  12 +-
 .../random/base/arcsine/test/test.factory.js  |  75 ++++-----
 .../@stdlib/random/base/arcsine/test/test.js  |  24 +--
 .../base/bernoulli/test/test.factory.js       |  75 ++++-----
 .../random/base/bernoulli/test/test.js        |  20 +--
 .../random/base/beta/test/test.factory.js     | 101 ++++++------
 .../@stdlib/random/base/beta/test/test.js     |  24 +--
 .../base/betaprime/test/test.factory.js       |  81 +++++-----
 .../random/base/betaprime/test/test.js        |  20 +--
 .../base/binomial/test/test.correction.js     |   4 +-
 .../random/base/binomial/test/test.factory.js |  93 +++++------
 .../@stdlib/random/base/binomial/test/test.js |  22 +--
 .../base/box-muller/test/test.factory.js      |  89 +++++-----
 .../random/base/box-muller/test/test.js       |  30 ++--
 .../random/base/cauchy/test/test.factory.js   |  79 ++++-----
 .../@stdlib/random/base/cauchy/test/test.js   |  22 +--
 .../random/base/chi/test/test.factory.js      |  77 ++++-----
 .../@stdlib/random/base/chi/test/test.js      |  22 +--
 .../base/chisquare/test/test.factory.js       |  77 ++++-----
 .../random/base/chisquare/test/test.js        |  22 +--
 .../random/base/cosine/test/test.factory.js   |  79 ++++-----
 .../@stdlib/random/base/cosine/test/test.js   |  22 +--
 .../test/test.discrete_uniform.js             |  66 ++++----
 .../discrete-uniform/test/test.factory.js     |  83 +++++-----
 .../random/base/discrete-uniform/test/test.js |  26 +--
 .../random/base/erlang/test/test.factory.js   |  79 ++++-----
 .../@stdlib/random/base/erlang/test/test.js   |  22 +--
 .../base/exponential/test/test.factory.js     |  75 ++++-----
 .../random/base/exponential/test/test.js      |  20 +--
 .../random/base/f/test/test.factory.js        |  75 ++++-----
 .../@stdlib/random/base/f/test/test.js        |  20 +--
 .../random/base/frechet/test/test.factory.js  |  75 ++++-----
 .../@stdlib/random/base/frechet/test/test.js  |  24 +--
 .../random/base/gamma/test/test.factory.js    |  89 +++++-----
 .../@stdlib/random/base/gamma/test/test.js    |  22 +--
 .../base/geometric/test/test.factory.js       |  75 ++++-----
 .../random/base/geometric/test/test.js        |  20 +--
 .../random/base/gumbel/test/test.factory.js   |  79 ++++-----
 .../@stdlib/random/base/gumbel/test/test.js   |  22 +--
 .../base/hypergeometric/test/test.factory.js  |  87 +++++-----
 .../random/base/hypergeometric/test/test.js   |  20 +--
 .../improved-ziggurat/test/test.factory.js    |  67 ++++----
 .../base/improved-ziggurat/test/test.js       |  22 +--
 .../random/base/invgamma/test/test.factory.js |  75 ++++-----
 .../@stdlib/random/base/invgamma/test/test.js |  20 +--
 .../base/kumaraswamy/test/test.factory.js     |  79 ++++-----
 .../random/base/kumaraswamy/test/test.js      |  20 +--
 .../random/base/laplace/test/test.factory.js  |  79 ++++-----
 .../@stdlib/random/base/laplace/test/test.js  |  22 +--
 .../random/base/levy/test/test.factory.js     |  79 ++++-----
 .../@stdlib/random/base/levy/test/test.js     |  22 +--
 .../random/base/logistic/test/test.factory.js |  79 ++++-----
 .../@stdlib/random/base/logistic/test/test.js |  22 +--
 .../base/lognormal/test/test.factory.js       |  79 ++++-----
 .../random/base/lognormal/test/test.js        |  20 +--
 .../minstd-shuffle/test/test.create_table.js  |   4 +-
 .../base/minstd-shuffle/test/test.factory.js  | 129 +++++++--------
 .../random/base/minstd-shuffle/test/test.js   |  56 +++----
 .../random/base/minstd/test/test.factory.js   | 124 +++++++-------
 .../@stdlib/random/base/minstd/test/test.js   |  56 +++----
 .../random/base/mt19937/test/test.factory.js  | 153 +++++++++---------
 .../@stdlib/random/base/mt19937/test/test.js  |  56 +++----
 .../negative-binomial/test/test.factory.js    |  83 +++++-----
 .../base/negative-binomial/test/test.js       |  20 +--
 .../random/base/normal/test/test.factory.js   |  79 ++++-----
 .../@stdlib/random/base/normal/test/test.js   |  22 +--
 .../base/pareto-type1/test/test.factory.js    |  75 ++++-----
 .../random/base/pareto-type1/test/test.js     |  20 +--
 .../random/base/poisson/test/test.factory.js  |  91 +++++------
 .../@stdlib/random/base/poisson/test/test.js  |  20 +--
 .../random/base/randi/test/test.factory.js    |  60 +++----
 .../@stdlib/random/base/randi/test/test.js    |  34 ++--
 .../random/base/randn/test/test.factory.js    |  71 ++++----
 .../@stdlib/random/base/randn/test/test.js    |  22 +--
 .../random/base/randu/test/test.factory.js    |  61 +++----
 .../@stdlib/random/base/randu/test/test.js    |  30 ++--
 .../random/base/rayleigh/test/test.factory.js |  75 ++++-----
 .../@stdlib/random/base/rayleigh/test/test.js |  20 +--
 .../@stdlib/random/base/reviver/test/test.js  |  14 +-
 .../random/base/t/test/test.factory.js        |  83 +++++-----
 .../@stdlib/random/base/t/test/test.js        |  20 +--
 .../@stdlib/random/base/test/test.js          |   2 +-
 .../base/triangular/test/test.factory.js      |  75 ++++-----
 .../random/base/triangular/test/test.js       |  24 +--
 .../random/base/uniform/test/test.factory.js  |  75 ++++-----
 .../@stdlib/random/base/uniform/test/test.js  |  24 +--
 .../random/base/weibull/test/test.factory.js  |  75 ++++-----
 .../@stdlib/random/base/weibull/test/test.js  |  20 +--
 .../@stdlib/random/exponential/test/test.js   |  12 +-
 .../@stdlib/random/iter/arcsine/test/test.js  | 110 ++++++-------
 .../random/iter/bernoulli/test/test.js        | 110 ++++++-------
 .../@stdlib/random/iter/beta/test/test.js     | 110 ++++++-------
 .../random/iter/betaprime/test/test.js        | 110 ++++++-------
 .../@stdlib/random/iter/binomial/test/test.js | 110 ++++++-------
 .../random/iter/box-muller/test/test.js       | 120 +++++++-------
 .../@stdlib/random/iter/cauchy/test/test.js   | 110 ++++++-------
 .../@stdlib/random/iter/chi/test/test.js      | 110 ++++++-------
 .../random/iter/chisquare/test/test.js        | 110 ++++++-------
 .../@stdlib/random/iter/cosine/test/test.js   | 110 ++++++-------
 .../random/iter/discrete-uniform/test/test.js | 110 ++++++-------
 .../@stdlib/random/iter/erlang/test/test.js   | 110 ++++++-------
 .../random/iter/exponential/test/test.js      | 110 ++++++-------
 .../@stdlib/random/iter/f/test/test.js        | 110 ++++++-------
 .../@stdlib/random/iter/frechet/test/test.js  | 110 ++++++-------
 .../@stdlib/random/iter/gamma/test/test.js    | 110 ++++++-------
 .../random/iter/geometric/test/test.js        | 110 ++++++-------
 .../@stdlib/random/iter/gumbel/test/test.js   | 110 ++++++-------
 .../random/iter/hypergeometric/test/test.js   | 110 ++++++-------
 .../iter/improved-ziggurat/test/test.js       | 112 ++++++-------
 .../@stdlib/random/iter/invgamma/test/test.js | 110 ++++++-------
 .../random/iter/kumaraswamy/test/test.js      | 110 ++++++-------
 .../@stdlib/random/iter/laplace/test/test.js  | 110 ++++++-------
 .../@stdlib/random/iter/levy/test/test.js     | 110 ++++++-------
 .../@stdlib/random/iter/logistic/test/test.js | 110 ++++++-------
 .../random/iter/lognormal/test/test.js        | 110 ++++++-------
 .../random/iter/minstd-shuffle/test/test.js   |  94 +++++------
 .../@stdlib/random/iter/minstd/test/test.js   |  94 +++++------
 .../@stdlib/random/iter/mt19937/test/test.js  |  94 +++++------
 .../iter/negative-binomial/test/test.js       | 110 ++++++-------
 .../@stdlib/random/iter/normal/test/test.js   | 110 ++++++-------
 .../random/iter/pareto-type1/test/test.js     | 110 ++++++-------
 .../@stdlib/random/iter/poisson/test/test.js  | 110 ++++++-------
 .../@stdlib/random/iter/randi/test/test.js    |  98 +++++------
 .../@stdlib/random/iter/randn/test/test.js    | 112 ++++++-------
 .../@stdlib/random/iter/randu/test/test.js    |  98 +++++------
 .../@stdlib/random/iter/rayleigh/test/test.js | 110 ++++++-------
 .../@stdlib/random/iter/t/test/test.js        | 110 ++++++-------
 .../@stdlib/random/iter/test/test.js          |   2 +-
 .../random/iter/triangular/test/test.js       | 110 ++++++-------
 .../@stdlib/random/iter/uniform/test/test.js  | 110 ++++++-------
 .../@stdlib/random/iter/weibull/test/test.js  | 110 ++++++-------
 .../random/sample/test/test.factory.js        | 100 ++++++------
 .../@stdlib/random/sample/test/test.js        |   6 +-
 .../random/sample/test/test.validate.js       |  10 +-
 .../random/shuffle/test/test.factory.js       |  20 +--
 .../@stdlib/random/shuffle/test/test.js       |   6 +-
 .../random/shuffle/test/test.validate.js      |   8 +-
 .../streams/arcsine/test/test.factory.js      |  16 +-
 .../random/streams/arcsine/test/test.js       |   4 +-
 .../random/streams/arcsine/test/test.main.js  |  76 ++++-----
 .../streams/arcsine/test/test.object_mode.js  |   8 +-
 .../streams/arcsine/test/test.validate.js     |  28 ++--
 .../streams/bernoulli/test/test.factory.js    |  16 +-
 .../random/streams/bernoulli/test/test.js     |   4 +-
 .../streams/bernoulli/test/test.main.js       |  76 ++++-----
 .../bernoulli/test/test.object_mode.js        |   8 +-
 .../streams/bernoulli/test/test.validate.js   |  28 ++--
 .../random/streams/beta/test/test.factory.js  |  16 +-
 .../@stdlib/random/streams/beta/test/test.js  |   4 +-
 .../random/streams/beta/test/test.main.js     |  76 ++++-----
 .../streams/beta/test/test.object_mode.js     |   8 +-
 .../random/streams/beta/test/test.validate.js |  28 ++--
 .../streams/betaprime/test/test.factory.js    |  16 +-
 .../random/streams/betaprime/test/test.js     |   4 +-
 .../streams/betaprime/test/test.main.js       |  76 ++++-----
 .../betaprime/test/test.object_mode.js        |   8 +-
 .../streams/betaprime/test/test.validate.js   |  28 ++--
 .../streams/binomial/test/test.factory.js     |  16 +-
 .../random/streams/binomial/test/test.js      |   4 +-
 .../random/streams/binomial/test/test.main.js |  76 ++++-----
 .../streams/binomial/test/test.object_mode.js |   8 +-
 .../streams/binomial/test/test.validate.js    |  28 ++--
 .../streams/box-muller/test/test.factory.js   |   8 +-
 .../random/streams/box-muller/test/test.js    |   4 +-
 .../streams/box-muller/test/test.main.js      |  76 ++++-----
 .../box-muller/test/test.object_mode.js       |   8 +-
 .../streams/box-muller/test/test.validate.js  |  28 ++--
 .../streams/cauchy/test/test.factory.js       |  16 +-
 .../random/streams/cauchy/test/test.js        |   4 +-
 .../random/streams/cauchy/test/test.main.js   |  76 ++++-----
 .../streams/cauchy/test/test.object_mode.js   |   8 +-
 .../streams/cauchy/test/test.validate.js      |  28 ++--
 .../random/streams/chi/test/test.factory.js   |  16 +-
 .../@stdlib/random/streams/chi/test/test.js   |   4 +-
 .../random/streams/chi/test/test.main.js      |  76 ++++-----
 .../streams/chi/test/test.object_mode.js      |   8 +-
 .../random/streams/chi/test/test.validate.js  |  28 ++--
 .../streams/chisquare/test/test.factory.js    |  16 +-
 .../random/streams/chisquare/test/test.js     |   4 +-
 .../streams/chisquare/test/test.main.js       |  76 ++++-----
 .../chisquare/test/test.object_mode.js        |   8 +-
 .../streams/chisquare/test/test.validate.js   |  28 ++--
 .../streams/cosine/test/test.factory.js       |  16 +-
 .../random/streams/cosine/test/test.js        |   4 +-
 .../random/streams/cosine/test/test.main.js   |  76 ++++-----
 .../streams/cosine/test/test.object_mode.js   |   8 +-
 .../streams/cosine/test/test.validate.js      |  28 ++--
 .../discrete-uniform/test/test.factory.js     |  16 +-
 .../streams/discrete-uniform/test/test.js     |   4 +-
 .../discrete-uniform/test/test.main.js        |  76 ++++-----
 .../discrete-uniform/test/test.object_mode.js |   8 +-
 .../discrete-uniform/test/test.validate.js    |  28 ++--
 .../streams/erlang/test/test.factory.js       |  16 +-
 .../random/streams/erlang/test/test.js        |   4 +-
 .../random/streams/erlang/test/test.main.js   |  76 ++++-----
 .../streams/erlang/test/test.object_mode.js   |   8 +-
 .../streams/erlang/test/test.validate.js      |  28 ++--
 .../streams/exponential/test/test.factory.js  |  16 +-
 .../random/streams/exponential/test/test.js   |   4 +-
 .../streams/exponential/test/test.main.js     |  76 ++++-----
 .../exponential/test/test.object_mode.js      |   8 +-
 .../streams/exponential/test/test.validate.js |  28 ++--
 .../random/streams/f/test/test.factory.js     |  16 +-
 .../@stdlib/random/streams/f/test/test.js     |   4 +-
 .../random/streams/f/test/test.main.js        |  76 ++++-----
 .../random/streams/f/test/test.object_mode.js |   8 +-
 .../random/streams/f/test/test.validate.js    |  28 ++--
 .../streams/frechet/test/test.factory.js      |  16 +-
 .../random/streams/frechet/test/test.js       |   4 +-
 .../random/streams/frechet/test/test.main.js  |  76 ++++-----
 .../streams/frechet/test/test.object_mode.js  |   8 +-
 .../streams/frechet/test/test.validate.js     |  28 ++--
 .../random/streams/gamma/test/test.factory.js |  16 +-
 .../@stdlib/random/streams/gamma/test/test.js |   4 +-
 .../random/streams/gamma/test/test.main.js    |  76 ++++-----
 .../streams/gamma/test/test.object_mode.js    |   8 +-
 .../streams/gamma/test/test.validate.js       |  28 ++--
 .../streams/geometric/test/test.factory.js    |  16 +-
 .../random/streams/geometric/test/test.js     |   4 +-
 .../streams/geometric/test/test.main.js       |  76 ++++-----
 .../geometric/test/test.object_mode.js        |   8 +-
 .../streams/geometric/test/test.validate.js   |  28 ++--
 .../streams/gumbel/test/test.factory.js       |  16 +-
 .../random/streams/gumbel/test/test.js        |   4 +-
 .../random/streams/gumbel/test/test.main.js   |  76 ++++-----
 .../streams/gumbel/test/test.object_mode.js   |   8 +-
 .../streams/gumbel/test/test.validate.js      |  28 ++--
 .../hypergeometric/test/test.factory.js       |  16 +-
 .../streams/hypergeometric/test/test.js       |   4 +-
 .../streams/hypergeometric/test/test.main.js  |  76 ++++-----
 .../hypergeometric/test/test.object_mode.js   |   8 +-
 .../hypergeometric/test/test.validate.js      |  28 ++--
 .../improved-ziggurat/test/test.factory.js    |   8 +-
 .../streams/improved-ziggurat/test/test.js    |   4 +-
 .../improved-ziggurat/test/test.main.js       |  76 ++++-----
 .../test/test.object_mode.js                  |   8 +-
 .../improved-ziggurat/test/test.validate.js   |  28 ++--
 .../streams/invgamma/test/test.factory.js     |  16 +-
 .../random/streams/invgamma/test/test.js      |   4 +-
 .../random/streams/invgamma/test/test.main.js |  76 ++++-----
 .../streams/invgamma/test/test.object_mode.js |   8 +-
 .../streams/invgamma/test/test.validate.js    |  28 ++--
 .../streams/kumaraswamy/test/test.factory.js  |  16 +-
 .../random/streams/kumaraswamy/test/test.js   |   4 +-
 .../streams/kumaraswamy/test/test.main.js     |  76 ++++-----
 .../kumaraswamy/test/test.object_mode.js      |   8 +-
 .../streams/kumaraswamy/test/test.validate.js |  28 ++--
 .../streams/laplace/test/test.factory.js      |  16 +-
 .../random/streams/laplace/test/test.js       |   4 +-
 .../random/streams/laplace/test/test.main.js  |  76 ++++-----
 .../streams/laplace/test/test.object_mode.js  |   8 +-
 .../streams/laplace/test/test.validate.js     |  28 ++--
 .../random/streams/levy/test/test.factory.js  |  16 +-
 .../@stdlib/random/streams/levy/test/test.js  |   4 +-
 .../random/streams/levy/test/test.main.js     |  76 ++++-----
 .../streams/levy/test/test.object_mode.js     |   8 +-
 .../random/streams/levy/test/test.validate.js |  28 ++--
 .../streams/logistic/test/test.factory.js     |  16 +-
 .../random/streams/logistic/test/test.js      |   4 +-
 .../random/streams/logistic/test/test.main.js |  76 ++++-----
 .../streams/logistic/test/test.object_mode.js |   8 +-
 .../streams/logistic/test/test.validate.js    |  28 ++--
 .../streams/lognormal/test/test.factory.js    |  16 +-
 .../random/streams/lognormal/test/test.js     |   4 +-
 .../streams/lognormal/test/test.main.js       |  76 ++++-----
 .../lognormal/test/test.object_mode.js        |   8 +-
 .../streams/lognormal/test/test.validate.js   |  28 ++--
 .../minstd-shuffle/test/test.factory.js       |   8 +-
 .../streams/minstd-shuffle/test/test.js       |   4 +-
 .../streams/minstd-shuffle/test/test.main.js  |  68 ++++----
 .../minstd-shuffle/test/test.object_mode.js   |  14 +-
 .../minstd-shuffle/test/test.validate.js      |  28 ++--
 .../streams/minstd/test/test.factory.js       |   8 +-
 .../random/streams/minstd/test/test.js        |   4 +-
 .../random/streams/minstd/test/test.main.js   |  68 ++++----
 .../streams/minstd/test/test.object_mode.js   |  14 +-
 .../streams/minstd/test/test.validate.js      |  28 ++--
 .../streams/mt19937/test/test.factory.js      |   8 +-
 .../random/streams/mt19937/test/test.js       |   4 +-
 .../random/streams/mt19937/test/test.main.js  |  68 ++++----
 .../streams/mt19937/test/test.object_mode.js  |  14 +-
 .../streams/mt19937/test/test.validate.js     |  28 ++--
 .../negative-binomial/test/test.factory.js    |  16 +-
 .../streams/negative-binomial/test/test.js    |   4 +-
 .../negative-binomial/test/test.main.js       |  76 ++++-----
 .../test/test.object_mode.js                  |   8 +-
 .../negative-binomial/test/test.validate.js   |  28 ++--
 .../streams/normal/test/test.factory.js       |  16 +-
 .../random/streams/normal/test/test.js        |   4 +-
 .../random/streams/normal/test/test.main.js   |  76 ++++-----
 .../streams/normal/test/test.object_mode.js   |   8 +-
 .../streams/normal/test/test.validate.js      |  28 ++--
 .../streams/pareto-type1/test/test.factory.js |  16 +-
 .../random/streams/pareto-type1/test/test.js  |   4 +-
 .../streams/pareto-type1/test/test.main.js    |  76 ++++-----
 .../pareto-type1/test/test.object_mode.js     |   8 +-
 .../pareto-type1/test/test.validate.js        |  28 ++--
 .../streams/poisson/test/test.factory.js      |  16 +-
 .../random/streams/poisson/test/test.js       |   4 +-
 .../random/streams/poisson/test/test.main.js  |  76 ++++-----
 .../streams/poisson/test/test.object_mode.js  |   8 +-
 .../streams/poisson/test/test.validate.js     |  28 ++--
 .../random/streams/randi/test/test.factory.js |   8 +-
 .../@stdlib/random/streams/randi/test/test.js |   4 +-
 .../random/streams/randi/test/test.main.js    |  62 +++----
 .../streams/randi/test/test.object_mode.js    |  10 +-
 .../streams/randi/test/test.validate.js       |  28 ++--
 .../random/streams/randn/test/test.factory.js |   8 +-
 .../@stdlib/random/streams/randn/test/test.js |   4 +-
 .../random/streams/randn/test/test.main.js    |  74 ++++-----
 .../streams/randn/test/test.object_mode.js    |   8 +-
 .../streams/randn/test/test.validate.js       |  30 ++--
 .../random/streams/randu/test/test.factory.js |   8 +-
 .../@stdlib/random/streams/randu/test/test.js |   4 +-
 .../random/streams/randu/test/test.main.js    |  62 +++----
 .../streams/randu/test/test.object_mode.js    |  10 +-
 .../streams/randu/test/test.validate.js       |  28 ++--
 .../streams/rayleigh/test/test.factory.js     |  16 +-
 .../random/streams/rayleigh/test/test.js      |   4 +-
 .../random/streams/rayleigh/test/test.main.js |  76 ++++-----
 .../streams/rayleigh/test/test.object_mode.js |   8 +-
 .../streams/rayleigh/test/test.validate.js    |  28 ++--
 .../random/streams/t/test/test.factory.js     |  16 +-
 .../@stdlib/random/streams/t/test/test.js     |   4 +-
 .../random/streams/t/test/test.main.js        |  76 ++++-----
 .../random/streams/t/test/test.object_mode.js |   8 +-
 .../random/streams/t/test/test.validate.js    |  28 ++--
 .../@stdlib/random/streams/test/test.js       |   2 +-
 .../streams/triangular/test/test.factory.js   |  16 +-
 .../random/streams/triangular/test/test.js    |   4 +-
 .../streams/triangular/test/test.main.js      |  76 ++++-----
 .../triangular/test/test.object_mode.js       |   8 +-
 .../streams/triangular/test/test.validate.js  |  28 ++--
 .../streams/uniform/test/test.factory.js      |  16 +-
 .../random/streams/uniform/test/test.js       |   4 +-
 .../random/streams/uniform/test/test.main.js  |  76 ++++-----
 .../streams/uniform/test/test.object_mode.js  |   8 +-
 .../streams/uniform/test/test.validate.js     |  28 ++--
 .../streams/weibull/test/test.factory.js      |  16 +-
 .../random/streams/weibull/test/test.js       |   4 +-
 .../random/streams/weibull/test/test.main.js  |  76 ++++-----
 .../streams/weibull/test/test.object_mode.js  |   8 +-
 .../streams/weibull/test/test.validate.js     |  28 ++--
 .../random/strided/bernoulli/test/test.js     |  12 +-
 .../@stdlib/random/strided/chi/test/test.js   |  12 +-
 .../random/strided/chisquare/test/test.js     |  12 +-
 .../random/strided/exponential/test/test.js   |  12 +-
 .../random/strided/geometric/test/test.js     |  12 +-
 .../random/strided/poisson/test/test.js       |  12 +-
 .../random/strided/rayleigh/test/test.js      |  12 +-
 .../@stdlib/random/strided/t/test/test.js     |  12 +-
 .../@stdlib/random/strided/test/test.js       |   2 +-
 .../@stdlib/random/strided/tools/test/test.js |   2 +-
 lib/node_modules/@stdlib/random/test/test.js  |   2 +-
 .../random/tools/binary/test/test.validate.js |  18 +--
 .../@stdlib/random/tools/test/test.js         |   2 +-
 .../random/tools/unary/test/test.validate.js  |  18 +--
 .../@stdlib/random/uniform/test/test.js       |  12 +-
 400 files changed, 7578 insertions(+), 7539 deletions(-)

diff --git a/lib/node_modules/@stdlib/random/array/arcsine/test/test.js b/lib/node_modules/@stdlib/random/array/arcsine/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/arcsine/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/arcsine/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/bernoulli/test/test.js b/lib/node_modules/@stdlib/random/array/bernoulli/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/bernoulli/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/bernoulli/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/beta/test/test.js b/lib/node_modules/@stdlib/random/array/beta/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/beta/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/beta/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/betaprime/test/test.js b/lib/node_modules/@stdlib/random/array/betaprime/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/betaprime/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/betaprime/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/binomial/test/test.js b/lib/node_modules/@stdlib/random/array/binomial/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/binomial/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/binomial/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/cauchy/test/test.js b/lib/node_modules/@stdlib/random/array/cauchy/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/cauchy/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/cauchy/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/chi/test/test.js b/lib/node_modules/@stdlib/random/array/chi/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/chi/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/chi/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/chisquare/test/test.js b/lib/node_modules/@stdlib/random/array/chisquare/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/chisquare/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/chisquare/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/cosine/test/test.js b/lib/node_modules/@stdlib/random/array/cosine/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/cosine/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/cosine/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/discrete-uniform/test/test.js b/lib/node_modules/@stdlib/random/array/discrete-uniform/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/discrete-uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/discrete-uniform/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/erlang/test/test.js b/lib/node_modules/@stdlib/random/array/erlang/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/erlang/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/erlang/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/exponential/test/test.js b/lib/node_modules/@stdlib/random/array/exponential/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/exponential/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/exponential/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/f/test/test.js b/lib/node_modules/@stdlib/random/array/f/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/f/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/f/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/frechet/test/test.js b/lib/node_modules/@stdlib/random/array/frechet/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/frechet/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/frechet/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/gamma/test/test.js b/lib/node_modules/@stdlib/random/array/gamma/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/gamma/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/gamma/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/geometric/test/test.js b/lib/node_modules/@stdlib/random/array/geometric/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/geometric/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/geometric/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/gumbel/test/test.js b/lib/node_modules/@stdlib/random/array/gumbel/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/gumbel/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/gumbel/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/hypergeometric/test/test.js b/lib/node_modules/@stdlib/random/array/hypergeometric/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/hypergeometric/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/hypergeometric/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/invgamma/test/test.js b/lib/node_modules/@stdlib/random/array/invgamma/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/invgamma/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/invgamma/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/kumaraswamy/test/test.js b/lib/node_modules/@stdlib/random/array/kumaraswamy/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/kumaraswamy/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/kumaraswamy/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/laplace/test/test.js b/lib/node_modules/@stdlib/random/array/laplace/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/laplace/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/laplace/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/levy/test/test.js b/lib/node_modules/@stdlib/random/array/levy/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/levy/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/levy/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/logistic/test/test.js b/lib/node_modules/@stdlib/random/array/logistic/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/logistic/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/logistic/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/lognormal/test/test.js b/lib/node_modules/@stdlib/random/array/lognormal/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/lognormal/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/lognormal/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/minstd-shuffle/test/test.js b/lib/node_modules/@stdlib/random/array/minstd-shuffle/test/test.js
index acb135d5238d..55fe64ac8f7b 100644
--- a/lib/node_modules/@stdlib/random/array/minstd-shuffle/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/minstd-shuffle/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `normalized` method', function test( t )
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isInt32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isInt32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isInt32Array( random.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/minstd-shuffle/test/test.validate.js b/lib/node_modules/@stdlib/random/array/minstd-shuffle/test/test.validate.js
index 57da6bc58bbc..fe2a14c5f200 100644
--- a/lib/node_modules/@stdlib/random/array/minstd-shuffle/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/array/minstd-shuffle/test/test.validate.js
@@ -51,7 +51,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ], 0 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ], 1 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ], 2 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function returns an error if provided a `dtype` option which is not a
 			'dtype': values[ i ]
 		};
 		err = validate( {}, opts, 1 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'the function returns an error if provided a `dtype` option which is not a
 			'dtype': values[ i ]
 		};
 		err = validate( {}, opts, 2 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -186,7 +186,7 @@ tape( 'the function returns an error if provided an `idtype` option which is not
 			'idtype': values[ i ]
 		};
 		err = validate( {}, opts, 0 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function returns an error if provided an `ndtype` option which is not
 			'ndtype': values[ i ]
 		};
 		err = validate( {}, opts, 0 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function returns null if all options are valid (mode=1)', function te
 	opts = {};
 	err = validate( opts, options, 1 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -248,7 +248,7 @@ tape( 'the function returns null if all options are valid (mode=2)', function te
 	opts = {};
 	err = validate( opts, options, 2 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -266,7 +266,7 @@ tape( 'the function returns null if all options are valid (mode=0)', function te
 	opts = {};
 	err = validate( opts, options, 0 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -284,7 +284,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=0)', function
 	opts = {};
 	err = validate( opts, options, 0 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
@@ -301,7 +301,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=1)', function
 	opts = {};
 	err = validate( opts, options, 1 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
@@ -318,7 +318,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=2)', function
 	opts = {};
 	err = validate( opts, options, 2 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/minstd/test/test.js b/lib/node_modules/@stdlib/random/array/minstd/test/test.js
index acb135d5238d..55fe64ac8f7b 100644
--- a/lib/node_modules/@stdlib/random/array/minstd/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/minstd/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `normalized` method', function test( t )
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isInt32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isInt32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isInt32Array( random.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/minstd/test/test.validate.js b/lib/node_modules/@stdlib/random/array/minstd/test/test.validate.js
index 57da6bc58bbc..fe2a14c5f200 100644
--- a/lib/node_modules/@stdlib/random/array/minstd/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/array/minstd/test/test.validate.js
@@ -51,7 +51,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ], 0 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ], 1 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ], 2 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function returns an error if provided a `dtype` option which is not a
 			'dtype': values[ i ]
 		};
 		err = validate( {}, opts, 1 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'the function returns an error if provided a `dtype` option which is not a
 			'dtype': values[ i ]
 		};
 		err = validate( {}, opts, 2 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -186,7 +186,7 @@ tape( 'the function returns an error if provided an `idtype` option which is not
 			'idtype': values[ i ]
 		};
 		err = validate( {}, opts, 0 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function returns an error if provided an `ndtype` option which is not
 			'ndtype': values[ i ]
 		};
 		err = validate( {}, opts, 0 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function returns null if all options are valid (mode=1)', function te
 	opts = {};
 	err = validate( opts, options, 1 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -248,7 +248,7 @@ tape( 'the function returns null if all options are valid (mode=2)', function te
 	opts = {};
 	err = validate( opts, options, 2 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -266,7 +266,7 @@ tape( 'the function returns null if all options are valid (mode=0)', function te
 	opts = {};
 	err = validate( opts, options, 0 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -284,7 +284,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=0)', function
 	opts = {};
 	err = validate( opts, options, 0 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
@@ -301,7 +301,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=1)', function
 	opts = {};
 	err = validate( opts, options, 1 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
@@ -318,7 +318,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=2)', function
 	opts = {};
 	err = validate( opts, options, 2 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/mt19937/test/test.js b/lib/node_modules/@stdlib/random/array/mt19937/test/test.js
index 02f60806cd9b..3380fb96937b 100644
--- a/lib/node_modules/@stdlib/random/array/mt19937/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/mt19937/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `normalized` method', function test( t )
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/mt19937/test/test.validate.js b/lib/node_modules/@stdlib/random/array/mt19937/test/test.validate.js
index 57da6bc58bbc..fe2a14c5f200 100644
--- a/lib/node_modules/@stdlib/random/array/mt19937/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/array/mt19937/test/test.validate.js
@@ -51,7 +51,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ], 0 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ], 1 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ], 2 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function returns an error if provided a `dtype` option which is not a
 			'dtype': values[ i ]
 		};
 		err = validate( {}, opts, 1 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'the function returns an error if provided a `dtype` option which is not a
 			'dtype': values[ i ]
 		};
 		err = validate( {}, opts, 2 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -186,7 +186,7 @@ tape( 'the function returns an error if provided an `idtype` option which is not
 			'idtype': values[ i ]
 		};
 		err = validate( {}, opts, 0 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function returns an error if provided an `ndtype` option which is not
 			'ndtype': values[ i ]
 		};
 		err = validate( {}, opts, 0 );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function returns null if all options are valid (mode=1)', function te
 	opts = {};
 	err = validate( opts, options, 1 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -248,7 +248,7 @@ tape( 'the function returns null if all options are valid (mode=2)', function te
 	opts = {};
 	err = validate( opts, options, 2 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -266,7 +266,7 @@ tape( 'the function returns null if all options are valid (mode=0)', function te
 	opts = {};
 	err = validate( opts, options, 0 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -284,7 +284,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=0)', function
 	opts = {};
 	err = validate( opts, options, 0 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
@@ -301,7 +301,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=1)', function
 	opts = {};
 	err = validate( opts, options, 1 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
@@ -318,7 +318,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=2)', function
 	opts = {};
 	err = validate( opts, options, 2 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/negative-binomial/test/test.js b/lib/node_modules/@stdlib/random/array/negative-binomial/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/negative-binomial/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/negative-binomial/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/normal/test/test.js b/lib/node_modules/@stdlib/random/array/normal/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/normal/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/normal/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/pareto-type1/test/test.js b/lib/node_modules/@stdlib/random/array/pareto-type1/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/pareto-type1/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/pareto-type1/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/poisson/test/test.js b/lib/node_modules/@stdlib/random/array/poisson/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/poisson/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/poisson/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/randu/test/test.js b/lib/node_modules/@stdlib/random/array/randu/test/test.js
index e7f16e57b0d8..8f2e782f2b09 100644
--- a/lib/node_modules/@stdlib/random/array/randu/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/randu/test/test.js
@@ -39,31 +39,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/randu/test/test.validate.js b/lib/node_modules/@stdlib/random/array/randu/test/test.validate.js
index 9fbe15f9577c..6897b9348963 100644
--- a/lib/node_modules/@stdlib/random/array/randu/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/array/randu/test/test.validate.js
@@ -51,7 +51,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -78,7 +78,7 @@ tape( 'the function returns an error if provided a `dtype` option which is not a
 		err = validate( {}, {
 			'dtype': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -112,7 +112,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/rayleigh/test/test.js b/lib/node_modules/@stdlib/random/array/rayleigh/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/rayleigh/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/rayleigh/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/t/test/test.js b/lib/node_modules/@stdlib/random/array/t/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/t/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/t/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/test/test.js b/lib/node_modules/@stdlib/random/array/test/test.js
index 9fdab6e77188..93a939a5f431 100644
--- a/lib/node_modules/@stdlib/random/array/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/tools/test/test.js b/lib/node_modules/@stdlib/random/array/tools/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/random/array/tools/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/tools/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/triangular/test/test.js b/lib/node_modules/@stdlib/random/array/triangular/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/triangular/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/triangular/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/uniform/test/test.js b/lib/node_modules/@stdlib/random/array/uniform/test/test.js
index 7b02836935b4..a3049e6fef91 100644
--- a/lib/node_modules/@stdlib/random/array/uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/uniform/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/weibull/test/test.js b/lib/node_modules/@stdlib/random/array/weibull/test/test.js
index 308151d4278c..bb804be3f0d2 100644
--- a/lib/node_modules/@stdlib/random/array/weibull/test/test.js
+++ b/lib/node_modules/@stdlib/random/array/weibull/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/arcsine/test/test.factory.js b/lib/node_modules/@stdlib/random/base/arcsine/test/test.factory.js
index 3fcb665df657..fe2fbfb4f4f4 100644
--- a/lib/node_modules/@stdlib/random/base/arcsine/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/arcsine/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -392,14 +393,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	arcsine = factory( -10.0, 10.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = arcsine();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	arcsine = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = arcsine( -10.0, 10.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -426,7 +427,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = arcsine1();
 		r2 = arcsine2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -453,25 +454,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = arcsine1();
 		r2 = arcsine2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var arcsine = factory();
-	t.equal( arcsine.NAME, 'arcsine', 'has property' );
+	t.strictEqual( arcsine.NAME, 'arcsine', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var arcsine = factory();
-	t.equal( typeof arcsine.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof arcsine.PRNG, 'function', 'has property' );
 
 	arcsine = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( arcsine.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( arcsine.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -479,14 +480,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var arcsine = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( arcsine.seed ), true, 'has property' );
-	t.equal( arcsine.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( arcsine.seed ), true, 'has property' );
+	t.strictEqual( arcsine.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	arcsine = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( arcsine.seed, null, 'equal to `null`' );
+	t.strictEqual( arcsine.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -502,54 +503,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var arcsine = factory();
-	t.equal( typeof arcsine.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof arcsine.seedLength, 'number', 'has property' );
 
 	arcsine = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( arcsine.seedLength, null, 'equal to `null`' );
+	t.strictEqual( arcsine.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var arcsine = factory();
-	t.equal( isUint32Array( arcsine.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( arcsine.state ), true, 'has property' );
 
 	arcsine = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( arcsine.state, null, 'equal to `null`' );
+	t.strictEqual( arcsine.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var arcsine = factory();
-	t.equal( typeof arcsine.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof arcsine.stateLength, 'number', 'has property' );
 
 	arcsine = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( arcsine.stateLength, null, 'equal to `null`' );
+	t.strictEqual( arcsine.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var arcsine = factory();
-	t.equal( typeof arcsine.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof arcsine.byteLength, 'number', 'has property' );
 
 	arcsine = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( arcsine.byteLength, null, 'equal to `null`' );
+	t.strictEqual( arcsine.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -558,11 +559,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	arcsine = factory();
-	t.equal( typeof arcsine.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof arcsine.toJSON, 'function', 'has method' );
 
 	o = arcsine.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, arcsine.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, arcsine.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( arcsine.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -574,8 +575,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	arcsine = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof arcsine.toJSON, 'function', 'has method' );
-	t.equal( arcsine.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof arcsine.toJSON, 'function', 'has method' );
+	t.strictEqual( arcsine.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -644,7 +645,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = arcsine();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -660,7 +661,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = arcsine( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -695,7 +696,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = arcsine1();
 		r2 = arcsine2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -730,7 +731,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = arcsine1( 1.0, 2.0 );
 		r2 = arcsine2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -749,7 +750,7 @@ tape( 'the function returns a PRNG for generating random numbers from an arcsine
 	a = 2.0;
 	b = 4.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 500;
 
 	count = -1;
@@ -778,7 +779,7 @@ tape( 'the function returns a PRNG for generating random numbers from an arcsine
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'arcsine', a, b ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -837,7 +838,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( arcsine(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( arcsine(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -887,8 +888,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -905,8 +906,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -937,7 +938,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( arcsine(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( arcsine(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/arcsine/test/test.js b/lib/node_modules/@stdlib/random/base/arcsine/test/test.js
index d8c5a6aa33c4..e70a549cb3f9 100644
--- a/lib/node_modules/@stdlib/random/base/arcsine/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/arcsine/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof arcsine.factory, 'function', 'has method' );
+	t.strictEqual( typeof arcsine.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof arcsine.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof arcsine.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( arcsine.NAME, 'arcsine', 'has property' );
+	t.strictEqual( arcsine.NAME, 'arcsine', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof arcsine.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof arcsine.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( arcsine.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( arcsine.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof arcsine.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof arcsine.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( arcsine.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( arcsine.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof arcsine.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof arcsine.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof arcsine.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof arcsine.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -88,8 +88,8 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	b = 4.0;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = arcsine( a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( arcsine( 2.0, 4.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( arcsine( 2.0, 4.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/bernoulli/test/test.factory.js b/lib/node_modules/@stdlib/random/base/bernoulli/test/test.factory.js
index 725a3f4e466e..a4fe197c0606 100644
--- a/lib/node_modules/@stdlib/random/base/bernoulli/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/bernoulli/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -374,14 +375,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	bernoulli = factory( 0.05 );
 	for ( i = 0; i < 100; i++ ) {
 		r = bernoulli();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	bernoulli = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = bernoulli( 0.1 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -409,7 +410,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = bernoulli1();
 		r2 = bernoulli2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -436,25 +437,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = bernoulli1();
 		r2 = bernoulli2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var bernoulli = factory();
-	t.equal( bernoulli.NAME, 'bernoulli', 'has property' );
+	t.strictEqual( bernoulli.NAME, 'bernoulli', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var bernoulli = factory();
-	t.equal( typeof bernoulli.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof bernoulli.PRNG, 'function', 'has property' );
 
 	bernoulli = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( bernoulli.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( bernoulli.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -462,14 +463,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var bernoulli = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( bernoulli.seed ), true, 'has property' );
-	t.equal( bernoulli.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( bernoulli.seed ), true, 'has property' );
+	t.strictEqual( bernoulli.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	bernoulli = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( bernoulli.seed, null, 'equal to `null`' );
+	t.strictEqual( bernoulli.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -485,54 +486,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var bernoulli = factory();
-	t.equal( typeof bernoulli.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof bernoulli.seedLength, 'number', 'has property' );
 
 	bernoulli = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( bernoulli.seedLength, null, 'equal to `null`' );
+	t.strictEqual( bernoulli.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var bernoulli = factory();
-	t.equal( isUint32Array( bernoulli.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( bernoulli.state ), true, 'has property' );
 
 	bernoulli = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( bernoulli.state, null, 'equal to `null`' );
+	t.strictEqual( bernoulli.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var bernoulli = factory();
-	t.equal( typeof bernoulli.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof bernoulli.stateLength, 'number', 'has property' );
 
 	bernoulli = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( bernoulli.stateLength, null, 'equal to `null`' );
+	t.strictEqual( bernoulli.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var bernoulli = factory();
-	t.equal( typeof bernoulli.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof bernoulli.byteLength, 'number', 'has property' );
 
 	bernoulli = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( bernoulli.byteLength, null, 'equal to `null`' );
+	t.strictEqual( bernoulli.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -541,11 +542,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	bernoulli = factory();
-	t.equal( typeof bernoulli.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof bernoulli.toJSON, 'function', 'has method' );
 
 	o = bernoulli.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, bernoulli.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, bernoulli.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( bernoulli.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -557,8 +558,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	bernoulli = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof bernoulli.toJSON, 'function', 'has method' );
-	t.equal( bernoulli.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof bernoulli.toJSON, 'function', 'has method' );
+	t.strictEqual( bernoulli.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -603,7 +604,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = bernoulli();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -619,7 +620,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = bernoulli( 0.3 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -654,7 +655,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = bernoulli1();
 		r2 = bernoulli2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -689,7 +690,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = bernoulli1( 0.3 );
 		r2 = bernoulli2( 0.3 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -708,7 +709,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Bernoull
 
 	p = 0.67;
 
-	freq = new Array( 30 );
+	freq = zeros( 30 );
 	repeats = 200;
 	N = 1e3;
 
@@ -744,7 +745,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Bernoull
 				'simulate': true,
 				'iterations': 500
 			}).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -800,7 +801,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( bernoulli(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( bernoulli(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -850,8 +851,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -868,8 +869,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -900,7 +901,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( bernoulli(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( bernoulli(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/bernoulli/test/test.js b/lib/node_modules/@stdlib/random/base/bernoulli/test/test.js
index bf977e5374dc..3fc526b90fb1 100644
--- a/lib/node_modules/@stdlib/random/base/bernoulli/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/bernoulli/test/test.js
@@ -35,47 +35,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof bernoulli.factory, 'function', 'has method' );
+	t.strictEqual( typeof bernoulli.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof bernoulli.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof bernoulli.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( bernoulli.NAME, 'bernoulli', 'has property' );
+	t.strictEqual( bernoulli.NAME, 'bernoulli', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof bernoulli.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof bernoulli.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( bernoulli.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( bernoulli.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof bernoulli.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof bernoulli.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( bernoulli.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( bernoulli.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof bernoulli.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof bernoulli.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof bernoulli.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof bernoulli.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( bernoulli( 0.3 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( bernoulli( 0.3 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/beta/test/test.factory.js b/lib/node_modules/@stdlib/random/base/beta/test/test.factory.js
index ed5cc4436d88..beb47e7d6056 100644
--- a/lib/node_modules/@stdlib/random/base/beta/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/beta/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -515,19 +516,19 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	beta = factory( 2.0, 2.0 );
 	for ( i = 0; i < 1e3; i++ ) {
 		r = beta();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	beta = factory( 30.0, 30.0 );
 	for ( i = 0; i < 1e3; i++ ) {
 		r = beta();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	beta = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		r = beta( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -555,7 +556,7 @@ tape( 'the function returns a seeded pseudorandom number generator (alpha,beta <
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = beta1();
 		r2 = beta2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	t.end();
 });
@@ -582,7 +583,7 @@ tape( 'the function returns a seeded pseudorandom number generator (alpha = beta
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = beta1();
 		r2 = beta2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	t.end();
 });
@@ -609,7 +610,7 @@ tape( 'the function returns a seeded pseudorandom number generator (alpha != bet
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = beta1();
 		r2 = beta2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	t.end();
 });
@@ -636,25 +637,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = beta1();
 		r2 = beta2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var beta = factory();
-	t.equal( beta.NAME, 'beta', 'has property' );
+	t.strictEqual( beta.NAME, 'beta', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var beta = factory();
-	t.equal( typeof beta.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof beta.PRNG, 'function', 'has property' );
 
 	beta = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( beta.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( beta.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -662,14 +663,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var beta = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( beta.seed ), true, 'has property' );
-	t.equal( beta.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( beta.seed ), true, 'has property' );
+	t.strictEqual( beta.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	beta = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( beta.seed, null, 'equal to `null`' );
+	t.strictEqual( beta.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -685,54 +686,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var beta = factory();
-	t.equal( typeof beta.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof beta.seedLength, 'number', 'has property' );
 
 	beta = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( beta.seedLength, null, 'equal to `null`' );
+	t.strictEqual( beta.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the return function is the generator state', function test( t ) {
 	var beta = factory();
-	t.equal( isUint32Array( beta.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( beta.state ), true, 'has property' );
 
 	beta = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( beta.state, null, 'equal to `null`' );
+	t.strictEqual( beta.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var beta = factory();
-	t.equal( typeof beta.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof beta.stateLength, 'number', 'has property' );
 
 	beta = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( beta.stateLength, null, 'equal to `null`' );
+	t.strictEqual( beta.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var beta = factory();
-	t.equal( typeof beta.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof beta.byteLength, 'number', 'has property' );
 
 	beta = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( beta.byteLength, null, 'equal to `null`' );
+	t.strictEqual( beta.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -741,11 +742,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	beta = factory();
-	t.equal( typeof beta.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof beta.toJSON, 'function', 'has method' );
 
 	o = beta.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, beta.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, beta.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( beta.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -757,8 +758,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	beta = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof beta.toJSON, 'function', 'has method' );
-	t.equal( beta.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof beta.toJSON, 'function', 'has method' );
+	t.strictEqual( beta.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -892,7 +893,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = beta();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -908,7 +909,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = beta( 1.0, 1.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -943,7 +944,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = beta1();
 		r2 = beta2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -978,7 +979,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = beta1( 1.0, 1.0 );
 		r2 = beta2( 1.0, 1.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -997,7 +998,7 @@ tape( 'the function returns a PRNG for generating random numbers from a beta dis
 	alpha = 2.0;
 	beta = 4.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -1023,7 +1024,7 @@ tape( 'the function returns a PRNG for generating random numbers from a beta dis
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'beta', alpha, beta ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1068,7 +1069,7 @@ tape( 'the function returns a PRNG for generating random numbers from a beta dis
 	alpha = 0.1;
 	beta = 0.5;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -1094,7 +1095,7 @@ tape( 'the function returns a PRNG for generating random numbers from a beta dis
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'beta', alpha, beta ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1139,7 +1140,7 @@ tape( 'the function returns a PRNG for generating random numbers from a beta dis
 	alpha = 1001.0;
 	beta = 1.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -1165,7 +1166,7 @@ tape( 'the function returns a PRNG for generating random numbers from a beta dis
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'beta', alpha, beta ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1224,7 +1225,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( beta(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( beta(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1274,8 +1275,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1( 2.0, 4.0 );
 		v2 = rand2( 2.0, 4.0 );
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1292,8 +1293,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1( 2.0, 4.0 );
 		v2 = rand2( 2.0, 4.0 );
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1344,8 +1345,8 @@ tape( 'the function supports specifying a shared generator state (other argument
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1362,8 +1363,8 @@ tape( 'the function supports specifying a shared generator state (other argument
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1394,7 +1395,7 @@ tape( 'the returned function supports setting the generator state (alpha,beta <=
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( beta(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( beta(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1424,7 +1425,7 @@ tape( 'the returned function supports setting the generator state (alpha != beta
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( beta(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( beta(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1454,7 +1455,7 @@ tape( 'the returned function supports setting the generator state (alpha == beta
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( beta(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( beta(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/beta/test/test.js b/lib/node_modules/@stdlib/random/base/beta/test/test.js
index ef85ee895c34..a7a1391c6014 100644
--- a/lib/node_modules/@stdlib/random/base/beta/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/beta/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof beta.factory, 'function', 'has method' );
+	t.strictEqual( typeof beta.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof beta.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof beta.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( beta.NAME, 'beta', 'has property' );
+	t.strictEqual( beta.NAME, 'beta', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof beta.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof beta.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( beta.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( beta.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof beta.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof beta.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( beta.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( beta.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof beta.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof beta.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof beta.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof beta.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function supports setting the generator state (alpha = beta > 1.5)',
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( beta( 2.0, 2.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( beta( 2.0, 2.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the function supports setting the generator state (alpha != beta > 1.0)',
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( beta( 2.0, 5.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( beta( 2.0, 5.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -165,7 +165,7 @@ tape( 'the function supports setting the generator state (alpha,beta <= 1.0)', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( beta( 0.5, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( beta( 0.5, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/betaprime/test/test.factory.js b/lib/node_modules/@stdlib/random/base/betaprime/test/test.factory.js
index 54de97303348..bf4109e5efde 100644
--- a/lib/node_modules/@stdlib/random/base/betaprime/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/betaprime/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -374,19 +375,19 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	betaprime = factory( 2.0, 2.0 );
 	for ( i = 0; i < 400; i++ ) {
 		r = betaprime();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	betaprime = factory( 30.0, 30.0 );
 	for ( i = 0; i < 400; i++ ) {
 		r = betaprime();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	betaprime = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = betaprime( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -414,7 +415,7 @@ tape( 'the function returns a seeded pseudorandom number generator (alpha,beta <
 	for ( i = 0; i < 1e3; i++ ) {
 		r1 = betaprime1();
 		r2 = betaprime2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	t.end();
 });
@@ -441,7 +442,7 @@ tape( 'the function returns a seeded pseudorandom number generator (alpha = beta
 	for ( i = 0; i < 1e3; i++ ) {
 		r1 = betaprime1();
 		r2 = betaprime2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	t.end();
 });
@@ -468,7 +469,7 @@ tape( 'the function returns a seeded pseudorandom number generator (alpha != bet
 	for ( i = 0; i < 1e3; i++ ) {
 		r1 = betaprime1();
 		r2 = betaprime2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	t.end();
 });
@@ -495,25 +496,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 1e3; i++ ) {
 		r1 = betaprime1();
 		r2 = betaprime2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var betaprime = factory();
-	t.equal( betaprime.NAME, 'betaprime', 'has property' );
+	t.strictEqual( betaprime.NAME, 'betaprime', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var betaprime = factory();
-	t.equal( typeof betaprime.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof betaprime.PRNG, 'function', 'has property' );
 
 	betaprime = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( betaprime.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( betaprime.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -521,14 +522,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var betaprime = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( betaprime.seed ), true, 'has property' );
-	t.equal( betaprime.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( betaprime.seed ), true, 'has property' );
+	t.strictEqual( betaprime.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	betaprime = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( betaprime.seed, null, 'equal to `null`' );
+	t.strictEqual( betaprime.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -544,54 +545,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var betaprime = factory();
-	t.equal( typeof betaprime.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof betaprime.seedLength, 'number', 'has property' );
 
 	betaprime = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( betaprime.seedLength, null, 'equal to `null`' );
+	t.strictEqual( betaprime.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var betaprime = factory();
-	t.equal( isUint32Array( betaprime.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( betaprime.state ), true, 'has property' );
 
 	betaprime = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( betaprime.state, null, 'equal to `null`' );
+	t.strictEqual( betaprime.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var betaprime = factory();
-	t.equal( typeof betaprime.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof betaprime.stateLength, 'number', 'has property' );
 
 	betaprime = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( betaprime.stateLength, null, 'equal to `null`' );
+	t.strictEqual( betaprime.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var betaprime = factory();
-	t.equal( typeof betaprime.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof betaprime.byteLength, 'number', 'has property' );
 
 	betaprime = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( betaprime.byteLength, null, 'equal to `null`' );
+	t.strictEqual( betaprime.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -600,11 +601,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	betaprime = factory();
-	t.equal( typeof betaprime.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof betaprime.toJSON, 'function', 'has method' );
 
 	o = betaprime.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, betaprime.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, betaprime.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( betaprime.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -616,8 +617,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	betaprime = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof betaprime.toJSON, 'function', 'has method' );
-	t.equal( betaprime.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof betaprime.toJSON, 'function', 'has method' );
+	t.strictEqual( betaprime.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -696,7 +697,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = betaprime();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -712,7 +713,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = betaprime( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -747,7 +748,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = betaprime1();
 		r2 = betaprime2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -782,7 +783,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = betaprime1( 1.0, 2.0 );
 		r2 = betaprime2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -801,7 +802,7 @@ tape( 'the function returns a PRNG for generating random numbers from a beta pri
 	alpha = 0.1;
 	beta = 0.5;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -827,7 +828,7 @@ tape( 'the function returns a PRNG for generating random numbers from a beta pri
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'betaprime', alpha, beta ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -886,7 +887,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( betaprime(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( betaprime(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -936,8 +937,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -954,8 +955,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -986,7 +987,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( betaprime(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( betaprime(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/betaprime/test/test.js b/lib/node_modules/@stdlib/random/base/betaprime/test/test.js
index e50888ae70fc..dff786bee320 100644
--- a/lib/node_modules/@stdlib/random/base/betaprime/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/betaprime/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof betaprime.factory, 'function', 'has method' );
+	t.strictEqual( typeof betaprime.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof betaprime.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof betaprime.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( betaprime.NAME, 'betaprime', 'has property' );
+	t.strictEqual( betaprime.NAME, 'betaprime', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof betaprime.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof betaprime.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( betaprime.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( betaprime.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof betaprime.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof betaprime.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( betaprime.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( betaprime.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof betaprime.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof betaprime.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof betaprime.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof betaprime.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( betaprime( 3.14, 1.25 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( betaprime( 3.14, 1.25 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/binomial/test/test.correction.js b/lib/node_modules/@stdlib/random/base/binomial/test/test.correction.js
index e54733a17ad4..bedb13bac747 100644
--- a/lib/node_modules/@stdlib/random/base/binomial/test/test.correction.js
+++ b/lib/node_modules/@stdlib/random/base/binomial/test/test.correction.js
@@ -52,7 +52,7 @@ tape( 'the function returns the Stirling correction term for nonnegative integer
 	];
 	for ( k = 0; k < expected.length; k++ ) {
 		val = correction( k );
-		t.equal( val, expected[ k ], 'returns correction term for k='+k );
+		t.strictEqual( val, expected[ k ], 'returns correction term for k='+k );
 	}
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'the function computes the Stirling correction term for nonnegative intege
 		expected = 1.0/12.0;
 		expected -= ( (1.0/360.0) - (1.0/1260.0/k2) ) / k2;
 		expected /= k;
-		t.equal( val, expected, 'k: '+k+'. actual: '+val+'. expected: '+expected+'.' );
+		t.strictEqual( val, expected, 'k: '+k+'. actual: '+val+'. expected: '+expected+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/binomial/test/test.factory.js b/lib/node_modules/@stdlib/random/base/binomial/test/test.factory.js
index 0e1954106ac1..7cb53c25b6dd 100644
--- a/lib/node_modules/@stdlib/random/base/binomial/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/binomial/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -376,14 +377,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	binomial = factory( 80, 0.05 );
 	for ( i = 0; i < 100; i++ ) {
 		r = binomial();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	binomial = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = binomial( 120, 0.75 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -411,7 +412,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 200; i++ ) {
 		r1 = binomial1();
 		r2 = binomial2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	seed = now();
 
@@ -427,7 +428,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 200; i++ ) {
 		r1 = binomial1();
 		r2 = binomial2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	seed = now();
 
@@ -443,7 +444,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 200; i++ ) {
 		r1 = binomial1();
 		r2 = binomial2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 
 	seed = now();
@@ -460,7 +461,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 200; i++ ) {
 		r1 = binomial1();
 		r2 = binomial2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	t.end();
 });
@@ -487,7 +488,7 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 200; i++ ) {
 		r1 = binomial1();
 		r2 = binomial2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	seed = [ now()+1, now()+2, now()+3, now()+4 ];
 
@@ -503,7 +504,7 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 200; i++ ) {
 		r1 = binomial1();
 		r2 = binomial2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	seed = [ now()+1, now()+2, now()+3, now()+4 ];
 
@@ -519,7 +520,7 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 200; i++ ) {
 		r1 = binomial1();
 		r2 = binomial2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 
 	seed = [ now()+1, now()+2, now()+3, now()+4 ];
@@ -536,25 +537,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 200; i++ ) {
 		r1 = binomial1();
 		r2 = binomial2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var binomial = factory();
-	t.equal( binomial.NAME, 'binomial', 'has property' );
+	t.strictEqual( binomial.NAME, 'binomial', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var binomial = factory();
-	t.equal( typeof binomial.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof binomial.PRNG, 'function', 'has property' );
 
 	binomial = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( binomial.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( binomial.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -562,14 +563,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var binomial = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( binomial.seed ), true, 'has property' );
-	t.equal( binomial.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( binomial.seed ), true, 'has property' );
+	t.strictEqual( binomial.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	binomial = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( binomial.seed, null, 'equal to `null`' );
+	t.strictEqual( binomial.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -585,54 +586,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var binomial = factory();
-	t.equal( typeof binomial.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof binomial.seedLength, 'number', 'has property' );
 
 	binomial = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( binomial.seedLength, null, 'equal to `null`' );
+	t.strictEqual( binomial.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var binomial = factory();
-	t.equal( isUint32Array( binomial.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( binomial.state ), true, 'has property' );
 
 	binomial = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( binomial.state, null, 'equal to `null`' );
+	t.strictEqual( binomial.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var binomial = factory();
-	t.equal( typeof binomial.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof binomial.stateLength, 'number', 'has property' );
 
 	binomial = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( binomial.stateLength, null, 'equal to `null`' );
+	t.strictEqual( binomial.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var binomial = factory();
-	t.equal( typeof binomial.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof binomial.byteLength, 'number', 'has property' );
 
 	binomial = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( binomial.byteLength, null, 'equal to `null`' );
+	t.strictEqual( binomial.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -641,11 +642,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	binomial = factory();
-	t.equal( typeof binomial.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof binomial.toJSON, 'function', 'has method' );
 
 	o = binomial.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, binomial.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, binomial.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( binomial.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -657,8 +658,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	binomial = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof binomial.toJSON, 'function', 'has method' );
-	t.equal( binomial.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof binomial.toJSON, 'function', 'has method' );
+	t.strictEqual( binomial.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -743,7 +744,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = binomial();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -759,7 +760,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = binomial( 10, 0.3 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -794,7 +795,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = binomial1();
 		r2 = binomial2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -829,7 +830,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = binomial1( 10, 0.3 );
 		r2 = binomial2( 10, 0.3 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -850,7 +851,7 @@ tape( 'the function returns a PRNG for generating random numbers from a binomial
 	n = 20;
 	p = 0.67;
 
-	freq = new Array( n+1 );
+	freq = zeros( n+1 );
 	repeats = 100;
 	N = 1e3;
 
@@ -886,7 +887,7 @@ tape( 'the function returns a PRNG for generating random numbers from a binomial
 				'simulate': true,
 				'iterations': 500
 			}).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -932,7 +933,7 @@ tape( 'the function returns a PRNG for generating random numbers from a binomial
 	n = 8;
 	p = 0.39;
 
-	freq = new Array( n+1 );
+	freq = zeros( n+1 );
 	repeats = 100;
 	N = 1e3;
 
@@ -968,7 +969,7 @@ tape( 'the function returns a PRNG for generating random numbers from a binomial
 				'simulate': true,
 				'iterations': 500
 			}).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1027,7 +1028,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( binomial(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( binomial(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1077,8 +1078,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1095,8 +1096,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1127,7 +1128,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( binomial(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( binomial(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1157,7 +1158,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( binomial(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( binomial(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/binomial/test/test.js b/lib/node_modules/@stdlib/random/base/binomial/test/test.js
index 0ccff968a241..9e700d9937a5 100644
--- a/lib/node_modules/@stdlib/random/base/binomial/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/binomial/test/test.js
@@ -37,47 +37,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof binomial.factory, 'function', 'has method' );
+	t.strictEqual( typeof binomial.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof binomial.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof binomial.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( binomial.NAME, 'binomial', 'has property' );
+	t.strictEqual( binomial.NAME, 'binomial', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof binomial.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof binomial.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( binomial.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( binomial.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof binomial.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof binomial.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( binomial.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( binomial.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof binomial.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof binomial.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof binomial.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof binomial.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -122,7 +122,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( binomial( 20, 0.67 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( binomial( 20, 0.67 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( binomial( 8, 0.39 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( binomial( 8, 0.39 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/box-muller/test/test.factory.js b/lib/node_modules/@stdlib/random/base/box-muller/test/test.factory.js
index 729d156c1e20..81d5ebe5bd59 100644
--- a/lib/node_modules/@stdlib/random/base/box-muller/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/box-muller/test/test.factory.js
@@ -29,6 +29,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var isUint32Array = require( '@stdlib/assert/is-uint32array' );
 var typedarray2json = require( '@stdlib/array/to-json' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -254,7 +255,7 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	randn = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -267,7 +268,7 @@ tape( 'the function returns a pseudorandom number generator (options; no seed)',
 	randn = factory( {} );
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -294,7 +295,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 1e3; i++ ) {
 		r1 = randn1();
 		r2 = randn2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -321,33 +322,33 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 1e3; i++ ) {
 		r1 = randn1();
 		r2 = randn2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var randn = factory();
-	t.equal( randn.NAME, 'box-muller', 'has property' );
+	t.strictEqual( randn.NAME, 'box-muller', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var randn = factory();
-	t.equal( typeof randn.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof randn.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the minimum possible generated number', function test( t ) {
 	var randn = factory();
 
-	t.equal( typeof randn.MIN, 'number', 'has property' );
-	t.equal( randn.MIN < 0.0, true, 'less than 0' );
+	t.strictEqual( typeof randn.MIN, 'number', 'has property' );
+	t.strictEqual( randn.MIN < 0.0, true, 'less than 0' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( randn.MIN, null, 'equal to `null`' );
+	t.strictEqual( randn.MIN, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -355,13 +356,13 @@ tape( 'attached to the returned function is the minimum possible generated numbe
 tape( 'attached to the returned function is the maximum possible generated number', function test( t ) {
 	var randn = factory();
 
-	t.equal( typeof randn.MAX, 'number', 'has property' );
-	t.equal( randn.MAX > 0.0, true, 'greater than 0' );
+	t.strictEqual( typeof randn.MAX, 'number', 'has property' );
+	t.strictEqual( randn.MAX > 0.0, true, 'greater than 0' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( randn.MAX, null, 'equal to `null`' );
+	t.strictEqual( randn.MAX, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -375,13 +376,13 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	});
 	actual = randn.seed;
 
-	t.equal( isUint32Array( actual ), true, 'has property' );
-	t.equal( actual[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( actual[ 0 ], 12345, 'equal to provided seed' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( randn.seed, null, 'equal to `null`' );
+	t.strictEqual( randn.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -398,54 +399,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = randn.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var randn = factory();
-	t.equal( typeof randn.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.seedLength, 'number', 'has property' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( randn.seedLength, null, 'equal to `null`' );
+	t.strictEqual( randn.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var randn = factory();
-	t.equal( isUint32Array( randn.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( randn.state ), true, 'has property' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( randn.state, null, 'equal to `null`' );
+	t.strictEqual( randn.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var randn = factory();
-	t.equal( typeof randn.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.stateLength, 'number', 'has property' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( randn.stateLength, null, 'equal to `null`' );
+	t.strictEqual( randn.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var randn = factory();
-	t.equal( typeof randn.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.byteLength, 'number', 'has property' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( randn.byteLength, null, 'equal to `null`' );
+	t.strictEqual( randn.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -454,19 +455,19 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	randn = factory();
-	t.equal( typeof randn.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof randn.toJSON, 'function', 'has method' );
 
 	o = randn.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, randn.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, randn.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( randn.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( typeof randn.toJSON, 'function', 'has method' );
-	t.equal( randn.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof randn.toJSON, 'function', 'has method' );
+	t.strictEqual( randn.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -537,7 +538,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -572,7 +573,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e3; i++ ) {
 		r1 = randn1();
 		r2 = randn2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -586,7 +587,7 @@ tape( 'the function returns pseudorandom numbers from a standard normal distribu
 
 	threshold = 0.10;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -612,7 +613,7 @@ tape( 'the function returns pseudorandom numbers from a standard normal distribu
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'normal', 0.0, 1.0 ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -671,7 +672,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -722,13 +723,13 @@ tape( 'the function supports specifying a shared generator state', function test
 		// NOTE: more complicated to test due to the generation of two pseudorandom variates at a time...
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+2 ], 'returns expected value. i: '+(j+2)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+2 ], 'returns expected value. i: '+(j+2)+'.' );
 
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
-		t.equal( v2, arr[ j+3 ], 'returns expected value. i: '+(j+3)+'.' );
+		t.strictEqual( v1, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v2, arr[ j+3 ], 'returns expected value. i: '+(j+3)+'.' );
 
 		j += 4; // stride
 	}
@@ -747,13 +748,13 @@ tape( 'the function supports specifying a shared generator state', function test
 		// NOTE: more complicated to test due to the generation of two pseudorandom variates at a time...
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+2 ], 'returns expected value. i: '+(j+2)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+2 ], 'returns expected value. i: '+(j+2)+'.' );
 
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
-		t.equal( v2, arr[ j+3 ], 'returns expected value. i: '+(j+3)+'.' );
+		t.strictEqual( v1, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v2, arr[ j+3 ], 'returns expected value. i: '+(j+3)+'.' );
 
 		j += 4; // stride
 	}
@@ -785,7 +786,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/box-muller/test/test.js b/lib/node_modules/@stdlib/random/base/box-muller/test/test.js
index 2f0944e3cab8..6b7554f9a85d 100644
--- a/lib/node_modules/@stdlib/random/base/box-muller/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/box-muller/test/test.js
@@ -34,59 +34,59 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof randn.factory, 'function', 'has method' );
+	t.strictEqual( typeof randn.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof randn.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof randn.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( randn.NAME, 'box-muller', 'has property' );
+	t.strictEqual( randn.NAME, 'box-muller', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof randn.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof randn.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the minimum possible generated number', function test( t ) {
-	t.equal( typeof randn.MIN, 'number', 'has property' );
-	t.equal( randn.MIN < 0.0, true, 'less than 0' );
+	t.strictEqual( typeof randn.MIN, 'number', 'has property' );
+	t.strictEqual( randn.MIN < 0.0, true, 'less than 0' );
 	t.end();
 });
 
 tape( 'attached to the main export is the maximum possible generated number', function test( t ) {
-	t.equal( typeof randn.MAX, 'number', 'has property' );
-	t.equal( randn.MAX > 0.0, true, 'greater than 0' );
+	t.strictEqual( typeof randn.MAX, 'number', 'has property' );
+	t.strictEqual( randn.MAX > 0.0, true, 'greater than 0' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( randn.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( randn.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof randn.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( randn.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( randn.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof randn.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof randn.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -95,7 +95,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/cauchy/test/test.factory.js b/lib/node_modules/@stdlib/random/base/cauchy/test/test.factory.js
index 004819d66534..55702664c9e2 100644
--- a/lib/node_modules/@stdlib/random/base/cauchy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/cauchy/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -372,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	cauchy = factory( 2.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = cauchy();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	cauchy = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = cauchy( 2.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -407,7 +408,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = cauchy1();
 		r2 = cauchy2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -434,25 +435,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = cauchy1();
 		r2 = cauchy2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var cauchy = factory();
-	t.equal( cauchy.NAME, 'cauchy', 'has property' );
+	t.strictEqual( cauchy.NAME, 'cauchy', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var cauchy = factory();
-	t.equal( typeof cauchy.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof cauchy.PRNG, 'function', 'has property' );
 
 	cauchy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( cauchy.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( cauchy.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -460,14 +461,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var cauchy = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( cauchy.seed ), true, 'has property' );
-	t.equal( cauchy.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( cauchy.seed ), true, 'has property' );
+	t.strictEqual( cauchy.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	cauchy = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( cauchy.seed, null, 'equal to `null`' );
+	t.strictEqual( cauchy.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -483,54 +484,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var cauchy = factory();
-	t.equal( typeof cauchy.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof cauchy.seedLength, 'number', 'has property' );
 
 	cauchy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( cauchy.seedLength, null, 'equal to `null`' );
+	t.strictEqual( cauchy.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var cauchy = factory();
-	t.equal( isUint32Array( cauchy.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( cauchy.state ), true, 'has property' );
 
 	cauchy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( cauchy.state, null, 'equal to `null`' );
+	t.strictEqual( cauchy.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var cauchy = factory();
-	t.equal( typeof cauchy.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof cauchy.stateLength, 'number', 'has property' );
 
 	cauchy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( cauchy.stateLength, null, 'equal to `null`' );
+	t.strictEqual( cauchy.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var cauchy = factory();
-	t.equal( typeof cauchy.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof cauchy.byteLength, 'number', 'has property' );
 
 	cauchy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( cauchy.byteLength, null, 'equal to `null`' );
+	t.strictEqual( cauchy.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -539,11 +540,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	cauchy = factory();
-	t.equal( typeof cauchy.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof cauchy.toJSON, 'function', 'has method' );
 
 	o = cauchy.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, cauchy.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, cauchy.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( cauchy.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -555,13 +556,13 @@ tape( 'attached to the returned function is a method to serialize the generator
 	cauchy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof cauchy.toJSON, 'function', 'has method' );
-	t.equal( cauchy.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof cauchy.toJSON, 'function', 'has method' );
+	t.strictEqual( cauchy.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument.strictEqual to `NaN`', function test( t ) {
 	var cauchy;
 	var r;
 
@@ -572,7 +573,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument.strictEqual to `NaN`', function test( t ) {
 	var cauchy;
 	var r;
 
@@ -620,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = cauchy();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -636,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = cauchy( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -671,7 +672,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = cauchy1();
 		r2 = cauchy2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -706,7 +707,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = cauchy1( 1.0, 2.0 );
 		r2 = cauchy2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -725,7 +726,7 @@ tape( 'the function returns a PRNG for generating random numbers from the specif
 	x0 = 2.0;
 	gamma = 4.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -751,7 +752,7 @@ tape( 'the function returns a PRNG for generating random numbers from the specif
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'cauchy', x0, gamma ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -810,7 +811,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( cauchy(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( cauchy(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -860,8 +861,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -878,8 +879,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -910,7 +911,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( cauchy(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( cauchy(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/cauchy/test/test.js b/lib/node_modules/@stdlib/random/base/cauchy/test/test.js
index 4c7e1372ef11..103eaf02cf47 100644
--- a/lib/node_modules/@stdlib/random/base/cauchy/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/cauchy/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof cauchy.factory, 'function', 'has method' );
+	t.strictEqual( typeof cauchy.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof cauchy.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof cauchy.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( cauchy.NAME, 'cauchy', 'has property' );
+	t.strictEqual( cauchy.NAME, 'cauchy', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof cauchy.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof cauchy.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( cauchy.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( cauchy.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof cauchy.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof cauchy.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( cauchy.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( cauchy.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof cauchy.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof cauchy.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof cauchy.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof cauchy.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = cauchy( 2.0, 1.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( cauchy( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( cauchy( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/chi/test/test.factory.js b/lib/node_modules/@stdlib/random/base/chi/test/test.factory.js
index c144ea33b069..25f21a8618a0 100644
--- a/lib/node_modules/@stdlib/random/base/chi/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/chi/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -372,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	chi = factory( 2 );
 	for ( i = 0; i < 100; i++ ) {
 		r = chi();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameter...
 	chi = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = chi( 100.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -407,7 +408,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = chi1();
 		r2 = chi2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -434,25 +435,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = chi1();
 		r2 = chi2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var chi = factory();
-	t.equal( chi.NAME, 'chi', 'has property' );
+	t.strictEqual( chi.NAME, 'chi', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var chi = factory();
-	t.equal( typeof chi.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof chi.PRNG, 'function', 'has property' );
 
 	chi = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( chi.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( chi.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -460,14 +461,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var chi = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( chi.seed ), true, 'has property' );
-	t.equal( chi.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( chi.seed ), true, 'has property' );
+	t.strictEqual( chi.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	chi = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( chi.seed, null, 'equal to `null`' );
+	t.strictEqual( chi.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -483,54 +484,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var chi = factory();
-	t.equal( typeof chi.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof chi.seedLength, 'number', 'has property' );
 
 	chi = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( chi.seedLength, null, 'equal to `null`' );
+	t.strictEqual( chi.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var chi = factory();
-	t.equal( isUint32Array( chi.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( chi.state ), true, 'has property' );
 
 	chi = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( chi.state, null, 'equal to `null`' );
+	t.strictEqual( chi.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var chi = factory();
-	t.equal( typeof chi.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof chi.stateLength, 'number', 'has property' );
 
 	chi = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( chi.stateLength, null, 'equal to `null`' );
+	t.strictEqual( chi.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var chi = factory();
-	t.equal( typeof chi.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof chi.byteLength, 'number', 'has property' );
 
 	chi = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( chi.byteLength, null, 'equal to `null`' );
+	t.strictEqual( chi.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -539,11 +540,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	chi = factory();
-	t.equal( typeof chi.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof chi.toJSON, 'function', 'has method' );
 
 	o = chi.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, chi.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, chi.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( chi.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -555,13 +556,13 @@ tape( 'attached to the returned function is a method to serialize the generator
 	chi = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof chi.toJSON, 'function', 'has method' );
-	t.equal( chi.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof chi.toJSON, 'function', 'has method' );
+	t.strictEqual( chi.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument.strictEqual to `NaN`', function test( t ) {
 	var chi;
 	var r;
 
@@ -601,7 +602,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = chi();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -617,7 +618,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = chi( 4 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -652,7 +653,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = chi1();
 		r2 = chi2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -687,7 +688,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = chi1( 4 );
 		r2 = chi2( 4 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -704,7 +705,7 @@ tape( 'the function returns a PRNG for generating random numbers from a chi dist
 
 	k = 4;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -730,7 +731,7 @@ tape( 'the function returns a PRNG for generating random numbers from a chi dist
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'chi', k ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -789,7 +790,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( chi(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( chi(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -839,8 +840,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -857,8 +858,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -889,7 +890,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( chi(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( chi(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/chi/test/test.js b/lib/node_modules/@stdlib/random/base/chi/test/test.js
index 7e73e0bdc304..8d65823c576e 100644
--- a/lib/node_modules/@stdlib/random/base/chi/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/chi/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof chi.factory, 'function', 'has method' );
+	t.strictEqual( typeof chi.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof chi.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof chi.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( chi.NAME, 'chi', 'has property' );
+	t.strictEqual( chi.NAME, 'chi', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof chi.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof chi.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( chi.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( chi.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof chi.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof chi.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( chi.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( chi.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof chi.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof chi.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof chi.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof chi.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = chi( 3.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( chi( 4 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( chi( 4 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/chisquare/test/test.factory.js b/lib/node_modules/@stdlib/random/base/chisquare/test/test.factory.js
index a9e515b4c199..268aab995cef 100644
--- a/lib/node_modules/@stdlib/random/base/chisquare/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/chisquare/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -372,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	chisquare = factory( 2 );
 	for ( i = 0; i < 100; i++ ) {
 		r = chisquare();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameter...
 	chisquare = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = chisquare( 100.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -407,7 +408,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = chisquare1();
 		r2 = chisquare2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -434,25 +435,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = chisquare1();
 		r2 = chisquare2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var chisquare = factory();
-	t.equal( chisquare.NAME, 'chisquare', 'has property' );
+	t.strictEqual( chisquare.NAME, 'chisquare', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var chisquare = factory();
-	t.equal( typeof chisquare.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof chisquare.PRNG, 'function', 'has property' );
 
 	chisquare = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( chisquare.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( chisquare.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -460,14 +461,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var chisquare = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( chisquare.seed ), true, 'has property' );
-	t.equal( chisquare.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( chisquare.seed ), true, 'has property' );
+	t.strictEqual( chisquare.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	chisquare = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( chisquare.seed, null, 'equal to `null`' );
+	t.strictEqual( chisquare.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -483,54 +484,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var chisquare = factory();
-	t.equal( typeof chisquare.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof chisquare.seedLength, 'number', 'has property' );
 
 	chisquare = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( chisquare.seedLength, null, 'equal to `null`' );
+	t.strictEqual( chisquare.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var chisquare = factory();
-	t.equal( isUint32Array( chisquare.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( chisquare.state ), true, 'has property' );
 
 	chisquare = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( chisquare.state, null, 'equal to `null`' );
+	t.strictEqual( chisquare.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var chisquare = factory();
-	t.equal( typeof chisquare.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof chisquare.stateLength, 'number', 'has property' );
 
 	chisquare = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( chisquare.stateLength, null, 'equal to `null`' );
+	t.strictEqual( chisquare.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var chisquare = factory();
-	t.equal( typeof chisquare.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof chisquare.byteLength, 'number', 'has property' );
 
 	chisquare = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( chisquare.byteLength, null, 'equal to `null`' );
+	t.strictEqual( chisquare.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -539,11 +540,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	chisquare = factory();
-	t.equal( typeof chisquare.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof chisquare.toJSON, 'function', 'has method' );
 
 	o = chisquare.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, chisquare.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, chisquare.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( chisquare.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -555,13 +556,13 @@ tape( 'attached to the returned function is a method to serialize the generator
 	chisquare = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof chisquare.toJSON, 'function', 'has method' );
-	t.equal( chisquare.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof chisquare.toJSON, 'function', 'has method' );
+	t.strictEqual( chisquare.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument.strictEqual to `NaN`', function test( t ) {
 	var chisquare;
 	var r;
 
@@ -601,7 +602,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = chisquare();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -617,7 +618,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = chisquare( 10 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -652,7 +653,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = chisquare1();
 		r2 = chisquare2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -687,7 +688,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = chisquare1( 10 );
 		r2 = chisquare2( 10 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -704,7 +705,7 @@ tape( 'the function returns a PRNG for generating random numbers from a chi-squa
 
 	k = 4;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -730,7 +731,7 @@ tape( 'the function returns a PRNG for generating random numbers from a chi-squa
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'chisquare', k ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -789,7 +790,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( chisquare(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( chisquare(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -839,8 +840,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -857,8 +858,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -889,7 +890,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( chisquare(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( chisquare(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/chisquare/test/test.js b/lib/node_modules/@stdlib/random/base/chisquare/test/test.js
index 94c6189cf21a..ba06c5d82d97 100644
--- a/lib/node_modules/@stdlib/random/base/chisquare/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/chisquare/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof chisquare.factory, 'function', 'has `method' );
+	t.strictEqual( typeof chisquare.factory, 'function', 'has `method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof chisquare.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof chisquare.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( chisquare.NAME, 'chisquare', 'has property' );
+	t.strictEqual( chisquare.NAME, 'chisquare', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof chisquare.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof chisquare.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( chisquare.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( chisquare.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof chisquare.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof chisquare.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( chisquare.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( chisquare.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof chisquare.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof chisquare.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof chisquare.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof chisquare.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = chisquare( 3.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( chisquare( 2 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( chisquare( 2 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/cosine/test/test.factory.js b/lib/node_modules/@stdlib/random/base/cosine/test/test.factory.js
index edc9b2a0f110..5b60e3c91f7f 100644
--- a/lib/node_modules/@stdlib/random/base/cosine/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/cosine/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -372,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	cosine = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = cosine();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	cosine = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = cosine( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -407,7 +408,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = cosine1();
 		r2 = cosine2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -434,25 +435,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = cosine1();
 		r2 = cosine2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var cosine = factory();
-	t.equal( cosine.NAME, 'cosine', 'has property' );
+	t.strictEqual( cosine.NAME, 'cosine', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var cosine = factory();
-	t.equal( typeof cosine.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof cosine.PRNG, 'function', 'has property' );
 
 	cosine = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( cosine.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( cosine.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -460,14 +461,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var cosine = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( cosine.seed ), true, 'has property' );
-	t.equal( cosine.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( cosine.seed ), true, 'has property' );
+	t.strictEqual( cosine.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	cosine = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( cosine.seed, null, 'equal to `null`' );
+	t.strictEqual( cosine.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -483,54 +484,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var cosine = factory();
-	t.equal( typeof cosine.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof cosine.seedLength, 'number', 'has property' );
 
 	cosine = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( cosine.seedLength, null, 'equal to `null`' );
+	t.strictEqual( cosine.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var cosine = factory();
-	t.equal( isUint32Array( cosine.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( cosine.state ), true, 'has property' );
 
 	cosine = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( cosine.state, null, 'equal to `null`' );
+	t.strictEqual( cosine.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var cosine = factory();
-	t.equal( typeof cosine.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof cosine.stateLength, 'number', 'has property' );
 
 	cosine = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( cosine.stateLength, null, 'equal to `null`' );
+	t.strictEqual( cosine.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var cosine = factory();
-	t.equal( typeof cosine.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof cosine.byteLength, 'number', 'has property' );
 
 	cosine = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( cosine.byteLength, null, 'equal to `null`' );
+	t.strictEqual( cosine.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -539,11 +540,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	cosine = factory();
-	t.equal( typeof cosine.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof cosine.toJSON, 'function', 'has method' );
 
 	o = cosine.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, cosine.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, cosine.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( cosine.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -555,13 +556,13 @@ tape( 'attached to the returned function is a method to serialize the generator
 	cosine = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof cosine.toJSON, 'function', 'has method' );
-	t.equal( cosine.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof cosine.toJSON, 'function', 'has method' );
+	t.strictEqual( cosine.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument.strictEqual to `NaN`', function test( t ) {
 	var cosine;
 	var r;
 
@@ -572,7 +573,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument.strictEqual to `NaN`', function test( t ) {
 	var cosine;
 	var r;
 
@@ -620,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = cosine();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -636,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = cosine( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -671,7 +672,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = cosine1();
 		r2 = cosine2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -706,7 +707,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = cosine1( 1.0, 2.0 );
 		r2 = cosine2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -725,7 +726,7 @@ tape( 'the function returns a PRNG for generating random numbers from a cosine d
 	mu = 0.0;
 	s = 3.14;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -751,7 +752,7 @@ tape( 'the function returns a PRNG for generating random numbers from a cosine d
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'cosine', mu, s ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -810,7 +811,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( cosine(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( cosine(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -860,8 +861,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -878,8 +879,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -910,7 +911,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( cosine(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( cosine(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/cosine/test/test.js b/lib/node_modules/@stdlib/random/base/cosine/test/test.js
index 992c71ce5437..05a97b39f0f1 100644
--- a/lib/node_modules/@stdlib/random/base/cosine/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/cosine/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof cosine.factory, 'function', 'has method' );
+	t.strictEqual( typeof cosine.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof cosine.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof cosine.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( cosine.NAME, 'cosine', 'has property' );
+	t.strictEqual( cosine.NAME, 'cosine', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof cosine.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof cosine.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( cosine.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( cosine.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof cosine.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof cosine.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( cosine.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( cosine.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof cosine.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof cosine.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof cosine.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof cosine.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = cosine( 2.0, 1.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( cosine( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( cosine( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.discrete_uniform.js b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.discrete_uniform.js
index d61e4d6592d2..4c93ed51b0a9 100644
--- a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.discrete_uniform.js
+++ b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.discrete_uniform.js
@@ -68,9 +68,9 @@ tape( 'the function returns pseudorandom numbers (smaller range)', function test
 	b = 40;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -90,9 +90,9 @@ tape( 'the function returns pseudorandom numbers (smaller range)', function test
 	b = 40;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -114,9 +114,9 @@ tape( 'the function returns pseudorandom numbers (smaller range)', function test
 	b = 3;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -131,9 +131,9 @@ tape( 'the function returns pseudorandom numbers (smaller range)', function test
 	b = floor( randi.MAX/2 ) + 1; // high likelihood of sampling rejection
 	for ( i = 0; i < 1e3; i++ ) {
 		r = rand( randi, a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -148,9 +148,9 @@ tape( 'the function returns pseudorandom numbers (equal range)', function test(
 	b = randi.MAX + 101;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -168,9 +168,9 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 	b = 10;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -193,9 +193,9 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -218,9 +218,9 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -238,9 +238,9 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 	b = 1e2 + 3;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -259,9 +259,9 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -284,9 +284,9 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.factory.js b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.factory.js
index a5677ab49b45..551ad7c61e15 100644
--- a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.factory.js
@@ -31,6 +31,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -543,16 +544,16 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	discreteUniform = factory( -100, 100 );
 	for ( i = 0; i < 100; i++ ) {
 		r = discreteUniform();
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 	}
 
 	// Without binding distribution parameters...
 	discreteUniform = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = discreteUniform( -100, 100 );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 	}
 	t.end();
 });
@@ -579,7 +580,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = discreteUniform1();
 		r2 = discreteUniform2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -606,25 +607,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = discreteUniform1();
 		r2 = discreteUniform2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var discreteUniform = factory();
-	t.equal( discreteUniform.NAME, 'discrete-uniform', 'has property' );
+	t.strictEqual( discreteUniform.NAME, 'discrete-uniform', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var discreteUniform = factory();
-	t.equal( typeof discreteUniform.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof discreteUniform.PRNG, 'function', 'has property' );
 
 	discreteUniform = factory({
 		'prng': minstd
 	});
-	t.equal( discreteUniform.PRNG, minstd, 'has property' );
+	t.strictEqual( discreteUniform.PRNG, minstd, 'has property' );
 	t.end();
 });
 
@@ -632,14 +633,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var discreteUniform = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( discreteUniform.seed ), true, 'has property' );
-	t.equal( discreteUniform.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( discreteUniform.seed ), true, 'has property' );
+	t.strictEqual( discreteUniform.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	discreteUniform = factory({
 		'seed': 12345,
 		'prng': minstd
 	});
-	t.equal( discreteUniform.seed, null, 'equal to `null`' );
+	t.strictEqual( discreteUniform.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -655,54 +656,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var discreteUniform = factory();
-	t.equal( typeof discreteUniform.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof discreteUniform.seedLength, 'number', 'has property' );
 
 	discreteUniform = factory({
 		'prng': minstd
 	});
-	t.equal( discreteUniform.seedLength, null, 'equal to `null`' );
+	t.strictEqual( discreteUniform.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var discreteUniform = factory();
-	t.equal( isUint32Array( discreteUniform.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( discreteUniform.state ), true, 'has property' );
 
 	discreteUniform = factory({
 		'prng': minstd
 	});
-	t.equal( discreteUniform.state, null, 'equal to `null`' );
+	t.strictEqual( discreteUniform.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var discreteUniform = factory();
-	t.equal( typeof discreteUniform.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof discreteUniform.stateLength, 'number', 'has property' );
 
 	discreteUniform = factory({
 		'prng': minstd
 	});
-	t.equal( discreteUniform.stateLength, null, 'equal to `null`' );
+	t.strictEqual( discreteUniform.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var discreteUniform = factory();
-	t.equal( typeof discreteUniform.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof discreteUniform.byteLength, 'number', 'has property' );
 
 	discreteUniform = factory({
 		'prng': minstd
 	});
-	t.equal( discreteUniform.byteLength, null, 'equal to `null`' );
+	t.strictEqual( discreteUniform.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -711,11 +712,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	discreteUniform = factory();
-	t.equal( typeof discreteUniform.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof discreteUniform.toJSON, 'function', 'has method' );
 
 	o = discreteUniform.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, discreteUniform.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, discreteUniform.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( discreteUniform.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -727,8 +728,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	discreteUniform = factory({
 		'prng': minstd
 	});
-	t.equal( typeof discreteUniform.toJSON, 'function', 'has method' );
-	t.equal( discreteUniform.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof discreteUniform.toJSON, 'function', 'has method' );
+	t.strictEqual( discreteUniform.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -819,7 +820,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	t.end();
 });
 
-tape( 'if provided a maximum support equal to the minimum support, the function returns a function that returns the minimum support', function test( t ) {
+tape( 'if provided a maximum support.strictEqual to the minimum support, the function returns a function that returns the minimum support', function test( t ) {
 	var discreteUniform;
 	var r;
 
@@ -848,7 +849,7 @@ tape( 'if provided a maximum support equal to the minimum support, the function
 	t.end();
 });
 
-tape( 'if provided a maximum support equal to the minimum support, the function returns a function that returns the minimum support', function test( t ) {
+tape( 'if provided a maximum support.strictEqual to the minimum support, the function returns a function that returns the minimum support', function test( t ) {
 	var discreteUniform;
 	var r;
 
@@ -877,7 +878,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = discreteUniform();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -893,7 +894,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = discreteUniform( 1, 10 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -928,7 +929,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = discreteUniform1();
 		r2 = discreteUniform2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -963,7 +964,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = discreteUniform1( 1, 10 );
 		r2 = discreteUniform2( 1, 10 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -984,7 +985,7 @@ tape( 'the function returns a PRNG for generating random numbers from a discrete
 	a = -10;
 	b = 10;
 
-	freq = new Array( b - a + 1 );
+	freq = zeros( b - a + 1 );
 	repeats = 100;
 	N = 1e3;
 
@@ -1020,7 +1021,7 @@ tape( 'the function returns a PRNG for generating random numbers from a discrete
 				'simulate': true,
 				'iterations': 500
 			}).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1079,7 +1080,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( discreteUniform(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( discreteUniform(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1129,8 +1130,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1147,8 +1148,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1179,7 +1180,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( discreteUniform(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( discreteUniform(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.js b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.js
index b38583aaa370..3ca6c03bd1e1 100644
--- a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.js
@@ -35,47 +35,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof discreteUniform.factory, 'function', 'has method' );
+	t.strictEqual( typeof discreteUniform.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof discreteUniform.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof discreteUniform.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( discreteUniform.NAME, 'discrete-uniform', 'has property' );
+	t.strictEqual( discreteUniform.NAME, 'discrete-uniform', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof discreteUniform.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof discreteUniform.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( discreteUniform.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( discreteUniform.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof discreteUniform.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof discreteUniform.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( discreteUniform.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( discreteUniform.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof discreteUniform.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof discreteUniform.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof discreteUniform.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof discreteUniform.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -89,9 +89,9 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	b = 40;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = discreteUniform( a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( isInteger( r ), true, 'returns an integer' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( discreteUniform( -10, 10 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( discreteUniform( -10, 10 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/erlang/test/test.factory.js b/lib/node_modules/@stdlib/random/base/erlang/test/test.factory.js
index 2432a6cbcb59..d4389b2dae5e 100644
--- a/lib/node_modules/@stdlib/random/base/erlang/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/erlang/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -375,14 +376,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	erlang = factory( 2, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = erlang();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	erlang = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = erlang( 2, 2.5 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -410,7 +411,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = erlang1();
 		r2 = erlang2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -437,25 +438,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = erlang1();
 		r2 = erlang2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var erlang = factory();
-	t.equal( erlang.NAME, 'erlang', 'has property' );
+	t.strictEqual( erlang.NAME, 'erlang', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var erlang = factory();
-	t.equal( typeof erlang.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof erlang.PRNG, 'function', 'has property' );
 
 	erlang = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( erlang.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( erlang.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -463,14 +464,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var erlang = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( erlang.seed ), true, 'has property' );
-	t.equal( erlang.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( erlang.seed ), true, 'has property' );
+	t.strictEqual( erlang.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	erlang = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( erlang.seed, null, 'equal to `null`' );
+	t.strictEqual( erlang.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -486,54 +487,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var erlang = factory();
-	t.equal( typeof erlang.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof erlang.seedLength, 'number', 'has property' );
 
 	erlang = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( erlang.seedLength, null, 'equal to `null`' );
+	t.strictEqual( erlang.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var erlang = factory();
-	t.equal( isUint32Array( erlang.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( erlang.state ), true, 'has property' );
 
 	erlang = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( erlang.state, null, 'equal to `null`' );
+	t.strictEqual( erlang.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var erlang = factory();
-	t.equal( typeof erlang.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof erlang.stateLength, 'number', 'has property' );
 
 	erlang = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( erlang.stateLength, null, 'equal to `null`' );
+	t.strictEqual( erlang.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var erlang = factory();
-	t.equal( typeof erlang.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof erlang.byteLength, 'number', 'has property' );
 
 	erlang = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( erlang.byteLength, null, 'equal to `null`' );
+	t.strictEqual( erlang.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -542,11 +543,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	erlang = factory();
-	t.equal( typeof erlang.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof erlang.toJSON, 'function', 'has method' );
 
 	o = erlang.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, erlang.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, erlang.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( erlang.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -558,13 +559,13 @@ tape( 'attached to the returned function is a method to serialize the generator
 	erlang = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof erlang.toJSON, 'function', 'has method' );
-	t.equal( erlang.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof erlang.toJSON, 'function', 'has method' );
+	t.strictEqual( erlang.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument.strictEqual to `NaN`', function test( t ) {
 	var erlang;
 	var r;
 
@@ -575,7 +576,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument.strictEqual to `NaN`', function test( t ) {
 	var erlang;
 	var r;
 
@@ -638,7 +639,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = erlang();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -654,7 +655,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = erlang( 2, 4.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -689,7 +690,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = erlang1();
 		r2 = erlang2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -724,7 +725,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = erlang1( 2, 4.0 );
 		r2 = erlang2( 2, 4.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -743,7 +744,7 @@ tape( 'the function returns a PRNG for generating random numbers from an Erlang
 	k = 2;
 	lambda = 4.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -769,7 +770,7 @@ tape( 'the function returns a PRNG for generating random numbers from an Erlang
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'erlang', k, lambda ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -828,7 +829,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( erlang(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( erlang(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -878,8 +879,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -896,8 +897,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -928,7 +929,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( erlang(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( erlang(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/erlang/test/test.js b/lib/node_modules/@stdlib/random/base/erlang/test/test.js
index c8825a662d59..da5a181cbe78 100644
--- a/lib/node_modules/@stdlib/random/base/erlang/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/erlang/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof erlang.factory, 'function', 'has method' );
+	t.strictEqual( typeof erlang.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof erlang.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof erlang.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( erlang.NAME, 'erlang', 'has property' );
+	t.strictEqual( erlang.NAME, 'erlang', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof erlang.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof erlang.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( erlang.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( erlang.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof erlang.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof erlang.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( erlang.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( erlang.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof erlang.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof erlang.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof erlang.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof erlang.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = erlang( 2, 1.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( erlang( 2, 4.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( erlang( 2, 4.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/exponential/test/test.factory.js b/lib/node_modules/@stdlib/random/base/exponential/test/test.factory.js
index 8e24b71dc43f..14091b14d920 100644
--- a/lib/node_modules/@stdlib/random/base/exponential/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/exponential/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -372,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	exponential = factory( 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = exponential();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameter...
 	exponential = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = exponential( 100.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -407,7 +408,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = exponential1();
 		r2 = exponential2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -434,25 +435,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = exponential1();
 		r2 = exponential2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var exponential = factory();
-	t.equal( exponential.NAME, 'exponential', 'has property' );
+	t.strictEqual( exponential.NAME, 'exponential', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var exponential = factory();
-	t.equal( typeof exponential.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof exponential.PRNG, 'function', 'has property' );
 
 	exponential = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( exponential.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( exponential.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -460,14 +461,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var exponential = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( exponential.seed ), true, 'has `seed` property' );
-	t.equal( exponential.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( exponential.seed ), true, 'has `seed` property' );
+	t.strictEqual( exponential.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	exponential = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( exponential.seed, null, 'equal to `null`' );
+	t.strictEqual( exponential.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -483,54 +484,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var exponential = factory();
-	t.equal( typeof exponential.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof exponential.seedLength, 'number', 'has property' );
 
 	exponential = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( exponential.seedLength, null, 'equal to `null`' );
+	t.strictEqual( exponential.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var exponential = factory();
-	t.equal( isUint32Array( exponential.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( exponential.state ), true, 'has property' );
 
 	exponential = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( exponential.state, null, 'equal to `null`' );
+	t.strictEqual( exponential.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var exponential = factory();
-	t.equal( typeof exponential.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof exponential.stateLength, 'number', 'has property' );
 
 	exponential = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( exponential.stateLength, null, 'equal to `null`' );
+	t.strictEqual( exponential.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var exponential = factory();
-	t.equal( typeof exponential.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof exponential.byteLength, 'number', 'has property' );
 
 	exponential = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( exponential.byteLength, null, 'equal to `null`' );
+	t.strictEqual( exponential.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -539,11 +540,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	exponential = factory();
-	t.equal( typeof exponential.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof exponential.toJSON, 'function', 'has method' );
 
 	o = exponential.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, exponential.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, exponential.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( exponential.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -555,8 +556,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	exponential = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof exponential.toJSON, 'function', 'has method' );
-	t.equal( exponential.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof exponential.toJSON, 'function', 'has method' );
+	t.strictEqual( exponential.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -601,7 +602,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = exponential();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -617,7 +618,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = exponential( 10.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -652,7 +653,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = exponential1();
 		r2 = exponential2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -687,7 +688,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = exponential1( 10.0 );
 		r2 = exponential2( 10.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -704,7 +705,7 @@ tape( 'the function returns a PRNG for generating random numbers from an exponen
 
 	lambda = 4.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -730,7 +731,7 @@ tape( 'the function returns a PRNG for generating random numbers from an exponen
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'exponential', lambda ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -789,7 +790,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( exponential(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( exponential(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -839,8 +840,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -857,8 +858,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -889,7 +890,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( exponential(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( exponential(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/exponential/test/test.js b/lib/node_modules/@stdlib/random/base/exponential/test/test.js
index bd1f67e244b2..60f3502852f5 100644
--- a/lib/node_modules/@stdlib/random/base/exponential/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/exponential/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof exponential.factory, 'function', 'has method' );
+	t.strictEqual( typeof exponential.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof exponential.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof exponential.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof exponential.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof exponential.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( exponential.NAME, 'exponential', 'has property' );
+	t.strictEqual( exponential.NAME, 'exponential', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( exponential.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( exponential.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof exponential.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof exponential.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( exponential.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( exponential.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof exponential.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof exponential.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof exponential.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof exponential.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( exponential( 4.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( exponential( 4.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/f/test/test.factory.js b/lib/node_modules/@stdlib/random/base/f/test/test.factory.js
index fef350fbc1de..3811541ae1dd 100644
--- a/lib/node_modules/@stdlib/random/base/f/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/f/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -374,14 +375,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	f = factory( 2.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = f();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	f = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = f( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -409,7 +410,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = randf1();
 		r2 = randf2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -436,25 +437,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = randf1();
 		r2 = randf2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var f = factory();
-	t.equal( f.NAME, 'f', 'has property' );
+	t.strictEqual( f.NAME, 'f', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var f = factory();
-	t.equal( typeof f.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof f.PRNG, 'function', 'has property' );
 
 	f = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( f.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( f.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -462,14 +463,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var f = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( f.seed ), true, 'has property' );
-	t.equal( f.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( f.seed ), true, 'has property' );
+	t.strictEqual( f.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	f = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( f.seed, null, 'equal to `null`' );
+	t.strictEqual( f.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -485,54 +486,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var f = factory();
-	t.equal( typeof f.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof f.seedLength, 'number', 'has property' );
 
 	f = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( f.seedLength, null, 'equal to `null`' );
+	t.strictEqual( f.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var f = factory();
-	t.equal( isUint32Array( f.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( f.state ), true, 'has property' );
 
 	f = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( f.state, null, 'equal to `null`' );
+	t.strictEqual( f.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var f = factory();
-	t.equal( typeof f.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof f.stateLength, 'number', 'has property' );
 
 	f = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( f.stateLength, null, 'equal to `null`' );
+	t.strictEqual( f.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var f = factory();
-	t.equal( typeof f.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof f.byteLength, 'number', 'has property' );
 
 	f = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( f.byteLength, null, 'equal to `null`' );
+	t.strictEqual( f.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -541,11 +542,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	f = factory();
-	t.equal( typeof f.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof f.toJSON, 'function', 'has method' );
 
 	o = f.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, f.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, f.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( f.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -557,8 +558,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	f = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof f.toJSON, 'function', 'has method' );
-	t.equal( f.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof f.toJSON, 'function', 'has method' );
+	t.strictEqual( f.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -637,7 +638,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = f();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -653,7 +654,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = f( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -688,7 +689,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = f1();
 		r2 = f2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -723,7 +724,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = f1( 1.0, 2.0 );
 		r2 = f2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -742,7 +743,7 @@ tape( 'the function returns a PRNG for generating random numbers from an F distr
 	d1 = 2.0;
 	d2 = 4.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -768,7 +769,7 @@ tape( 'the function returns a PRNG for generating random numbers from an F distr
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'f', d1, d2 ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -827,7 +828,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( f(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( f(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -877,8 +878,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -895,8 +896,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -927,7 +928,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( f(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( f(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/f/test/test.js b/lib/node_modules/@stdlib/random/base/f/test/test.js
index e085dde4696f..81e182f9282e 100644
--- a/lib/node_modules/@stdlib/random/base/f/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/f/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof f.factory, 'function', 'has method' );
+	t.strictEqual( typeof f.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof f.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof f.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( f.NAME, 'f', 'has property' );
+	t.strictEqual( f.NAME, 'f', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof f.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof f.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( f.seed ), true, 'has `seed` property' );
+	t.strictEqual( isUint32Array( f.seed ), true, 'has `seed` property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof f.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof f.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( f.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( f.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof f.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof f.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof f.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof f.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( f( 2.0, 4.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( f( 2.0, 4.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/frechet/test/test.factory.js b/lib/node_modules/@stdlib/random/base/frechet/test/test.factory.js
index 2abe66aa16a9..c290f95c59cb 100644
--- a/lib/node_modules/@stdlib/random/base/frechet/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/frechet/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -402,14 +403,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	frechet = factory( 10.0, 10.0, 5.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = frechet();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	frechet = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = frechet( 10.0, 10.0, 5.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -437,7 +438,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = frechet1();
 		r2 = frechet2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -464,25 +465,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = frechet1();
 		r2 = frechet2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var frechet = factory();
-	t.equal( frechet.NAME, 'frechet', 'has property' );
+	t.strictEqual( frechet.NAME, 'frechet', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var frechet = factory();
-	t.equal( typeof frechet.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof frechet.PRNG, 'function', 'has property' );
 
 	frechet = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( frechet.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( frechet.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -490,14 +491,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var frechet = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( frechet.seed ), true, 'has property' );
-	t.equal( frechet.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( frechet.seed ), true, 'has property' );
+	t.strictEqual( frechet.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	frechet = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( frechet.seed, null, 'equal to `null`' );
+	t.strictEqual( frechet.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -513,54 +514,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var frechet = factory();
-	t.equal( typeof frechet.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof frechet.seedLength, 'number', 'has property' );
 
 	frechet = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( frechet.seedLength, null, 'equal to `null`' );
+	t.strictEqual( frechet.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var frechet = factory();
-	t.equal( isUint32Array( frechet.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( frechet.state ), true, 'has property' );
 
 	frechet = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( frechet.state, null, 'equal to `null`' );
+	t.strictEqual( frechet.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var frechet = factory();
-	t.equal( typeof frechet.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof frechet.stateLength, 'number', 'has property' );
 
 	frechet = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( frechet.stateLength, null, 'equal to `null`' );
+	t.strictEqual( frechet.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var frechet = factory();
-	t.equal( typeof frechet.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof frechet.byteLength, 'number', 'has property' );
 
 	frechet = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( frechet.byteLength, null, 'equal to `null`' );
+	t.strictEqual( frechet.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -569,11 +570,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	frechet = factory();
-	t.equal( typeof frechet.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof frechet.toJSON, 'function', 'has method' );
 
 	o = frechet.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, frechet.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, frechet.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( frechet.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -585,8 +586,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	frechet = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof frechet.toJSON, 'function', 'has method' );
-	t.equal( frechet.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof frechet.toJSON, 'function', 'has method' );
+	t.strictEqual( frechet.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -646,7 +647,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = frechet();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -662,7 +663,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = frechet( 2.0, 4.0, -1.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -697,7 +698,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = frechet1();
 		r2 = frechet2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -732,7 +733,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = frechet1( 2.0, 4.0, -1.0 );
 		r2 = frechet2( 2.0, 4.0, -1.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -753,7 +754,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Fréchet
 	s = 4.0;
 	m = -1.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 500;
 
 	count = -1;
@@ -782,7 +783,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Fréchet
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'frechet', alpha, s, m ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -841,7 +842,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( frechet(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( frechet(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -891,8 +892,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -909,8 +910,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -941,7 +942,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( frechet(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( frechet(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/frechet/test/test.js b/lib/node_modules/@stdlib/random/base/frechet/test/test.js
index 88f85dc071dd..6891c598df4c 100644
--- a/lib/node_modules/@stdlib/random/base/frechet/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/frechet/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof frechet.factory, 'function', 'has method' );
+	t.strictEqual( typeof frechet.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof frechet.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof frechet.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( frechet.NAME, 'frechet', 'has property' );
+	t.strictEqual( frechet.NAME, 'frechet', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof frechet.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof frechet.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( frechet.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( frechet.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof frechet.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof frechet.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( frechet.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( frechet.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof frechet.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof frechet.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof frechet.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof frechet.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -90,8 +90,8 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	m = 10.0;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = frechet( alpha, s, m );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( r >= m, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( r >= m, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( frechet( 8.0, 3.0, 10.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( frechet( 8.0, 3.0, 10.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/gamma/test/test.factory.js b/lib/node_modules/@stdlib/random/base/gamma/test/test.factory.js
index 8960bf1e0652..01af04b0e6a0 100644
--- a/lib/node_modules/@stdlib/random/base/gamma/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/gamma/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -515,14 +516,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	gamma = factory( 2.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = gamma();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	gamma = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = gamma( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -550,7 +551,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = gamma1();
 		r2 = gamma2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -577,25 +578,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = gamma1();
 		r2 = gamma2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var gamma = factory();
-	t.equal( gamma.NAME, 'gamma', 'has property' );
+	t.strictEqual( gamma.NAME, 'gamma', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var gamma = factory();
-	t.equal( typeof gamma.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof gamma.PRNG, 'function', 'has property' );
 
 	gamma = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( gamma.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( gamma.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -603,14 +604,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var gamma = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( gamma.seed ), true, 'has property' );
-	t.equal( gamma.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( gamma.seed ), true, 'has property' );
+	t.strictEqual( gamma.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	gamma = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( gamma.seed, null, 'equal to `null`' );
+	t.strictEqual( gamma.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -626,54 +627,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var gamma = factory();
-	t.equal( typeof gamma.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof gamma.seedLength, 'number', 'has property' );
 
 	gamma = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( gamma.seedLength, null, 'equal to `null`' );
+	t.strictEqual( gamma.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the return function is the generator state', function test( t ) {
 	var gamma = factory();
-	t.equal( isUint32Array( gamma.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( gamma.state ), true, 'has property' );
 
 	gamma = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( gamma.state, null, 'equal to `null`' );
+	t.strictEqual( gamma.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var gamma = factory();
-	t.equal( typeof gamma.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof gamma.stateLength, 'number', 'has property' );
 
 	gamma = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( gamma.stateLength, null, 'equal to `null`' );
+	t.strictEqual( gamma.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var gamma = factory();
-	t.equal( typeof gamma.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof gamma.byteLength, 'number', 'has property' );
 
 	gamma = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( gamma.byteLength, null, 'equal to `null`' );
+	t.strictEqual( gamma.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -682,11 +683,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	gamma = factory();
-	t.equal( typeof gamma.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof gamma.toJSON, 'function', 'has method' );
 
 	o = gamma.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, gamma.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, gamma.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( gamma.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -698,8 +699,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	gamma = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof gamma.toJSON, 'function', 'has method' );
-	t.equal( gamma.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof gamma.toJSON, 'function', 'has method' );
+	t.strictEqual( gamma.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -833,7 +834,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = gamma();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -849,7 +850,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = gamma( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -884,7 +885,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = gamma1();
 		r2 = gamma2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -919,7 +920,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = gamma1( 1.0, 2.0 );
 		r2 = gamma2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -938,7 +939,7 @@ tape( 'the function returns a PRNG for generating random numbers from a gamma di
 	alpha = 2.0;
 	beta = 4.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -964,7 +965,7 @@ tape( 'the function returns a PRNG for generating random numbers from a gamma di
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'gamma', alpha, beta ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1009,7 +1010,7 @@ tape( 'the function returns a PRNG for generating random numbers from a gamma di
 	alpha = 0.2;
 	beta = 4.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -1035,7 +1036,7 @@ tape( 'the function returns a PRNG for generating random numbers from a gamma di
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'gamma', alpha, beta ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1094,7 +1095,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( gamma(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( gamma(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1144,8 +1145,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1( 2.0, 4.0 );
 		v2 = rand2( 2.0, 4.0 );
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1162,8 +1163,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1( 2.0, 4.0 );
 		v2 = rand2( 2.0, 4.0 );
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1214,8 +1215,8 @@ tape( 'the function supports specifying a shared generator state (other argument
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1232,8 +1233,8 @@ tape( 'the function supports specifying a shared generator state (other argument
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1264,7 +1265,7 @@ tape( 'the returned function supports setting the generator state (alpha < 1.0)'
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( gamma(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( gamma(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1294,7 +1295,7 @@ tape( 'the returned function supports setting the generator state (alpha >= 1.0)
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( gamma(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( gamma(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/gamma/test/test.js b/lib/node_modules/@stdlib/random/base/gamma/test/test.js
index db29ac5b474f..1e9d7ab191f3 100644
--- a/lib/node_modules/@stdlib/random/base/gamma/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/gamma/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof gamma.factory, 'function', 'has method' );
+	t.strictEqual( typeof gamma.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof gamma.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof gamma.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( gamma.NAME, 'gamma', 'has property' );
+	t.strictEqual( gamma.NAME, 'gamma', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof gamma.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof gamma.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( gamma.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( gamma.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof gamma.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof gamma.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( gamma.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( gamma.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof gamma.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof gamma.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof gamma.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof gamma.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -122,7 +122,7 @@ tape( 'the function supports setting the generator state (alpha >= 1.0)', functi
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( gamma( 2.0, 2.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( gamma( 2.0, 2.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function supports setting the generator state (alpha < 1.0)', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( gamma( 0.05, 2.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( gamma( 0.05, 2.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/geometric/test/test.factory.js b/lib/node_modules/@stdlib/random/base/geometric/test/test.factory.js
index 5a31ae0098eb..b667f3a23572 100644
--- a/lib/node_modules/@stdlib/random/base/geometric/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/geometric/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -374,14 +375,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	geometric = factory( 0.05 );
 	for ( i = 0; i < 100; i++ ) {
 		r = geometric();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	geometric = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = geometric( 0.1 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -409,7 +410,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = geometric1();
 		r2 = geometric2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -436,25 +437,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = geometric1();
 		r2 = geometric2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var geometric = factory();
-	t.equal( geometric.NAME, 'geometric', 'has property' );
+	t.strictEqual( geometric.NAME, 'geometric', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var geometric = factory();
-	t.equal( typeof geometric.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof geometric.PRNG, 'function', 'has property' );
 
 	geometric = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( geometric.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( geometric.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -462,14 +463,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var geometric = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( geometric.seed ), true, 'has property' );
-	t.equal( geometric.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( geometric.seed ), true, 'has property' );
+	t.strictEqual( geometric.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	geometric = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( geometric.seed, null, 'equal to `null`' );
+	t.strictEqual( geometric.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -485,54 +486,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var geometric = factory();
-	t.equal( typeof geometric.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof geometric.seedLength, 'number', 'has property' );
 
 	geometric = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( geometric.seedLength, null, 'equal to `null`' );
+	t.strictEqual( geometric.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var geometric = factory();
-	t.equal( isUint32Array( geometric.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( geometric.state ), true, 'has property' );
 
 	geometric = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( geometric.state, null, 'equal to `null`' );
+	t.strictEqual( geometric.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var geometric = factory();
-	t.equal( typeof geometric.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof geometric.stateLength, 'number', 'has property' );
 
 	geometric = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( geometric.stateLength, null, 'equal to `null`' );
+	t.strictEqual( geometric.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var geometric = factory();
-	t.equal( typeof geometric.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof geometric.byteLength, 'number', 'has property' );
 
 	geometric = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( geometric.byteLength, null, 'equal to `null`' );
+	t.strictEqual( geometric.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -541,11 +542,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	geometric = factory();
-	t.equal( typeof geometric.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof geometric.toJSON, 'function', 'has method' );
 
 	o = geometric.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, geometric.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, geometric.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( geometric.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -557,8 +558,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	geometric = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof geometric.toJSON, 'function', 'has method' );
-	t.equal( geometric.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof geometric.toJSON, 'function', 'has method' );
+	t.strictEqual( geometric.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -603,7 +604,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = geometric();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -619,7 +620,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = geometric( 0.3 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -654,7 +655,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = geometric1();
 		r2 = geometric2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -689,7 +690,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = geometric1( 0.3 );
 		r2 = geometric2( 0.3 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -708,7 +709,7 @@ tape( 'the function returns a PRNG for generating random numbers from a geometri
 
 	p = 0.67;
 
-	freq = new Array( 30 );
+	freq = zeros( 30 );
 	repeats = 200;
 	N = 1e3;
 
@@ -744,7 +745,7 @@ tape( 'the function returns a PRNG for generating random numbers from a geometri
 				'simulate': true,
 				'iterations': 500
 			}).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -803,7 +804,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( geometric(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( geometric(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -853,8 +854,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -871,8 +872,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -903,7 +904,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( geometric(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( geometric(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/geometric/test/test.js b/lib/node_modules/@stdlib/random/base/geometric/test/test.js
index 648d6fa83456..26b9c4386c66 100644
--- a/lib/node_modules/@stdlib/random/base/geometric/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/geometric/test/test.js
@@ -35,47 +35,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof geometric.factory, 'function', 'has method' );
+	t.strictEqual( typeof geometric.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof geometric.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof geometric.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( geometric.NAME, 'geometric', 'has property' );
+	t.strictEqual( geometric.NAME, 'geometric', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof geometric.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof geometric.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( geometric.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( geometric.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof geometric.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof geometric.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( geometric.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( geometric.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof geometric.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof geometric.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof geometric.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof geometric.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( geometric( 0.9 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( geometric( 0.9 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/gumbel/test/test.factory.js b/lib/node_modules/@stdlib/random/base/gumbel/test/test.factory.js
index 39170ab450ed..0d1d061cad94 100644
--- a/lib/node_modules/@stdlib/random/base/gumbel/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/gumbel/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -372,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	gumbel = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = gumbel();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	gumbel = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = gumbel( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -407,7 +408,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = gumbel1();
 		r2 = gumbel2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -434,25 +435,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = gumbel1();
 		r2 = gumbel2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var gumbel = factory();
-	t.equal( gumbel.NAME, 'gumbel', 'has property' );
+	t.strictEqual( gumbel.NAME, 'gumbel', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var gumbel = factory();
-	t.equal( typeof gumbel.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof gumbel.PRNG, 'function', 'has property' );
 
 	gumbel = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( gumbel.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( gumbel.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -460,14 +461,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var gumbel = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( gumbel.seed ), true, 'has property' );
-	t.equal( gumbel.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( gumbel.seed ), true, 'has property' );
+	t.strictEqual( gumbel.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	gumbel = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( gumbel.seed, null, 'equal to `null`' );
+	t.strictEqual( gumbel.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -483,54 +484,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var gumbel = factory();
-	t.equal( typeof gumbel.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof gumbel.seedLength, 'number', 'has property' );
 
 	gumbel = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( gumbel.seedLength, null, 'equal to `null`' );
+	t.strictEqual( gumbel.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var gumbel = factory();
-	t.equal( isUint32Array( gumbel.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( gumbel.state ), true, 'has property' );
 
 	gumbel = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( gumbel.state, null, 'equal to `null`' );
+	t.strictEqual( gumbel.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var gumbel = factory();
-	t.equal( typeof gumbel.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof gumbel.stateLength, 'number', 'has property' );
 
 	gumbel = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( gumbel.stateLength, null, 'equal to `null`' );
+	t.strictEqual( gumbel.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var gumbel = factory();
-	t.equal( typeof gumbel.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof gumbel.byteLength, 'number', 'has property' );
 
 	gumbel = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( gumbel.byteLength, null, 'equal to `null`' );
+	t.strictEqual( gumbel.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -539,11 +540,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	gumbel = factory();
-	t.equal( typeof gumbel.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof gumbel.toJSON, 'function', 'has method' );
 
 	o = gumbel.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, gumbel.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, gumbel.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( gumbel.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -555,13 +556,13 @@ tape( 'attached to the returned function is a method to serialize the generator
 	gumbel = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof gumbel.toJSON, 'function', 'has method' );
-	t.equal( gumbel.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof gumbel.toJSON, 'function', 'has method' );
+	t.strictEqual( gumbel.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument.strictEqual to `NaN`', function test( t ) {
 	var gumbel;
 	var r;
 
@@ -572,7 +573,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument.strictEqual to `NaN`', function test( t ) {
 	var gumbel;
 	var r;
 
@@ -620,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = gumbel();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -636,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = gumbel( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -671,7 +672,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = gumbel1();
 		r2 = gumbel2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -706,7 +707,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = gumbel1( 1.0, 2.0 );
 		r2 = gumbel2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -725,7 +726,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Gumbel d
 	mu = 0.0;
 	beta = 3.14;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -751,7 +752,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Gumbel d
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'gumbel', mu, beta ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -810,7 +811,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( gumbel(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( gumbel(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -860,8 +861,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -878,8 +879,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -910,7 +911,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( gumbel(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( gumbel(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/gumbel/test/test.js b/lib/node_modules/@stdlib/random/base/gumbel/test/test.js
index 3cb4d1421413..2df1e272b747 100644
--- a/lib/node_modules/@stdlib/random/base/gumbel/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/gumbel/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof gumbel.factory, 'function', 'has method' );
+	t.strictEqual( typeof gumbel.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof gumbel.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof gumbel.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( gumbel.NAME, 'gumbel', 'has property' );
+	t.strictEqual( gumbel.NAME, 'gumbel', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof gumbel.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof gumbel.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( gumbel.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( gumbel.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof gumbel.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof gumbel.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( gumbel.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( gumbel.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof gumbel.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof gumbel.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof gumbel.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof gumbel.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = gumbel( 2.0, 1.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( gumbel( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( gumbel( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/hypergeometric/test/test.factory.js b/lib/node_modules/@stdlib/random/base/hypergeometric/test/test.factory.js
index 44cf9f4ffac1..5c2e908cb247 100644
--- a/lib/node_modules/@stdlib/random/base/hypergeometric/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/hypergeometric/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -450,14 +451,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	hypergeometric = factory( 80, 50, 30 );
 	for ( i = 0; i < 100; i++ ) {
 		r = hypergeometric();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	hypergeometric = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = hypergeometric( 80, 50, 30 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -485,7 +486,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = hypergeometric1();
 		r2 = hypergeometric2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -512,25 +513,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = hypergeometric1();
 		r2 = hypergeometric2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var hypergeometric = factory();
-	t.equal( hypergeometric.NAME, 'hypergeometric', 'has property' );
+	t.strictEqual( hypergeometric.NAME, 'hypergeometric', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var hypergeometric = factory();
-	t.equal( typeof hypergeometric.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof hypergeometric.PRNG, 'function', 'has property' );
 
 	hypergeometric = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( hypergeometric.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( hypergeometric.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -538,14 +539,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var hypergeometric = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( hypergeometric.seed ), true, 'has `seed` property' );
-	t.equal( hypergeometric.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( hypergeometric.seed ), true, 'has `seed` property' );
+	t.strictEqual( hypergeometric.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	hypergeometric = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( hypergeometric.seed, null, 'equal to `null`' );
+	t.strictEqual( hypergeometric.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -561,54 +562,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var hypergeometric = factory();
-	t.equal( typeof hypergeometric.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof hypergeometric.seedLength, 'number', 'has property' );
 
 	hypergeometric = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( hypergeometric.seedLength, null, 'equal to `null`' );
+	t.strictEqual( hypergeometric.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var hypergeometric = factory();
-	t.equal( isUint32Array( hypergeometric.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( hypergeometric.state ), true, 'has property' );
 
 	hypergeometric = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( hypergeometric.state, null, 'equal to `null`' );
+	t.strictEqual( hypergeometric.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var hypergeometric = factory();
-	t.equal( typeof hypergeometric.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof hypergeometric.stateLength, 'number', 'has property' );
 
 	hypergeometric = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( hypergeometric.stateLength, null, 'equal to `null`' );
+	t.strictEqual( hypergeometric.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var hypergeometric = factory();
-	t.equal( typeof hypergeometric.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof hypergeometric.byteLength, 'number', 'has property' );
 
 	hypergeometric = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( hypergeometric.byteLength, null, 'equal to `null`' );
+	t.strictEqual( hypergeometric.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -617,11 +618,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	hypergeometric = factory();
-	t.equal( typeof hypergeometric.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof hypergeometric.toJSON, 'function', 'has method' );
 
 	o = hypergeometric.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, hypergeometric.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, hypergeometric.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( hypergeometric.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -633,8 +634,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	hypergeometric = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof hypergeometric.toJSON, 'function', 'has method' );
-	t.equal( hypergeometric.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof hypergeometric.toJSON, 'function', 'has method' );
+	t.strictEqual( hypergeometric.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -738,7 +739,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = hypergeometric();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -754,7 +755,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = hypergeometric( 100, 25, 7 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -789,7 +790,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = hypergeometric1();
 		r2 = hypergeometric2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -824,7 +825,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = hypergeometric1( 100, 25, 7 );
 		r2 = hypergeometric2( 100, 25, 7 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -847,7 +848,7 @@ tape( 'the function returns a PRNG for generating random numbers from a hypergeo
 	K = 25;
 	n = 7;
 
-	freq = new Array( 20 );
+	freq = zeros( 20 );
 	repeats = 200;
 	T = 1e3;
 
@@ -883,7 +884,7 @@ tape( 'the function returns a PRNG for generating random numbers from a hypergeo
 				'simulate': false,
 				'iterations': 500
 			}).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -932,7 +933,7 @@ tape( 'the function returns a PRNG for generating random numbers from a hypergeo
 	K = 70;
 	n = 7;
 
-	freq = new Array( 20 );
+	freq = zeros( 20 );
 	repeats = 200;
 	T = 1e3;
 
@@ -968,7 +969,7 @@ tape( 'the function returns a PRNG for generating random numbers from a hypergeo
 				'simulate': false,
 				'iterations': 500
 			}).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1017,7 +1018,7 @@ tape( 'the function returns a PRNG for generating random numbers from a hypergeo
 	K = 8;
 	n = 12;
 
-	freq = new Array( 12 );
+	freq = zeros( 12 );
 	repeats = 200;
 	T = 1e3;
 
@@ -1053,7 +1054,7 @@ tape( 'the function returns a PRNG for generating random numbers from a hypergeo
 				'simulate': false,
 				'iterations': 500
 			}).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1102,7 +1103,7 @@ tape( 'the function returns a PRNG for generating random numbers from a hypergeo
 	K = 40;
 	n = 60;
 
-	freq = new Array( 50 );
+	freq = zeros( 50 );
 	repeats = 200;
 	T = 1e3;
 
@@ -1138,7 +1139,7 @@ tape( 'the function returns a PRNG for generating random numbers from a hypergeo
 				'simulate': false,
 				'iterations': 500
 			}).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1197,7 +1198,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( hypergeometric(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( hypergeometric(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1247,8 +1248,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1265,8 +1266,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1297,7 +1298,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( hypergeometric(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( hypergeometric(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/hypergeometric/test/test.js b/lib/node_modules/@stdlib/random/base/hypergeometric/test/test.js
index 161a492f1d29..f366532a5198 100644
--- a/lib/node_modules/@stdlib/random/base/hypergeometric/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/hypergeometric/test/test.js
@@ -37,47 +37,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof hypergeometric.factory, 'function', 'has method' );
+	t.strictEqual( typeof hypergeometric.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof hypergeometric.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof hypergeometric.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( hypergeometric.NAME, 'hypergeometric', 'has property' );
+	t.strictEqual( hypergeometric.NAME, 'hypergeometric', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof hypergeometric.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof hypergeometric.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( hypergeometric.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( hypergeometric.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof hypergeometric.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof hypergeometric.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( hypergeometric.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( hypergeometric.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof hypergeometric.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof hypergeometric.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof hypergeometric.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof hypergeometric.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -124,7 +124,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( hypergeometric( 10, 8, 5 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( hypergeometric( 10, 8, 5 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.factory.js b/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.factory.js
index 37fff649b67f..b923f2c7394f 100644
--- a/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.factory.js
@@ -29,6 +29,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var isUint32Array = require( '@stdlib/assert/is-uint32array' );
 var typedarray2json = require( '@stdlib/array/to-json' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -254,7 +255,7 @@ tape( 'the function returns a pseudorandom number generator', function test( t )
 	randn = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -267,7 +268,7 @@ tape( 'the function returns a pseudorandom number generator (options; no seed)',
 	randn = factory( {} );
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -294,7 +295,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 1e3; i++ ) {
 		r1 = randn1();
 		r2 = randn2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -321,20 +322,20 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 1e3; i++ ) {
 		r1 = randn1();
 		r2 = randn2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var randn = factory();
-	t.equal( randn.NAME, 'improved-ziggurat', 'has property' );
+	t.strictEqual( randn.NAME, 'improved-ziggurat', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var randn = factory();
-	t.equal( typeof randn.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof randn.PRNG, 'function', 'has property' );
 	t.end();
 });
 
@@ -347,13 +348,13 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	});
 	actual = randn.seed;
 
-	t.equal( isUint32Array( actual ), true, 'has property' );
-	t.equal( actual[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( actual[ 0 ], 12345, 'equal to provided seed' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( randn.seed, null, 'equal to `null`' );
+	t.strictEqual( randn.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -370,54 +371,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = randn.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var randn = factory();
-	t.equal( typeof randn.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.seedLength, 'number', 'has property' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( randn.seedLength, null, 'equal to `null`' );
+	t.strictEqual( randn.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var randn = factory();
-	t.equal( isUint32Array( randn.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( randn.state ), true, 'has property' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( randn.state, null, 'equal to `null`' );
+	t.strictEqual( randn.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var randn = factory();
-	t.equal( typeof randn.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.stateLength, 'number', 'has property' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( randn.stateLength, null, 'equal to `null`' );
+	t.strictEqual( randn.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var randn = factory();
-	t.equal( typeof randn.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.byteLength, 'number', 'has property' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( randn.byteLength, null, 'equal to `null`' );
+	t.strictEqual( randn.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -426,18 +427,18 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	randn = factory();
-	t.equal( typeof randn.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof randn.toJSON, 'function', 'has method' );
 
 	o = randn.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, randn.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, randn.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( randn.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
 	randn = factory({
 		'prng': Math.random // eslint-disable-line stdlib/no-builtin-math
 	});
-	t.equal( randn.toJSON(), null, 'equal to `null`' );
+	t.strictEqual( randn.toJSON(), null, 'equal to `null`' );
 
 	t.end();
 });
@@ -508,7 +509,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -543,7 +544,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e3; i++ ) {
 		r1 = randn1();
 		r2 = randn2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -557,7 +558,7 @@ tape( 'the function returns pseudorandom numbers from a standard normal distribu
 
 	threshold = 0.10;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -583,7 +584,7 @@ tape( 'the function returns pseudorandom numbers from a standard normal distribu
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'normal', 0.0, 1.0 ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -642,7 +643,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -692,8 +693,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -710,8 +711,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -742,7 +743,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.js b/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.js
index 4de274c7f79e..af5020bfd34c 100644
--- a/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof randn.factory, 'function', 'has method' );
+	t.strictEqual( typeof randn.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof randn.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof randn.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( randn.NAME, 'improved-ziggurat', 'has property' );
+	t.strictEqual( randn.NAME, 'improved-ziggurat', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof randn.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof randn.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( randn.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( randn.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof randn.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( randn.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( randn.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof randn.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof randn.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/invgamma/test/test.factory.js b/lib/node_modules/@stdlib/random/base/invgamma/test/test.factory.js
index 258b00a799ec..9a828d8674a0 100644
--- a/lib/node_modules/@stdlib/random/base/invgamma/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/invgamma/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -374,14 +375,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	invgamma = factory( 2.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = invgamma();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	invgamma = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = invgamma( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -409,7 +410,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = invgamma1();
 		r2 = invgamma2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -436,25 +437,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = invgamma1();
 		r2 = invgamma2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var invgamma = factory();
-	t.equal( invgamma.NAME, 'invgamma', 'has property' );
+	t.strictEqual( invgamma.NAME, 'invgamma', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var invgamma = factory();
-	t.equal( typeof invgamma.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof invgamma.PRNG, 'function', 'has property' );
 
 	invgamma = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( invgamma.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( invgamma.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -462,14 +463,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var invgamma = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( invgamma.seed ), true, 'has property' );
-	t.equal( invgamma.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( invgamma.seed ), true, 'has property' );
+	t.strictEqual( invgamma.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	invgamma = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( invgamma.seed, null, 'equal to `null`' );
+	t.strictEqual( invgamma.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -485,54 +486,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var invgamma = factory();
-	t.equal( typeof invgamma.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof invgamma.seedLength, 'number', 'has property' );
 
 	invgamma = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( invgamma.seedLength, null, 'equal to `null`' );
+	t.strictEqual( invgamma.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var invgamma = factory();
-	t.equal( isUint32Array( invgamma.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( invgamma.state ), true, 'has property' );
 
 	invgamma = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( invgamma.state, null, 'equal to `null`' );
+	t.strictEqual( invgamma.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var invgamma = factory();
-	t.equal( typeof invgamma.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof invgamma.stateLength, 'number', 'has property' );
 
 	invgamma = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( invgamma.stateLength, null, 'equal to `null`' );
+	t.strictEqual( invgamma.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var invgamma = factory();
-	t.equal( typeof invgamma.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof invgamma.byteLength, 'number', 'has property' );
 
 	invgamma = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( invgamma.byteLength, null, 'equal to `null`' );
+	t.strictEqual( invgamma.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -541,11 +542,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	invgamma = factory();
-	t.equal( typeof invgamma.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof invgamma.toJSON, 'function', 'has method' );
 
 	o = invgamma.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, invgamma.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, invgamma.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( invgamma.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -557,8 +558,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	invgamma = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof invgamma.toJSON, 'function', 'has method' );
-	t.equal( invgamma.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof invgamma.toJSON, 'function', 'has method' );
+	t.strictEqual( invgamma.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -637,7 +638,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = invgamma();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -653,7 +654,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = invgamma( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -688,7 +689,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = invgamma1();
 		r2 = invgamma2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -723,7 +724,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = invgamma1( 1.0, 2.0 );
 		r2 = invgamma2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -742,7 +743,7 @@ tape( 'the function returns a PRNG for generating random numbers from an inverse
 	alpha = 3.14;
 	beta = 2.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -768,7 +769,7 @@ tape( 'the function returns a PRNG for generating random numbers from an inverse
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'invgamma', alpha, beta ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -827,7 +828,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( invgamma(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( invgamma(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -877,8 +878,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -895,8 +896,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -927,7 +928,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( invgamma(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( invgamma(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/invgamma/test/test.js b/lib/node_modules/@stdlib/random/base/invgamma/test/test.js
index 218f5bf696d3..f3cdb3660b1f 100644
--- a/lib/node_modules/@stdlib/random/base/invgamma/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/invgamma/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof invgamma.factory, 'function', 'has method' );
+	t.strictEqual( typeof invgamma.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof invgamma.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof invgamma.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( invgamma.NAME, 'invgamma', 'has property' );
+	t.strictEqual( invgamma.NAME, 'invgamma', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof invgamma.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof invgamma.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( invgamma.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( invgamma.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof invgamma.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof invgamma.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( invgamma.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( invgamma.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof invgamma.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof invgamma.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof invgamma.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof invgamma.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( invgamma( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( invgamma( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.factory.js b/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.factory.js
index b95edef130be..007446140c1c 100644
--- a/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -374,19 +375,19 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	kumaraswamy = factory( 2.0, 2.0 );
 	for ( i = 0; i < 400; i++ ) {
 		r = kumaraswamy();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	kumaraswamy = factory( 30.0, 30.0 );
 	for ( i = 0; i < 400; i++ ) {
 		r = kumaraswamy();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	kumaraswamy = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = kumaraswamy( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -414,7 +415,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 1e3; i++ ) {
 		r1 = kumaraswamy1();
 		r2 = kumaraswamy2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	t.end();
 });
@@ -441,7 +442,7 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 1e3; i++ ) {
 		r1 = kumaraswamy1();
 		r2 = kumaraswamy2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	t.end();
 });
@@ -468,25 +469,25 @@ tape( 'the function returns a seeded pseudorandom number generator', function te
 	for ( i = 0; i < 1e3; i++ ) {
 		r1 = kumaraswamy1();
 		r2 = kumaraswamy2();
-		t.equal( r1, r2, 'both return same number: '+r1 );
+		t.strictEqual( r1, r2, 'both return same number: '+r1 );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var kumaraswamy = factory();
-	t.equal( kumaraswamy.NAME, 'kumaraswamy', 'has property' );
+	t.strictEqual( kumaraswamy.NAME, 'kumaraswamy', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var kumaraswamy = factory();
-	t.equal( typeof kumaraswamy.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof kumaraswamy.PRNG, 'function', 'has property' );
 
 	kumaraswamy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( kumaraswamy.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( kumaraswamy.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -494,14 +495,14 @@ tape( 'attached to the returned function is the generator seed', function test(
 	var kumaraswamy = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( kumaraswamy.seed ), true, 'has property' );
-	t.equal( kumaraswamy.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( kumaraswamy.seed ), true, 'has property' );
+	t.strictEqual( kumaraswamy.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	kumaraswamy = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( kumaraswamy.seed, null, 'equal to `null`' );
+	t.strictEqual( kumaraswamy.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -517,54 +518,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var kumaraswamy = factory();
-	t.equal( typeof kumaraswamy.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof kumaraswamy.seedLength, 'number', 'has property' );
 
 	kumaraswamy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( kumaraswamy.seedLength, null, 'equal to `null`' );
+	t.strictEqual( kumaraswamy.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var kumaraswamy = factory();
-	t.equal( isUint32Array( kumaraswamy.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( kumaraswamy.state ), true, 'has property' );
 
 	kumaraswamy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( kumaraswamy.state, null, 'equal to `null`' );
+	t.strictEqual( kumaraswamy.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var kumaraswamy = factory();
-	t.equal( typeof kumaraswamy.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof kumaraswamy.stateLength, 'number', 'has property' );
 
 	kumaraswamy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( kumaraswamy.stateLength, null, 'equal to `null`' );
+	t.strictEqual( kumaraswamy.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var kumaraswamy = factory();
-	t.equal( typeof kumaraswamy.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof kumaraswamy.byteLength, 'number', 'has property' );
 
 	kumaraswamy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( kumaraswamy.byteLength, null, 'equal to `null`' );
+	t.strictEqual( kumaraswamy.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -573,11 +574,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	kumaraswamy = factory();
-	t.equal( typeof kumaraswamy.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof kumaraswamy.toJSON, 'function', 'has method' );
 
 	o = kumaraswamy.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, kumaraswamy.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, kumaraswamy.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( kumaraswamy.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -589,8 +590,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	kumaraswamy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof kumaraswamy.toJSON, 'function', 'has method' );
-	t.equal( kumaraswamy.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof kumaraswamy.toJSON, 'function', 'has method' );
+	t.strictEqual( kumaraswamy.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -669,7 +670,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = kumaraswamy();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -685,7 +686,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = kumaraswamy( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -720,7 +721,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = kumaraswamy1();
 		r2 = kumaraswamy2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -755,7 +756,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = kumaraswamy1( 1.0, 2.0 );
 		r2 = kumaraswamy2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -774,7 +775,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Kumarasw
 	a = 2.0;
 	b = 4.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -800,7 +801,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Kumarasw
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'kumaraswamy', a, b ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -859,7 +860,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( kumaraswamy(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( kumaraswamy(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -909,8 +910,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -927,8 +928,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -959,7 +960,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( kumaraswamy(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( kumaraswamy(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.js b/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.js
index d1f500f1b655..71057d3d518c 100644
--- a/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof kumaraswamy.factory, 'function', 'has method' );
+	t.strictEqual( typeof kumaraswamy.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof kumaraswamy.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof kumaraswamy.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( kumaraswamy.NAME, 'kumaraswamy', 'has property' );
+	t.strictEqual( kumaraswamy.NAME, 'kumaraswamy', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof kumaraswamy.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof kumaraswamy.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( kumaraswamy.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( kumaraswamy.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof kumaraswamy.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof kumaraswamy.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( kumaraswamy.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( kumaraswamy.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof kumaraswamy.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof kumaraswamy.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof kumaraswamy.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof kumaraswamy.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( kumaraswamy( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( kumaraswamy( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/laplace/test/test.factory.js b/lib/node_modules/@stdlib/random/base/laplace/test/test.factory.js
index 08e38cd3b9d9..b50c3227c5cb 100644
--- a/lib/node_modules/@stdlib/random/base/laplace/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/laplace/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -372,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	laplace = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = laplace();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	laplace = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = laplace( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -407,7 +408,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = laplace1();
 		r2 = laplace2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -434,25 +435,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = laplace1();
 		r2 = laplace2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var laplace = factory();
-	t.equal( laplace.NAME, 'laplace', 'has property' );
+	t.strictEqual( laplace.NAME, 'laplace', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var laplace = factory();
-	t.equal( typeof laplace.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof laplace.PRNG, 'function', 'has property' );
 
 	laplace = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( laplace.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( laplace.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -460,14 +461,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var laplace = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( laplace.seed ), true, 'has property' );
-	t.equal( laplace.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( laplace.seed ), true, 'has property' );
+	t.strictEqual( laplace.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	laplace = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( laplace.seed, null, 'equal to `null`' );
+	t.strictEqual( laplace.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -483,54 +484,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var laplace = factory();
-	t.equal( typeof laplace.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof laplace.seedLength, 'number', 'has property' );
 
 	laplace = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( laplace.seedLength, null, 'equal to `null`' );
+	t.strictEqual( laplace.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var laplace = factory();
-	t.equal( isUint32Array( laplace.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( laplace.state ), true, 'has property' );
 
 	laplace = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( laplace.state, null, 'equal to `null`' );
+	t.strictEqual( laplace.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var laplace = factory();
-	t.equal( typeof laplace.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof laplace.stateLength, 'number', 'has property' );
 
 	laplace = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( laplace.stateLength, null, 'equal to `null`' );
+	t.strictEqual( laplace.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var laplace = factory();
-	t.equal( typeof laplace.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof laplace.byteLength, 'number', 'has property' );
 
 	laplace = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( laplace.byteLength, null, 'equal to `null`' );
+	t.strictEqual( laplace.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -539,11 +540,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	laplace = factory();
-	t.equal( typeof laplace.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof laplace.toJSON, 'function', 'has method' );
 
 	o = laplace.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, laplace.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, laplace.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( laplace.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -555,13 +556,13 @@ tape( 'attached to the returned function is a method to serialize the generator
 	laplace = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof laplace.toJSON, 'function', 'has method' );
-	t.equal( laplace.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof laplace.toJSON, 'function', 'has method' );
+	t.strictEqual( laplace.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument.strictEqual to `NaN`', function test( t ) {
 	var laplace;
 	var r;
 
@@ -572,7 +573,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument.strictEqual to `NaN`', function test( t ) {
 	var laplace;
 	var r;
 
@@ -620,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = laplace();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -636,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = laplace( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -671,7 +672,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = laplace1();
 		r2 = laplace2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -706,7 +707,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = laplace1( 1.0, 2.0 );
 		r2 = laplace2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -725,7 +726,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Laplace
 	mu = 0.0;
 	b = 3.14;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -751,7 +752,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Laplace
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'laplace', mu, b ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -810,7 +811,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( laplace(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( laplace(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -860,8 +861,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -878,8 +879,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -910,7 +911,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( laplace(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( laplace(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/laplace/test/test.js b/lib/node_modules/@stdlib/random/base/laplace/test/test.js
index ac2059ce6866..496f28fa964e 100644
--- a/lib/node_modules/@stdlib/random/base/laplace/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/laplace/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof laplace.factory, 'function', 'has method' );
+	t.strictEqual( typeof laplace.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof laplace.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof laplace.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( laplace.NAME, 'laplace', 'has property' );
+	t.strictEqual( laplace.NAME, 'laplace', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof laplace.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof laplace.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( laplace.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( laplace.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof laplace.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof laplace.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( laplace.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( laplace.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof laplace.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof laplace.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof laplace.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof laplace.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = laplace( 2.0, 1.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( laplace( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( laplace( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/levy/test/test.factory.js b/lib/node_modules/@stdlib/random/base/levy/test/test.factory.js
index d5d68348b80f..7b64e78f6e8f 100644
--- a/lib/node_modules/@stdlib/random/base/levy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/levy/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -372,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	levy = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = levy();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	levy = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = levy( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -407,7 +408,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = levy1();
 		r2 = levy2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -434,25 +435,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = levy1();
 		r2 = levy2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var levy = factory();
-	t.equal( levy.NAME, 'levy', 'has property' );
+	t.strictEqual( levy.NAME, 'levy', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var levy = factory();
-	t.equal( typeof levy.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof levy.PRNG, 'function', 'has property' );
 
 	levy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( levy.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( levy.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -460,14 +461,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var levy = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( levy.seed ), true, 'has property' );
-	t.equal( levy.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( levy.seed ), true, 'has property' );
+	t.strictEqual( levy.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	levy = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( levy.seed, null, 'equal to `null`' );
+	t.strictEqual( levy.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -483,54 +484,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var levy = factory();
-	t.equal( typeof levy.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof levy.seedLength, 'number', 'has property' );
 
 	levy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( levy.seedLength, null, 'equal to `null`' );
+	t.strictEqual( levy.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var levy = factory();
-	t.equal( isUint32Array( levy.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( levy.state ), true, 'has property' );
 
 	levy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( levy.state, null, 'equal to `null`' );
+	t.strictEqual( levy.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var levy = factory();
-	t.equal( typeof levy.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof levy.stateLength, 'number', 'has property' );
 
 	levy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( levy.stateLength, null, 'equal to `null`' );
+	t.strictEqual( levy.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var levy = factory();
-	t.equal( typeof levy.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof levy.byteLength, 'number', 'has property' );
 
 	levy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( levy.byteLength, null, 'equal to `null`' );
+	t.strictEqual( levy.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -539,11 +540,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	levy = factory();
-	t.equal( typeof levy.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof levy.toJSON, 'function', 'has method' );
 
 	o = levy.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, levy.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, levy.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( levy.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -555,13 +556,13 @@ tape( 'attached to the returned function is a method to serialize the generator
 	levy = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof levy.toJSON, 'function', 'has method' );
-	t.equal( levy.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof levy.toJSON, 'function', 'has method' );
+	t.strictEqual( levy.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument.strictEqual to `NaN`', function test( t ) {
 	var levy;
 	var r;
 
@@ -572,7 +573,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument.strictEqual to `NaN`', function test( t ) {
 	var levy;
 	var r;
 
@@ -620,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = levy();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -636,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = levy( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -671,7 +672,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = levy1();
 		r2 = levy2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -706,7 +707,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = levy1( 1.0, 2.0 );
 		r2 = levy2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -725,7 +726,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Lévy di
 	mu = 0.0;
 	c = 3.14;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -751,7 +752,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Lévy di
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'levy', mu, c ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -810,7 +811,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( levy(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( levy(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -860,8 +861,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -878,8 +879,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -910,7 +911,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( levy(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( levy(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/levy/test/test.js b/lib/node_modules/@stdlib/random/base/levy/test/test.js
index 291ea2756a51..b110fa80b3df 100644
--- a/lib/node_modules/@stdlib/random/base/levy/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/levy/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof levy.factory, 'function', 'has method' );
+	t.strictEqual( typeof levy.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof levy.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof levy.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( levy.NAME, 'levy', 'has property' );
+	t.strictEqual( levy.NAME, 'levy', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof levy.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof levy.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( levy.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( levy.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof levy.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof levy.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( levy.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( levy.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof levy.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof levy.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof levy.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof levy.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = levy( 2.0, 1.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( levy( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( levy( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/logistic/test/test.factory.js b/lib/node_modules/@stdlib/random/base/logistic/test/test.factory.js
index f351f60753ea..76375b12b1ef 100644
--- a/lib/node_modules/@stdlib/random/base/logistic/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/logistic/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -372,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	logistic = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = logistic();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	logistic = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = logistic( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -407,7 +408,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = logistic1();
 		r2 = logistic2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -434,25 +435,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = logistic1();
 		r2 = logistic2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var logistic = factory();
-	t.equal( logistic.NAME, 'logistic', 'has property' );
+	t.strictEqual( logistic.NAME, 'logistic', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var logistic = factory();
-	t.equal( typeof logistic.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof logistic.PRNG, 'function', 'has property' );
 
 	logistic = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( logistic.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( logistic.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -460,14 +461,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var logistic = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( logistic.seed ), true, 'has property' );
-	t.equal( logistic.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( logistic.seed ), true, 'has property' );
+	t.strictEqual( logistic.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	logistic = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( logistic.seed, null, 'equal to `null`' );
+	t.strictEqual( logistic.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -483,54 +484,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var logistic = factory();
-	t.equal( typeof logistic.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof logistic.seedLength, 'number', 'has property' );
 
 	logistic = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( logistic.seedLength, null, 'equal to `null`' );
+	t.strictEqual( logistic.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var logistic = factory();
-	t.equal( isUint32Array( logistic.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( logistic.state ), true, 'has property' );
 
 	logistic = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( logistic.state, null, 'equal to `null`' );
+	t.strictEqual( logistic.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var logistic = factory();
-	t.equal( typeof logistic.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof logistic.stateLength, 'number', 'has property' );
 
 	logistic = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( logistic.stateLength, null, 'equal to `null`' );
+	t.strictEqual( logistic.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var logistic = factory();
-	t.equal( typeof logistic.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof logistic.byteLength, 'number', 'has property' );
 
 	logistic = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( logistic.byteLength, null, 'equal to `null`' );
+	t.strictEqual( logistic.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -539,11 +540,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	logistic = factory();
-	t.equal( typeof logistic.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof logistic.toJSON, 'function', 'has method' );
 
 	o = logistic.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, logistic.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, logistic.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( logistic.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -555,13 +556,13 @@ tape( 'attached to the returned function is a method to serialize the generator
 	logistic = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof logistic.toJSON, 'function', 'has method' );
-	t.equal( logistic.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof logistic.toJSON, 'function', 'has method' );
+	t.strictEqual( logistic.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument.strictEqual to `NaN`', function test( t ) {
 	var logistic;
 	var r;
 
@@ -572,7 +573,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument.strictEqual to `NaN`', function test( t ) {
 	var logistic;
 	var r;
 
@@ -620,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = logistic();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -636,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = logistic( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -671,7 +672,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = logistic1();
 		r2 = logistic2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -706,7 +707,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = logistic1( 1.0, 2.0 );
 		r2 = logistic2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -725,7 +726,7 @@ tape( 'the function returns a PRNG for generating random numbers from a logistic
 	mu = 0.0;
 	s = 3.14;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -751,7 +752,7 @@ tape( 'the function returns a PRNG for generating random numbers from a logistic
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'logistic', mu, s ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -810,7 +811,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( logistic(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( logistic(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -860,8 +861,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -878,8 +879,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -910,7 +911,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( logistic(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( logistic(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/logistic/test/test.js b/lib/node_modules/@stdlib/random/base/logistic/test/test.js
index 32b4657b6f8a..e9dbbde824d1 100644
--- a/lib/node_modules/@stdlib/random/base/logistic/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/logistic/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof logistic.factory, 'function', 'has method' );
+	t.strictEqual( typeof logistic.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof logistic.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof logistic.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( logistic.NAME, 'logistic', 'has property' );
+	t.strictEqual( logistic.NAME, 'logistic', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof logistic.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof logistic.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( logistic.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( logistic.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof logistic.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof logistic.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( logistic.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( logistic.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof logistic.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof logistic.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof logistic.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof logistic.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = logistic( 2.0, 1.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( logistic( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( logistic( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/lognormal/test/test.factory.js b/lib/node_modules/@stdlib/random/base/lognormal/test/test.factory.js
index eac86d76a0f8..1298c6506738 100644
--- a/lib/node_modules/@stdlib/random/base/lognormal/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/lognormal/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -372,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	lognormal = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = lognormal();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	lognormal = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = lognormal( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -407,7 +408,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = lognormal1();
 		r2 = lognormal2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -434,25 +435,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = lognormal1();
 		r2 = lognormal2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var lognormal = factory();
-	t.equal( lognormal.NAME, 'lognormal', 'has property' );
+	t.strictEqual( lognormal.NAME, 'lognormal', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var lognormal = factory();
-	t.equal( typeof lognormal.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof lognormal.PRNG, 'function', 'has property' );
 
 	lognormal = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( lognormal.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( lognormal.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -460,14 +461,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var lognormal = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( lognormal.seed ), true, 'has property' );
-	t.equal( lognormal.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( lognormal.seed ), true, 'has property' );
+	t.strictEqual( lognormal.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	lognormal = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( lognormal.seed, null, 'equal to `null`' );
+	t.strictEqual( lognormal.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -483,54 +484,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var lognormal = factory();
-	t.equal( typeof lognormal.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof lognormal.seedLength, 'number', 'has property' );
 
 	lognormal = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( lognormal.seedLength, null, 'equal to `null`' );
+	t.strictEqual( lognormal.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var lognormal = factory();
-	t.equal( isUint32Array( lognormal.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( lognormal.state ), true, 'has property' );
 
 	lognormal = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( lognormal.state, null, 'equal to `null`' );
+	t.strictEqual( lognormal.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var lognormal = factory();
-	t.equal( typeof lognormal.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof lognormal.stateLength, 'number', 'has property' );
 
 	lognormal = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( lognormal.stateLength, null, 'equal to `null`' );
+	t.strictEqual( lognormal.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var lognormal = factory();
-	t.equal( typeof lognormal.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof lognormal.byteLength, 'number', 'has property' );
 
 	lognormal = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( lognormal.byteLength, null, 'equal to `null`' );
+	t.strictEqual( lognormal.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -539,11 +540,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	lognormal = factory();
-	t.equal( typeof lognormal.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof lognormal.toJSON, 'function', 'has method' );
 
 	o = lognormal.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, lognormal.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, lognormal.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( lognormal.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -555,13 +556,13 @@ tape( 'attached to the returned function is a method to serialize the generator
 	lognormal = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof lognormal.toJSON, 'function', 'has method' );
-	t.equal( lognormal.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof lognormal.toJSON, 'function', 'has method' );
+	t.strictEqual( lognormal.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument.strictEqual to `NaN`', function test( t ) {
 	var lognormal;
 	var r;
 
@@ -572,7 +573,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument.strictEqual to `NaN`', function test( t ) {
 	var lognormal;
 	var r;
 
@@ -620,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = lognormal();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -636,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = lognormal( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -671,7 +672,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = lognormal1();
 		r2 = lognormal2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -706,7 +707,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = lognormal1( 1.0, 2.0 );
 		r2 = lognormal2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -725,7 +726,7 @@ tape( 'the function returns a PRNG for generating pseudorandom numbers from a lo
 	mu = 2.0;
 	sigma = 4.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -751,7 +752,7 @@ tape( 'the function returns a PRNG for generating pseudorandom numbers from a lo
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'lognormal', mu, sigma ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue <= 0.05 ) {
 				rejected += 1;
 			}
@@ -810,7 +811,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( lognormal(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( lognormal(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -860,8 +861,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -878,8 +879,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -910,7 +911,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( lognormal(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( lognormal(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/lognormal/test/test.js b/lib/node_modules/@stdlib/random/base/lognormal/test/test.js
index ad82e5c1f683..9d59a7a92ffe 100644
--- a/lib/node_modules/@stdlib/random/base/lognormal/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/lognormal/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof lognormal.factory, 'function', 'has method' );
+	t.strictEqual( typeof lognormal.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof lognormal.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof lognormal.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( lognormal.NAME, 'lognormal', 'has property' );
+	t.strictEqual( lognormal.NAME, 'lognormal', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof lognormal.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof lognormal.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( lognormal.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( lognormal.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof lognormal.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof lognormal.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( lognormal.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( lognormal.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof lognormal.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof lognormal.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof lognormal.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof lognormal.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( lognormal( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( lognormal( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.create_table.js b/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.create_table.js
index 9f39dfe869be..f3fabf78b51b 100644
--- a/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.create_table.js
+++ b/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.create_table.js
@@ -42,8 +42,8 @@ tape( 'the function returns an `Int32Array`', function test( t ) {
 	arr = new Int32Array( 32 );
 	out = createTable( minstd, arr, arr.length );
 
-	t.equal( isInt32Array( out ), true, 'returns expected value' );
-	t.equal( out, arr, 'returns expected value' );
+	t.strictEqual( isInt32Array( out ), true, 'returns expected value' );
+	t.strictEqual( out, arr, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.factory.js b/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.factory.js
index 882807e52286..8802eabffbfd 100644
--- a/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.factory.js
@@ -32,6 +32,7 @@ var isPositiveInteger = require( '@stdlib/math/base/assert/is-positive-integer'
 var kstest = require( '@stdlib/stats/kstest' );
 var gcopy = require( '@stdlib/blas/base/gcopy' );
 var typedarray2json = require( '@stdlib/array/to-json' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -430,9 +431,9 @@ tape( 'the function returns a pseudorandom number generator (no options)', funct
 	minstd = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( isPositiveInteger( v ), true, 'returns a positive integer' );
-		t.equal( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( isPositiveInteger( v ), true, 'returns a positive integer' );
+		t.strictEqual( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
 	}
 	t.end();
 });
@@ -445,9 +446,9 @@ tape( 'the function returns a pseudorandom number generator (options; no seed)',
 	minstd = factory( {} );
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( isPositiveInteger( v ), true, 'returns a positive integer' );
-		t.equal( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( isPositiveInteger( v ), true, 'returns a positive integer' );
+		t.strictEqual( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
 	}
 	t.end();
 });
@@ -474,7 +475,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 1e3; i++ ) {
 		v1 = minstd1();
 		v2 = minstd2();
-		t.equal( v1, v2, 'both return same number' );
+		t.strictEqual( v1, v2, 'both return same number' );
 	}
 	t.end();
 });
@@ -501,7 +502,7 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 1e3; i++ ) {
 		v1 = minstd1();
 		v2 = minstd2();
-		t.equal( v1, v2, 'both return same number' );
+		t.strictEqual( v1, v2, 'both return same number' );
 	}
 	t.end();
 });
@@ -532,7 +533,7 @@ tape( 'the returned function returns a known sequence of pseudorandom integers',
 		'seed': seed
 	});
 
-	actual = new Array( expected.length );
+	actual = zeros( expected.length );
 	for ( i = 0; i < expected.length; i++ ) {
 		actual[ i ] = minstd();
 	}
@@ -556,7 +557,7 @@ tape( 'the returned function returns a known sequence of pseudorandom integers',
 		'seed': seed
 	});
 
-	actual = new Array( expected.length );
+	actual = zeros( expected.length );
 	for ( i = 0; i < expected.length; i++ ) {
 		actual[ i ] = minstd();
 	}
@@ -567,19 +568,19 @@ tape( 'the returned function returns a known sequence of pseudorandom integers',
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var minstd = factory();
-	t.equal( minstd.NAME, 'minstd-shuffle', 'has property' );
+	t.strictEqual( minstd.NAME, 'minstd-shuffle', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the minimum possible generated number', function test( t ) {
 	var minstd = factory();
-	t.equal( minstd.MIN, 1, 'has property' );
+	t.strictEqual( minstd.MIN, 1, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the maximum possible generated number', function test( t ) {
 	var minstd = factory();
-	t.equal( minstd.MAX, INT32_MAX-1, 'has property' );
+	t.strictEqual( minstd.MAX, INT32_MAX-1, 'has property' );
 	t.end();
 });
 
@@ -592,9 +593,9 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	});
 	actual = minstd.seed;
 
-	t.equal( isInt32Array( actual ), true, 'has property' );
-	t.equal( actual.length, 1, 'has expected length' );
-	t.equal( actual[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isInt32Array( actual ), true, 'has property' );
+	t.strictEqual( actual.length, 1, 'has expected length' );
+	t.strictEqual( actual[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -611,34 +612,34 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 	actual = minstd.seed;
 
-	t.equal( isInt32Array( actual ), true, 'has property' );
+	t.strictEqual( isInt32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var minstd = factory();
-	t.equal( typeof minstd.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var minstd = factory();
-	t.equal( isInt32Array( minstd.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( minstd.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var minstd = factory();
-	t.equal( typeof minstd.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var minstd = factory();
-	t.equal( typeof minstd.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -647,11 +648,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	minstd = factory();
-	t.equal( typeof minstd.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof minstd.toJSON, 'function', 'has method' );
 
 	o = minstd.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, minstd.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, minstd.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( minstd.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -930,27 +931,27 @@ tape( 'attached to the returned function is a `normalized` method for generating
 	minstd = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd.normalized();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator name', function test( t ) {
 	var minstd = factory();
-	t.equal( minstd.normalized.NAME, 'minstd-shuffle', 'has property' );
+	t.strictEqual( minstd.normalized.NAME, 'minstd-shuffle', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the minimum possible generated number', function test( t ) {
 	var minstd = factory();
-	t.equal( minstd.normalized.MIN, 0.0, 'has property' );
+	t.strictEqual( minstd.normalized.MIN, 0.0, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the maximum possible generated number', function test( t ) {
 	var minstd = factory();
-	t.equal( minstd.normalized.MAX, (INT32_MAX-2.0)/(INT32_MAX-1.0), 'has property' );
+	t.strictEqual( minstd.normalized.MAX, (INT32_MAX-2.0)/(INT32_MAX-1.0), 'has property' );
 	t.end();
 });
 
@@ -963,9 +964,9 @@ tape( 'attached to the `normalized` method is the generator seed (integer seed)'
 	});
 	actual = minstd.normalized.seed;
 
-	t.equal( isInt32Array( actual ), true, 'has property' );
-	t.equal( actual.length, 1, 'has expected length' );
-	t.equal( actual[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isInt32Array( actual ), true, 'has property' );
+	t.strictEqual( actual.length, 1, 'has expected length' );
+	t.strictEqual( actual[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -981,28 +982,28 @@ tape( 'attached to the `normalized` method is the generator seed (array seed)',
 	});
 	actual = minstd.normalized.seed;
 
-	t.equal( isInt32Array( actual ), true, 'has property' );
+	t.strictEqual( isInt32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state', function test( t ) {
 	var minstd = factory();
-	t.equal( isInt32Array( minstd.normalized.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( minstd.normalized.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state length', function test( t ) {
 	var minstd = factory();
-	t.equal( typeof minstd.normalized.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.normalized.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state size', function test( t ) {
 	var minstd = factory();
-	t.equal( typeof minstd.normalized.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.normalized.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -1011,11 +1012,11 @@ tape( 'attached to the r`normalized` method is a method to serialize the generat
 	var o;
 
 	minstd = factory();
-	t.equal( typeof minstd.normalized.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof minstd.normalized.toJSON, 'function', 'has method' );
 
 	o = minstd.normalized.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, minstd.normalized.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, minstd.normalized.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( minstd.normalized.state ), 'has property' );
 
 	t.end();
@@ -1294,7 +1295,7 @@ tape( 'the `normalized` method returns pseudorandom numbers drawn from a uniform
 
 	threshold = 0.10;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 500;
 
 	count = -1;
@@ -1323,7 +1324,7 @@ tape( 'the `normalized` method returns pseudorandom numbers drawn from a uniform
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'uniform', 0.0, 1.0 ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1382,7 +1383,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1432,8 +1433,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1464,7 +1465,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1522,9 +1523,9 @@ tape( 'the returned function supports setting the generator state to a state arr
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
 		v1 = rand1();
-		t.equal( v1, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v1, arr[ i ], 'returns expected value. i: '+i+'.' );
 		v2 = rand2();
-		t.equal( v2, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v2, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1554,7 +1555,7 @@ tape( 'the returned function supports setting the generator state (normalized)',
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1584,7 +1585,7 @@ tape( 'the returned function supports setting the generator state (normalized)',
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1634,8 +1635,8 @@ tape( 'the returned function supports setting a shared generator state (same len
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1652,8 +1653,8 @@ tape( 'the returned function supports setting a shared generator state (same len
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1705,8 +1706,8 @@ tape( 'the returned function supports setting a shared generator state (differen
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1729,7 +1730,7 @@ tape( 'the returned function supports setting a shared generator state (differen
 		v2 = rand2();
 
 		// `rand1()` state is not affected by `rand2()`:
-		t.equal( v1, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v1, arr[ i ], 'returns expected value. i: '+i+'.' );
 
 		// `rand2()` state was never reset:
 		t.notEqual( v2, arr[ j+1 ], 'does not return expected value. i: '+(j+1)+'.' );
@@ -1749,8 +1750,8 @@ tape( 'the returned function supports setting a shared generator state (differen
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1809,8 +1810,8 @@ tape( 'the returned function supports setting a shared generator state (no initi
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1826,8 +1827,8 @@ tape( 'the returned function supports setting a shared generator state (no initi
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.js b/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.js
index 0e1abc34c40a..07d4fc1d7900 100644
--- a/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.js
@@ -36,57 +36,57 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate normalized pseudorandom numbers', function test( t ) {
-	t.equal( typeof minstd.normalized, 'function', 'has method' );
+	t.strictEqual( typeof minstd.normalized, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to generate linear congruential pseudorandom number generator', function test( t ) {
-	t.equal( typeof minstd.factory, 'function', 'has method' );
+	t.strictEqual( typeof minstd.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof minstd.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof minstd.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( minstd.NAME, 'minstd-shuffle', 'has property' );
+	t.strictEqual( minstd.NAME, 'minstd-shuffle', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the minimum possible generated number', function test( t ) {
-	t.equal( minstd.MIN, 1, 'has property' );
+	t.strictEqual( minstd.MIN, 1, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the maximum possible generated number', function test( t ) {
-	t.equal( minstd.MAX, INT32_MAX-1, 'has property' );
+	t.strictEqual( minstd.MAX, INT32_MAX-1, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isInt32Array( minstd.seed ), true, 'has property' );
+	t.strictEqual( isInt32Array( minstd.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof minstd.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isInt32Array( minstd.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( minstd.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof minstd.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof minstd.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -95,9 +95,9 @@ tape( 'the function returns pseudorandom integers strictly between 0 and 2^31-1
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( isPositiveInteger( v ), true, 'returns a positive integer' );
-		t.equal( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( isPositiveInteger( v ), true, 'returns a positive integer' );
+		t.strictEqual( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
 	}
 	t.end();
 });
@@ -107,54 +107,54 @@ tape( 'the `normalized` method returns pseudorandom numbers strictly between 0 (
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd.normalized();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator name', function test( t ) {
-	t.equal( minstd.normalized.NAME, 'minstd-shuffle', 'has property' );
+	t.strictEqual( minstd.normalized.NAME, 'minstd-shuffle', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the minimum possible generated number', function test( t ) {
-	t.equal( minstd.normalized.MIN, 0.0, 'has property' );
+	t.strictEqual( minstd.normalized.MIN, 0.0, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the maximum possible generated number', function test( t ) {
-	t.equal( minstd.normalized.MAX, (INT32_MAX-2.0)/(INT32_MAX-1.0), 'has property' );
+	t.strictEqual( minstd.normalized.MAX, (INT32_MAX-2.0)/(INT32_MAX-1.0), 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator seed', function test( t ) {
-	t.equal( isInt32Array( minstd.normalized.seed ), true, 'has property' );
+	t.strictEqual( isInt32Array( minstd.normalized.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator seed length', function test( t ) {
-	t.equal( typeof minstd.normalized.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.normalized.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state', function test( t ) {
-	t.equal( isInt32Array( minstd.normalized.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( minstd.normalized.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state length', function test( t ) {
-	t.equal( typeof minstd.normalized.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.normalized.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state size', function test( t ) {
-	t.equal( typeof minstd.normalized.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.normalized.byteLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof minstd.normalized.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof minstd.normalized.toJSON, 'function', 'has method' );
 	t.end();
 });
 
@@ -180,7 +180,7 @@ tape( 'the generator supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -207,7 +207,7 @@ tape( 'the generator supports setting the generator state (normalized)', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -234,7 +234,7 @@ tape( 'the generator supports setting the generator state (normalized)', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/minstd/test/test.factory.js b/lib/node_modules/@stdlib/random/base/minstd/test/test.factory.js
index 33b65638c5e9..0b5b8b44ab07 100644
--- a/lib/node_modules/@stdlib/random/base/minstd/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/minstd/test/test.factory.js
@@ -389,9 +389,9 @@ tape( 'the function returns a pseudorandom number generator (no options)', funct
 	minstd = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( isPositiveInteger( v ), true, 'returns a positive integer' );
-		t.equal( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( isPositiveInteger( v ), true, 'returns a positive integer' );
+		t.strictEqual( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
 	}
 	t.end();
 });
@@ -404,9 +404,9 @@ tape( 'the function returns a pseudorandom number generator (options; no seed)',
 	minstd = factory( {} );
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( isPositiveInteger( v ), true, 'returns a positive integer' );
-		t.equal( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( isPositiveInteger( v ), true, 'returns a positive integer' );
+		t.strictEqual( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
 	}
 	t.end();
 });
@@ -433,7 +433,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 1e3; i++ ) {
 		v1 = minstd1();
 		v2 = minstd2();
-		t.equal( v1, v2, 'both return same number' );
+		t.strictEqual( v1, v2, 'both return same number' );
 	}
 	t.end();
 });
@@ -460,26 +460,26 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 1e3; i++ ) {
 		v1 = minstd1();
 		v2 = minstd2();
-		t.equal( v1, v2, 'both return same number' );
+		t.strictEqual( v1, v2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var minstd = factory();
-	t.equal( minstd.NAME, 'minstd', 'has property' );
+	t.strictEqual( minstd.NAME, 'minstd', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the minimum possible generated number', function test( t ) {
 	var minstd = factory();
-	t.equal( minstd.MIN, 1, 'has property' );
+	t.strictEqual( minstd.MIN, 1, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the maximum possible generated number', function test( t ) {
 	var minstd = factory();
-	t.equal( minstd.MAX, INT32_MAX-1, 'has property' );
+	t.strictEqual( minstd.MAX, INT32_MAX-1, 'has property' );
 	t.end();
 });
 
@@ -492,9 +492,9 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	});
 	actual = minstd.seed;
 
-	t.equal( isInt32Array( actual ), true, 'has property' );
-	t.equal( actual.length, 1, 'has expected length' );
-	t.equal( actual[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isInt32Array( actual ), true, 'has property' );
+	t.strictEqual( actual.length, 1, 'has expected length' );
+	t.strictEqual( actual[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -511,34 +511,34 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 	actual = minstd.seed;
 
-	t.equal( isInt32Array( actual ), true, 'has property' );
+	t.strictEqual( isInt32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var minstd = factory();
-	t.equal( typeof minstd.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var minstd = factory();
-	t.equal( isInt32Array( minstd.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( minstd.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var minstd = factory();
-	t.equal( typeof minstd.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var minstd = factory();
-	t.equal( typeof minstd.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -547,11 +547,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	minstd = factory();
-	t.equal( typeof minstd.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof minstd.toJSON, 'function', 'has method' );
 
 	o = minstd.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, minstd.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, minstd.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( minstd.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -766,27 +766,27 @@ tape( 'attached to the returned function is a `normalized` method for generating
 	minstd = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd.normalized();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator name', function test( t ) {
 	var minstd = factory();
-	t.equal( minstd.normalized.NAME, 'minstd', 'has property' );
+	t.strictEqual( minstd.normalized.NAME, 'minstd', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the minimum possible generated number', function test( t ) {
 	var minstd = factory();
-	t.equal( minstd.normalized.MIN, 0.0, 'has property' );
+	t.strictEqual( minstd.normalized.MIN, 0.0, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the maximum possible generated number', function test( t ) {
 	var minstd = factory();
-	t.equal( minstd.normalized.MAX, (INT32_MAX-2.0)/(INT32_MAX-1.0), 'has property' );
+	t.strictEqual( minstd.normalized.MAX, (INT32_MAX-2.0)/(INT32_MAX-1.0), 'has property' );
 	t.end();
 });
 
@@ -799,9 +799,9 @@ tape( 'attached to the `normalized` method is the generator seed (integer seed)'
 	});
 	actual = minstd.normalized.seed;
 
-	t.equal( isInt32Array( actual ), true, 'has property' );
-	t.equal( actual.length, 1, 'has expected length' );
-	t.equal( actual[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isInt32Array( actual ), true, 'has property' );
+	t.strictEqual( actual.length, 1, 'has expected length' );
+	t.strictEqual( actual[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -817,34 +817,34 @@ tape( 'attached to the `normalized` method is the generator seed (array seed)',
 	});
 	actual = minstd.normalized.seed;
 
-	t.equal( isInt32Array( actual ), true, 'has property' );
+	t.strictEqual( isInt32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator seed length', function test( t ) {
 	var minstd = factory();
-	t.equal( typeof minstd.normalized.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.normalized.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state', function test( t ) {
 	var minstd = factory();
-	t.equal( isInt32Array( minstd.normalized.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( minstd.normalized.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state length', function test( t ) {
 	var minstd = factory();
-	t.equal( typeof minstd.normalized.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.normalized.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state size', function test( t ) {
 	var minstd = factory();
-	t.equal( typeof minstd.normalized.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.normalized.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -853,11 +853,11 @@ tape( 'attached to the `normalized` method is a method to serialize the generato
 	var o;
 
 	minstd = factory();
-	t.equal( typeof minstd.normalized.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof minstd.normalized.toJSON, 'function', 'has method' );
 
 	o = minstd.normalized.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, minstd.normalized.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, minstd.normalized.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( minstd.normalized.state ), 'has property' );
 
 	t.end();
@@ -1124,7 +1124,7 @@ tape( 'the `normalized` method returns pseudorandom numbers drawn from a uniform
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'uniform', 0.0, 1.0 ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1183,7 +1183,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1233,8 +1233,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1265,7 +1265,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1323,9 +1323,9 @@ tape( 'the returned function supports setting the generator state to a state arr
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
 		v1 = rand1();
-		t.equal( v1, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v1, arr[ i ], 'returns expected value. i: '+i+'.' );
 		v2 = rand2();
-		t.equal( v2, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v2, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1355,7 +1355,7 @@ tape( 'the returned function supports setting the generator state (normalized)',
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1385,7 +1385,7 @@ tape( 'the returned function supports setting the generator state (normalized)',
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1435,8 +1435,8 @@ tape( 'the returned function supports setting a shared generator state (same len
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1453,8 +1453,8 @@ tape( 'the returned function supports setting a shared generator state (same len
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1506,8 +1506,8 @@ tape( 'the returned function supports setting a shared generator state (differen
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1530,7 +1530,7 @@ tape( 'the returned function supports setting a shared generator state (differen
 		v2 = rand2();
 
 		// `rand1()` state is not affected by `rand2()`:
-		t.equal( v1, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v1, arr[ i ], 'returns expected value. i: '+i+'.' );
 
 		// `rand2()` state was never reset:
 		t.notEqual( v2, arr[ j+1 ], 'does not return expected value. i: '+(j+1)+'.' );
@@ -1550,8 +1550,8 @@ tape( 'the returned function supports setting a shared generator state (differen
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1610,8 +1610,8 @@ tape( 'the returned function supports setting a shared generator state (no initi
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1627,8 +1627,8 @@ tape( 'the returned function supports setting a shared generator state (no initi
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/minstd/test/test.js b/lib/node_modules/@stdlib/random/base/minstd/test/test.js
index 8313ba2acbe2..cfc3e197fc9f 100644
--- a/lib/node_modules/@stdlib/random/base/minstd/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/minstd/test/test.js
@@ -36,57 +36,57 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate normalized pseudorandom numbers', function test( t ) {
-	t.equal( typeof minstd.normalized, 'function', 'has method' );
+	t.strictEqual( typeof minstd.normalized, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to generate linear congruential pseudorandom number generator', function test( t ) {
-	t.equal( typeof minstd.factory, 'function', 'has method' );
+	t.strictEqual( typeof minstd.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof minstd.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof minstd.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( minstd.NAME, 'minstd', 'has property' );
+	t.strictEqual( minstd.NAME, 'minstd', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the minimum possible generated number', function test( t ) {
-	t.equal( minstd.MIN, 1, 'has property' );
+	t.strictEqual( minstd.MIN, 1, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the maximum possible generated number', function test( t ) {
-	t.equal( minstd.MAX, INT32_MAX-1, 'has property' );
+	t.strictEqual( minstd.MAX, INT32_MAX-1, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isInt32Array( minstd.seed ), true, 'has property' );
+	t.strictEqual( isInt32Array( minstd.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof minstd.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isInt32Array( minstd.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( minstd.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof minstd.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof minstd.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -95,9 +95,9 @@ tape( 'the function returns pseudorandom integers strictly between 0 and 2^31-1
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( isPositiveInteger( v ), true, 'returns a positive integer' );
-		t.equal( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( isPositiveInteger( v ), true, 'returns a positive integer' );
+		t.strictEqual( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
 	}
 	t.end();
 });
@@ -107,54 +107,54 @@ tape( 'the `normalized` method returns pseudorandom numbers strictly between 0 (
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd.normalized();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator name', function test( t ) {
-	t.equal( minstd.normalized.NAME, 'minstd', 'has property' );
+	t.strictEqual( minstd.normalized.NAME, 'minstd', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the minimum possible generated number', function test( t ) {
-	t.equal( minstd.normalized.MIN, 0.0, 'has property' );
+	t.strictEqual( minstd.normalized.MIN, 0.0, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the maximum possible generated number', function test( t ) {
-	t.equal( minstd.normalized.MAX, (INT32_MAX-2.0)/(INT32_MAX-1.0), 'has property' );
+	t.strictEqual( minstd.normalized.MAX, (INT32_MAX-2.0)/(INT32_MAX-1.0), 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator seed', function test( t ) {
-	t.equal( isInt32Array( minstd.normalized.seed ), true, 'has property' );
+	t.strictEqual( isInt32Array( minstd.normalized.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator seed length', function test( t ) {
-	t.equal( typeof minstd.normalized.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.normalized.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state', function test( t ) {
-	t.equal( isInt32Array( minstd.normalized.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( minstd.normalized.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state length', function test( t ) {
-	t.equal( typeof minstd.normalized.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.normalized.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state size', function test( t ) {
-	t.equal( typeof minstd.normalized.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof minstd.normalized.byteLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof minstd.normalized.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof minstd.normalized.toJSON, 'function', 'has method' );
 	t.end();
 });
 
@@ -180,7 +180,7 @@ tape( 'the generator supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -207,7 +207,7 @@ tape( 'the generator supports setting the generator state (normalized)', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -234,7 +234,7 @@ tape( 'the generator supports setting the generator state (normalized)', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( minstd.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/mt19937/test/test.factory.js b/lib/node_modules/@stdlib/random/base/mt19937/test/test.factory.js
index 0c13b6b7847e..a522d9e36518 100644
--- a/lib/node_modules/@stdlib/random/base/mt19937/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/mt19937/test/test.factory.js
@@ -33,6 +33,7 @@ var kstest = require( '@stdlib/stats/kstest' );
 var minstd = require( '@stdlib/random/base/minstd-shuffle' );
 var gcopy = require( '@stdlib/blas/base/gcopy' );
 var typedarray2json = require( '@stdlib/array/to-json' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -456,9 +457,9 @@ tape( 'the function returns a pseudorandom number generator (no options)', funct
 	mt19937 = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = mt19937();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( isNonNegativeInteger( v ), true, 'returns a nonnegative integer' );
-		t.equal( v >= 0 && v <= UINT32_MAX, true, 'returns an integer between 0 and 2^32-1 (inclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( isNonNegativeInteger( v ), true, 'returns a nonnegative integer' );
+		t.strictEqual( v >= 0 && v <= UINT32_MAX, true, 'returns an integer between 0 and 2^32-1 (inclusive)' );
 	}
 	t.end();
 });
@@ -471,9 +472,9 @@ tape( 'the function returns a pseudorandom number generator (options; no seed)',
 	mt19937 = factory( {} );
 	for ( i = 0; i < 1e3; i++ ) {
 		v = mt19937();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( isNonNegativeInteger( v ), true, 'returns a nonnegative integer' );
-		t.equal( v >= 0 && v <= UINT32_MAX, true, 'returns an integer between 0 and 2^32-1 (inclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( isNonNegativeInteger( v ), true, 'returns a nonnegative integer' );
+		t.strictEqual( v >= 0 && v <= UINT32_MAX, true, 'returns an integer between 0 and 2^32-1 (inclusive)' );
 	}
 	t.end();
 });
@@ -500,7 +501,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 1e3; i++ ) {
 		v1 = mt19937a();
 		v2 = mt19937b();
-		t.equal( v1, v2, 'both return same number' );
+		t.strictEqual( v1, v2, 'both return same number' );
 	}
 	t.end();
 });
@@ -527,7 +528,7 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed;
 	for ( i = 0; i < 1e3; i++ ) {
 		v1 = mt19937a();
 		v2 = mt19937b();
-		t.equal( v1, v2, 'both return same number' );
+		t.strictEqual( v1, v2, 'both return same number' );
 	}
 	t.end();
 });
@@ -554,26 +555,26 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed;
 	for ( i = 0; i < 1e3; i++ ) {
 		v1 = mt19937a();
 		v2 = mt19937b();
-		t.equal( v1, v2, 'both return same number' );
+		t.strictEqual( v1, v2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var mt19937 = factory();
-	t.equal( mt19937.NAME, 'mt19937', 'has property' );
+	t.strictEqual( mt19937.NAME, 'mt19937', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the minimum possible generated number', function test( t ) {
 	var mt19937 = factory();
-	t.equal( mt19937.MIN, 0, 'has property' );
+	t.strictEqual( mt19937.MIN, 0, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the maximum possible generated number', function test( t ) {
 	var mt19937 = factory();
-	t.equal( mt19937.MAX, UINT32_MAX, 'has property' );
+	t.strictEqual( mt19937.MAX, UINT32_MAX, 'has property' );
 	t.end();
 });
 
@@ -586,9 +587,9 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	});
 	actual = mt19937.seed;
 
-	t.equal( isUint32Array( actual ), true, 'has property' );
-	t.equal( actual.length, 1, 'has expected length' );
-	t.equal( actual[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( actual.length, 1, 'has expected length' );
+	t.strictEqual( actual[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -601,9 +602,9 @@ tape( 'attached to the returned function is the generator seed (array seed; leng
 	});
 	actual = mt19937.seed;
 
-	t.equal( isUint32Array( actual ), true, 'has property' );
-	t.equal( actual.length, 1, 'has expected length' );
-	t.equal( actual[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( actual.length, 1, 'has expected length' );
+	t.strictEqual( actual[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -619,34 +620,34 @@ tape( 'attached to the returned function is the generator seed (array seed; leng
 	});
 
 	actual = mt19937.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var mt19937 = factory();
-	t.equal( typeof mt19937.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof mt19937.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var mt19937 = factory();
-	t.equal( isUint32Array( mt19937.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( mt19937.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var mt19937 = factory();
-	t.equal( typeof mt19937.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof mt19937.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var mt19937 = factory();
-	t.equal( typeof mt19937.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof mt19937.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -655,11 +656,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	mt19937 = factory();
-	t.equal( typeof mt19937.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof mt19937.toJSON, 'function', 'has method' );
 
 	o = mt19937.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, mt19937.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, mt19937.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( mt19937.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -929,27 +930,27 @@ tape( 'attached to the returned function is a `normalized` method for generating
 	mt19937 = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = mt19937.normalized();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator name', function test( t ) {
 	var mt19937 = factory();
-	t.equal( mt19937.normalized.NAME, 'mt19937', 'has property' );
+	t.strictEqual( mt19937.normalized.NAME, 'mt19937', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the minimum possible generated number', function test( t ) {
 	var mt19937 = factory();
-	t.equal( mt19937.normalized.MIN, 0.0, 'has property' );
+	t.strictEqual( mt19937.normalized.MIN, 0.0, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the maximum possible generated number', function test( t ) {
 	var mt19937 = factory();
-	t.equal( mt19937.normalized.MAX, FLOAT64_MAX_SAFE_INTEGER/(FLOAT64_MAX_SAFE_INTEGER+1), 'has property' );
+	t.strictEqual( mt19937.normalized.MAX, FLOAT64_MAX_SAFE_INTEGER/(FLOAT64_MAX_SAFE_INTEGER+1), 'has property' );
 	t.end();
 });
 
@@ -962,9 +963,9 @@ tape( 'attached to the `normalized` method is the generator seed (integer seed)'
 	});
 	actual = mt19937.normalized.seed;
 
-	t.equal( isUint32Array( actual ), true, 'has property' );
-	t.equal( actual.length, 1, 'has expected length' );
-	t.equal( actual[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( actual.length, 1, 'has expected length' );
+	t.strictEqual( actual[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -977,9 +978,9 @@ tape( 'attached to the `normalized` method is the generator seed (array seed; le
 	});
 	actual = mt19937.normalized.seed;
 
-	t.equal( isUint32Array( actual ), true, 'has property' );
-	t.equal( actual.length, 1, 'has expected length' );
-	t.equal( actual[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( actual.length, 1, 'has expected length' );
+	t.strictEqual( actual[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -995,34 +996,34 @@ tape( 'attached to the `normalized` method is the generator seed (array seed; le
 	});
 
 	actual = mt19937.normalized.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator seed length', function test( t ) {
 	var mt19937 = factory();
-	t.equal( typeof mt19937.normalized.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof mt19937.normalized.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state', function test( t ) {
 	var mt19937 = factory();
-	t.equal( isUint32Array( mt19937.normalized.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( mt19937.normalized.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state size', function test( t ) {
 	var mt19937 = factory();
-	t.equal( typeof mt19937.normalized.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof mt19937.normalized.byteLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state length', function test( t ) {
 	var mt19937 = factory();
-	t.equal( typeof mt19937.normalized.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof mt19937.normalized.stateLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -1031,11 +1032,11 @@ tape( 'attached to the `normalized` method is a method to serialize the generato
 	var o;
 
 	mt19937 = factory();
-	t.equal( typeof mt19937.normalized.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof mt19937.normalized.toJSON, 'function', 'has method' );
 
 	o = mt19937.normalized.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, mt19937.normalized.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, mt19937.normalized.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( mt19937.normalized.state ), 'has property' );
 
 	t.end();
@@ -1305,7 +1306,7 @@ tape( 'the `normalized` method returns pseudorandom numbers drawn from a uniform
 
 	threshold = 0.10;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 500;
 
 	count = -1;
@@ -1334,7 +1335,7 @@ tape( 'the `normalized` method returns pseudorandom numbers drawn from a uniform
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'uniform', 0.0, 1.0 ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1375,7 +1376,7 @@ tape( 'the function returns pseudorandom numbers from a Mersenne Twister PRNG (i
 		'seed': 1234
 	});
 	for ( i = 0; i < expected.length; i++ ) {
-		t.equal( rand(), expected[ i ], 'returns expected value for iteration '+i );
+		t.strictEqual( rand(), expected[ i ], 'returns expected value for iteration '+i );
 	}
 	t.end();
 });
@@ -1390,7 +1391,7 @@ tape( 'the function returns pseudorandom numbers from a Mersenne Twister PRNG (a
 		'seed': [ 1234 ]
 	});
 	for ( i = 0; i < expected.length; i++ ) {
-		t.equal( rand(), expected[ i ], 'returns expected value for iteration '+i );
+		t.strictEqual( rand(), expected[ i ], 'returns expected value for iteration '+i );
 	}
 	t.end();
 });
@@ -1405,7 +1406,7 @@ tape( 'the function returns pseudorandom numbers from a Mersenne Twister PRNG (a
 		'seed': [ 291, 564, 837, 1110 ]
 	});
 	for ( i = 0; i < expected.length; i++ ) {
-		t.equal( rand(), expected[ i ], 'returns expected value for iteration '+i );
+		t.strictEqual( rand(), expected[ i ], 'returns expected value for iteration '+i );
 	}
 	t.end();
 });
@@ -1423,7 +1424,7 @@ tape( 'the `normalized` method returns pseudorandom double-precision floating-po
 	};
 	rand = factory( opts ).normalized;
 	for ( i = 0; i < expected.length; i++ ) {
-		t.equal( rand(), expected[ i ], 'returns expected value for iteration '+i );
+		t.strictEqual( rand(), expected[ i ], 'returns expected value for iteration '+i );
 	}
 	t.end();
 });
@@ -1441,7 +1442,7 @@ tape( 'the `normalized` method returns pseudorandom double-precision floating-po
 	};
 	rand = factory( opts ).normalized;
 	for ( i = 0; i < expected.length; i++ ) {
-		t.equal( rand(), expected[ i ], 'returns expected value for iteration '+i );
+		t.strictEqual( rand(), expected[ i ], 'returns expected value for iteration '+i );
 	}
 	t.end();
 });
@@ -1459,7 +1460,7 @@ tape( 'the `normalized` method returns pseudorandom double-precision floating-po
 	};
 	rand = factory( opts ).normalized;
 	for ( i = 0; i < expected.length; i++ ) {
-		t.equal( rand(), expected[ i ], 'returns expected value for iteration '+i );
+		t.strictEqual( rand(), expected[ i ], 'returns expected value for iteration '+i );
 	}
 	t.end();
 });
@@ -1492,7 +1493,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( mt19937(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( mt19937(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1542,8 +1543,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1574,7 +1575,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( mt19937(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( mt19937(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1632,9 +1633,9 @@ tape( 'the returned function supports setting the generator state to a state arr
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
 		v1 = rand1();
-		t.equal( v1, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v1, arr[ i ], 'returns expected value. i: '+i+'.' );
 		v2 = rand2();
-		t.equal( v2, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v2, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1664,7 +1665,7 @@ tape( 'the returned function supports setting the generator state (normalized)',
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( mt19937.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( mt19937.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1694,7 +1695,7 @@ tape( 'the returned function supports setting the generator state (normalized)',
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( mt19937.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( mt19937.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1744,8 +1745,8 @@ tape( 'the returned function supports setting a shared generator state (same len
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1762,8 +1763,8 @@ tape( 'the returned function supports setting a shared generator state (same len
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1815,8 +1816,8 @@ tape( 'the returned function supports setting a shared generator state (differen
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1839,7 +1840,7 @@ tape( 'the returned function supports setting a shared generator state (differen
 		v2 = rand2();
 
 		// `rand1()` state is not affected by `rand2()`:
-		t.equal( v1, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v1, arr[ i ], 'returns expected value. i: '+i+'.' );
 
 		// `rand2()` state was never reset:
 		t.notEqual( v2, arr[ j+1 ], 'does not return expected value. i: '+(j+1)+'.' );
@@ -1859,8 +1860,8 @@ tape( 'the returned function supports setting a shared generator state (differen
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1919,8 +1920,8 @@ tape( 'the returned function supports setting a shared generator state (no initi
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1936,8 +1937,8 @@ tape( 'the returned function supports setting a shared generator state (no initi
 	for ( i = 0; i < 50; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/mt19937/test/test.js b/lib/node_modules/@stdlib/random/base/mt19937/test/test.js
index 0de4aa709e0d..c47a8d5e2af1 100644
--- a/lib/node_modules/@stdlib/random/base/mt19937/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/mt19937/test/test.js
@@ -37,57 +37,57 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate normalized pseudorandom numbers', function test( t ) {
-	t.equal( typeof mt19937.normalized, 'function', 'has method' );
+	t.strictEqual( typeof mt19937.normalized, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to create a Mersenne Twister pseudorandom number generator', function test( t ) {
-	t.equal( typeof mt19937.factory, 'function', 'has method' );
+	t.strictEqual( typeof mt19937.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof mt19937.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof mt19937.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( mt19937.NAME, 'mt19937', 'has property' );
+	t.strictEqual( mt19937.NAME, 'mt19937', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the minimum possible generated number', function test( t ) {
-	t.equal( mt19937.MIN, 0, 'has property' );
+	t.strictEqual( mt19937.MIN, 0, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the maximum possible generated number', function test( t ) {
-	t.equal( mt19937.MAX, UINT32_MAX, 'has property' );
+	t.strictEqual( mt19937.MAX, UINT32_MAX, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( mt19937.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( mt19937.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof mt19937.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof mt19937.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( mt19937.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( mt19937.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof mt19937.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof mt19937.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof mt19937.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof mt19937.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -96,9 +96,9 @@ tape( 'the function returns pseudorandom integers strictly between 0 and 2^32-1
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = mt19937();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( isNonNegativeInteger( v ), true, 'returns a nonnegative integer' );
-		t.equal( v >= 0 && v <= UINT32_MAX, true, 'returns an integer between 0 and 2^32-1 (inclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( isNonNegativeInteger( v ), true, 'returns a nonnegative integer' );
+		t.strictEqual( v >= 0 && v <= UINT32_MAX, true, 'returns an integer between 0 and 2^32-1 (inclusive)' );
 	}
 	t.end();
 });
@@ -108,54 +108,54 @@ tape( 'the `normalized` method returns pseudorandom numbers strictly between 0 (
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = mt19937.normalized();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator name', function test( t ) {
-	t.equal( mt19937.normalized.NAME, 'mt19937', 'has property' );
+	t.strictEqual( mt19937.normalized.NAME, 'mt19937', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the minimum possible generated number', function test( t ) {
-	t.equal( mt19937.normalized.MIN, 0.0, 'has property' );
+	t.strictEqual( mt19937.normalized.MIN, 0.0, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the maximum possible generated number', function test( t ) {
-	t.equal( mt19937.normalized.MAX, FLOAT64_MAX_SAFE_INTEGER/(FLOAT64_MAX_SAFE_INTEGER+1), 'has property' );
+	t.strictEqual( mt19937.normalized.MAX, FLOAT64_MAX_SAFE_INTEGER/(FLOAT64_MAX_SAFE_INTEGER+1), 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator seed', function test( t ) {
-	t.equal( isUint32Array( mt19937.normalized.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( mt19937.normalized.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator seed length', function test( t ) {
-	t.equal( typeof mt19937.normalized.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof mt19937.normalized.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state', function test( t ) {
-	t.equal( isUint32Array( mt19937.normalized.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( mt19937.normalized.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state length', function test( t ) {
-	t.equal( typeof mt19937.normalized.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof mt19937.normalized.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is the generator state size', function test( t ) {
-	t.equal( typeof mt19937.normalized.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof mt19937.normalized.byteLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the `normalized` method is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof mt19937.normalized.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof mt19937.normalized.toJSON, 'function', 'has method' );
 	t.end();
 });
 
@@ -181,7 +181,7 @@ tape( 'the generator supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( mt19937(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( mt19937(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -208,7 +208,7 @@ tape( 'the generator supports setting the generator state (normalized)', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( mt19937.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( mt19937.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -235,7 +235,7 @@ tape( 'the generator supports setting the generator state (normalized)', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( mt19937.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( mt19937.normalized(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/negative-binomial/test/test.factory.js b/lib/node_modules/@stdlib/random/base/negative-binomial/test/test.factory.js
index 5c23ba09bb5a..ba737a277cc2 100644
--- a/lib/node_modules/@stdlib/random/base/negative-binomial/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/negative-binomial/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -539,14 +540,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	negativeBinomial = factory( 80, 0.05 );
 	for ( i = 0; i < 100; i++ ) {
 		r = negativeBinomial();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	negativeBinomial = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = negativeBinomial( 120, 0.75 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -574,7 +575,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = negativeBinomial1();
 		r2 = negativeBinomial2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -601,25 +602,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = negativeBinomial1();
 		r2 = negativeBinomial2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var negativeBinomial = factory();
-	t.equal( negativeBinomial.NAME, 'negative-binomial', 'has property' );
+	t.strictEqual( negativeBinomial.NAME, 'negative-binomial', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var negativeBinomial = factory();
-	t.equal( typeof negativeBinomial.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof negativeBinomial.PRNG, 'function', 'has property' );
 
 	negativeBinomial = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( negativeBinomial.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( negativeBinomial.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -627,14 +628,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var negativeBinomial = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( negativeBinomial.seed ), true, 'has property' );
-	t.equal( negativeBinomial.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( negativeBinomial.seed ), true, 'has property' );
+	t.strictEqual( negativeBinomial.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	negativeBinomial = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( negativeBinomial.seed, null, 'equal to `null`' );
+	t.strictEqual( negativeBinomial.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -650,54 +651,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var negativeBinomial = factory();
-	t.equal( typeof negativeBinomial.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof negativeBinomial.seedLength, 'number', 'has property' );
 
 	negativeBinomial = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( negativeBinomial.seedLength, null, 'equal to `null`' );
+	t.strictEqual( negativeBinomial.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the return function is the generator state', function test( t ) {
 	var negativeBinomial = factory();
-	t.equal( isUint32Array( negativeBinomial.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( negativeBinomial.state ), true, 'has property' );
 
 	negativeBinomial = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( negativeBinomial.state, null, 'equal to `null`' );
+	t.strictEqual( negativeBinomial.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var negativeBinomial = factory();
-	t.equal( typeof negativeBinomial.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof negativeBinomial.stateLength, 'number', 'has property' );
 
 	negativeBinomial = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( negativeBinomial.stateLength, null, 'equal to `null`' );
+	t.strictEqual( negativeBinomial.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var negativeBinomial = factory();
-	t.equal( typeof negativeBinomial.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof negativeBinomial.byteLength, 'number', 'has property' );
 
 	negativeBinomial = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( negativeBinomial.byteLength, null, 'equal to `null`' );
+	t.strictEqual( negativeBinomial.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -706,11 +707,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	negativeBinomial = factory();
-	t.equal( typeof negativeBinomial.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof negativeBinomial.toJSON, 'function', 'has method' );
 
 	o = negativeBinomial.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, negativeBinomial.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, negativeBinomial.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( negativeBinomial.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -722,8 +723,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	negativeBinomial = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof negativeBinomial.toJSON, 'function', 'has method' );
-	t.equal( negativeBinomial.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof negativeBinomial.toJSON, 'function', 'has method' );
+	t.strictEqual( negativeBinomial.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -851,7 +852,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = negativeBinomial();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -867,7 +868,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = negativeBinomial( 40, 0.8 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -902,7 +903,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = negativeBinomial1();
 		r2 = negativeBinomial2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -937,7 +938,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = negativeBinomial1( 40, 0.8 );
 		r2 = negativeBinomial2( 40, 0.8 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -958,7 +959,7 @@ tape( 'the function returns a PRNG for generating random numbers from a negative
 	r = 40;
 	p = 0.80;
 
-	freq = new Array( 40 );
+	freq = zeros( 40 );
 	repeats = 100;
 	N = 1e3;
 
@@ -994,7 +995,7 @@ tape( 'the function returns a PRNG for generating random numbers from a negative
 				'simulate': true,
 				'iterations': 500
 			}).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -1053,7 +1054,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( negativeBinomial(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( negativeBinomial(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1103,8 +1104,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1( 40, 0.8 );
 		v2 = rand2( 40, 0.8 );
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1121,8 +1122,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1( 40, 0.8 );
 		v2 = rand2( 40, 0.8 );
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1173,8 +1174,8 @@ tape( 'the function supports specifying a shared generator state (other argument
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1191,8 +1192,8 @@ tape( 'the function supports specifying a shared generator state (other argument
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1223,7 +1224,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( negativeBinomial(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( negativeBinomial(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/negative-binomial/test/test.js b/lib/node_modules/@stdlib/random/base/negative-binomial/test/test.js
index 3e70426fcd41..f1d0b18d2a01 100644
--- a/lib/node_modules/@stdlib/random/base/negative-binomial/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/negative-binomial/test/test.js
@@ -37,47 +37,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof negativeBinomial.factory, 'function', 'has method' );
+	t.strictEqual( typeof negativeBinomial.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof negativeBinomial.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof negativeBinomial.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof negativeBinomial.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof negativeBinomial.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( negativeBinomial.NAME, 'negative-binomial', 'has property' );
+	t.strictEqual( negativeBinomial.NAME, 'negative-binomial', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( negativeBinomial.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( negativeBinomial.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof negativeBinomial.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof negativeBinomial.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( negativeBinomial.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( negativeBinomial.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof negativeBinomial.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof negativeBinomial.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof negativeBinomial.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof negativeBinomial.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -122,7 +122,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( negativeBinomial( 100, 0.75 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( negativeBinomial( 100, 0.75 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/normal/test/test.factory.js b/lib/node_modules/@stdlib/random/base/normal/test/test.factory.js
index c21b02ec3bc2..62ed5d41e3be 100644
--- a/lib/node_modules/@stdlib/random/base/normal/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/normal/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -372,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	normal = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = normal();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	normal = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = normal( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -407,7 +408,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = normal1();
 		r2 = normal2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -434,25 +435,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = normal1();
 		r2 = normal2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var normal = factory();
-	t.equal( normal.NAME, 'normal', 'has property' );
+	t.strictEqual( normal.NAME, 'normal', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var normal = factory();
-	t.equal( typeof normal.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof normal.PRNG, 'function', 'has property' );
 
 	normal = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( normal.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( normal.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -460,14 +461,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var normal = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( normal.seed ), true, 'has property' );
-	t.equal( normal.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( normal.seed ), true, 'has property' );
+	t.strictEqual( normal.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	normal = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( normal.seed, null, 'equal to `null`' );
+	t.strictEqual( normal.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -483,54 +484,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var normal = factory();
-	t.equal( typeof normal.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof normal.seedLength, 'number', 'has property' );
 
 	normal = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( normal.seedLength, null, 'equal to `null`' );
+	t.strictEqual( normal.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var normal = factory();
-	t.equal( isUint32Array( normal.state ), true, 'has `state` property' );
+	t.strictEqual( isUint32Array( normal.state ), true, 'has `state` property' );
 
 	normal = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( normal.state, null, 'equal to `null`' );
+	t.strictEqual( normal.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var normal = factory();
-	t.equal( typeof normal.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof normal.stateLength, 'number', 'has property' );
 
 	normal = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( normal.stateLength, null, 'equal to `null`' );
+	t.strictEqual( normal.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var normal = factory();
-	t.equal( typeof normal.byteLength, 'number', 'has `byteLength` property' );
+	t.strictEqual( typeof normal.byteLength, 'number', 'has `byteLength` property' );
 
 	normal = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( normal.byteLength, null, 'equal to `null`' );
+	t.strictEqual( normal.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -539,11 +540,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	normal = factory();
-	t.equal( typeof normal.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof normal.toJSON, 'function', 'has method' );
 
 	o = normal.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, normal.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, normal.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( normal.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -555,13 +556,13 @@ tape( 'attached to the returned function is a method to serialize the generator
 	normal = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof normal.toJSON, 'function', 'has method' );
-	t.equal( normal.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof normal.toJSON, 'function', 'has method' );
+	t.strictEqual( normal.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a first argument.strictEqual to `NaN`', function test( t ) {
 	var normal;
 	var r;
 
@@ -572,7 +573,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	t.end();
 });
 
-tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument equal to `NaN`', function test( t ) {
+tape( 'when called without arguments, the function returns a PRNG that returns `NaN` when provided a second argument.strictEqual to `NaN`', function test( t ) {
 	var normal;
 	var r;
 
@@ -620,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = normal();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -636,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = normal( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -671,7 +672,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = normal1();
 		r2 = normal2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -706,7 +707,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = normal1( 1.0, 2.0 );
 		r2 = normal2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -725,7 +726,7 @@ tape( 'the function returns a PRNG for generating pseudorandom numbers from a no
 	mu = 2.0;
 	sigma = 4.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -751,7 +752,7 @@ tape( 'the function returns a PRNG for generating pseudorandom numbers from a no
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'normal', mu, sigma ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue <= 0.05 ) {
 				rejected += 1;
 			}
@@ -810,7 +811,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( normal(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( normal(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -860,8 +861,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -878,8 +879,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -910,7 +911,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( normal(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( normal(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/normal/test/test.js b/lib/node_modules/@stdlib/random/base/normal/test/test.js
index 39ffac6f66bd..53f4d0298095 100644
--- a/lib/node_modules/@stdlib/random/base/normal/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/normal/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof normal.factory, 'function', 'has method' );
+	t.strictEqual( typeof normal.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof normal.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof normal.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( normal.NAME, 'normal', 'has property' );
+	t.strictEqual( normal.NAME, 'normal', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof normal.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof normal.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( normal.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( normal.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof normal.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof normal.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( normal.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( normal.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof normal.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof normal.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof normal.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof normal.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = normal( 2.0, 1.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( normal( 2.0, 5.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( normal( 2.0, 5.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.factory.js b/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.factory.js
index 13da400b48d9..0b7288533f26 100644
--- a/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -374,14 +375,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	pareto1 = factory( 2.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = pareto1();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	pareto1 = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = pareto1( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -409,7 +410,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = pareto1a();
 		r2 = pareto1b();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -436,25 +437,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = pareto1a();
 		r2 = pareto1b();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var pareto1 = factory();
-	t.equal( pareto1.NAME, 'pareto-type1', 'has property' );
+	t.strictEqual( pareto1.NAME, 'pareto-type1', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var pareto1 = factory();
-	t.equal( typeof pareto1.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof pareto1.PRNG, 'function', 'has property' );
 
 	pareto1 = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( pareto1.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( pareto1.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -462,14 +463,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var pareto1 = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( pareto1.seed ), true, 'has property' );
-	t.equal( pareto1.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( pareto1.seed ), true, 'has property' );
+	t.strictEqual( pareto1.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	pareto1 = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( pareto1.seed, null, 'equal to `null`' );
+	t.strictEqual( pareto1.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -485,54 +486,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var pareto1 = factory();
-	t.equal( typeof pareto1.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof pareto1.seedLength, 'number', 'has property' );
 
 	pareto1 = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( pareto1.seedLength, null, 'equal to `null`' );
+	t.strictEqual( pareto1.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var pareto1 = factory();
-	t.equal( isUint32Array( pareto1.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( pareto1.state ), true, 'has property' );
 
 	pareto1 = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( pareto1.state, null, 'equal to `null`' );
+	t.strictEqual( pareto1.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var pareto1 = factory();
-	t.equal( typeof pareto1.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof pareto1.stateLength, 'number', 'has property' );
 
 	pareto1 = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( pareto1.stateLength, null, 'equal to `null`' );
+	t.strictEqual( pareto1.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var pareto1 = factory();
-	t.equal( typeof pareto1.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof pareto1.byteLength, 'number', 'has property' );
 
 	pareto1 = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( pareto1.byteLength, null, 'equal to `null`' );
+	t.strictEqual( pareto1.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -541,11 +542,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	pareto1 = factory();
-	t.equal( typeof pareto1.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof pareto1.toJSON, 'function', 'has method' );
 
 	o = pareto1.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, pareto1.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, pareto1.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( pareto1.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -557,8 +558,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	pareto1 = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof pareto1.toJSON, 'function', 'has method' );
-	t.equal( pareto1.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof pareto1.toJSON, 'function', 'has method' );
+	t.strictEqual( pareto1.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -637,7 +638,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = pareto1();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -653,7 +654,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = pareto1( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -688,7 +689,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = pareto1a();
 		r2 = pareto1b();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -723,7 +724,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = pareto1a( 1.0, 2.0 );
 		r2 = pareto1b( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -742,7 +743,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Pareto (
 	alpha = 3.14;
 	beta = 1.2;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -768,7 +769,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Pareto (
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'pareto-type1', alpha, beta ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -827,7 +828,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( pareto1(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( pareto1(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -877,8 +878,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -895,8 +896,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -927,7 +928,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( pareto1(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( pareto1(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.js b/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.js
index 0031ce8deb4f..5ffa818c7115 100644
--- a/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof pareto1.factory, 'function', 'has method' );
+	t.strictEqual( typeof pareto1.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof pareto1.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof pareto1.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( pareto1.NAME, 'pareto-type1', 'has property' );
+	t.strictEqual( pareto1.NAME, 'pareto-type1', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof pareto1.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof pareto1.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( pareto1.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( pareto1.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof pareto1.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof pareto1.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( pareto1.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( pareto1.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof pareto1.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof pareto1.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof pareto1.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof pareto1.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( pareto1( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( pareto1( 2.0, 1.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/poisson/test/test.factory.js b/lib/node_modules/@stdlib/random/base/poisson/test/test.factory.js
index e86736f5bfcf..539bd3f7fb7e 100644
--- a/lib/node_modules/@stdlib/random/base/poisson/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/poisson/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -371,14 +372,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	poisson = factory( 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = poisson();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	poisson = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = poisson( 100.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -406,7 +407,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = poisson1();
 		r2 = poisson2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -433,25 +434,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = poisson1();
 		r2 = poisson2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var poisson = factory();
-	t.equal( poisson.NAME, 'poisson', 'has property' );
+	t.strictEqual( poisson.NAME, 'poisson', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var poisson = factory();
-	t.equal( typeof poisson.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof poisson.PRNG, 'function', 'has property' );
 
 	poisson = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( poisson.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( poisson.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -459,14 +460,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var poisson = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( poisson.seed ), true, 'has property' );
-	t.equal( poisson.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( poisson.seed ), true, 'has property' );
+	t.strictEqual( poisson.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	poisson = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( poisson.seed, null, 'equal to `null`' );
+	t.strictEqual( poisson.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -482,54 +483,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var poisson = factory();
-	t.equal( typeof poisson.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof poisson.seedLength, 'number', 'has property' );
 
 	poisson = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( poisson.seedLength, null, 'equal to `null`' );
+	t.strictEqual( poisson.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var poisson = factory();
-	t.equal( isUint32Array( poisson.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( poisson.state ), true, 'has property' );
 
 	poisson = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( poisson.state, null, 'equal to `null`' );
+	t.strictEqual( poisson.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var poisson = factory();
-	t.equal( typeof poisson.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof poisson.stateLength, 'number', 'has property' );
 
 	poisson = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( poisson.stateLength, null, 'equal to `null`' );
+	t.strictEqual( poisson.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var poisson = factory();
-	t.equal( typeof poisson.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof poisson.byteLength, 'number', 'has property' );
 
 	poisson = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( poisson.byteLength, null, 'equal to `null`' );
+	t.strictEqual( poisson.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -538,11 +539,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	poisson = factory();
-	t.equal( typeof poisson.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof poisson.toJSON, 'function', 'has method' );
 
 	o = poisson.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, poisson.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, poisson.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( poisson.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -554,8 +555,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	poisson = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof poisson.toJSON, 'function', 'has method' );
-	t.equal( poisson.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof poisson.toJSON, 'function', 'has method' );
+	t.strictEqual( poisson.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -600,7 +601,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = poisson();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -616,7 +617,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = poisson( 10.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -651,7 +652,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = poisson1();
 		r2 = poisson2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -686,7 +687,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = poisson1( 10.0 );
 		r2 = poisson2( 10.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -705,7 +706,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Poisson
 
 	lambda = 0.73;
 
-	freq = new Array( 30 );
+	freq = zeros( 30 );
 	repeats = 200;
 	N = 1e3;
 
@@ -741,7 +742,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Poisson
 				'simulate': true,
 				'iterations': 500
 			}).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -786,7 +787,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Poisson
 
 	lambda = 35.7;
 
-	freq = new Array( 300 );
+	freq = zeros( 300 );
 	repeats = 100;
 	N = 1e3;
 
@@ -822,7 +823,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Poisson
 				'simulate': true,
 				'iterations': 500
 			}).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -881,7 +882,7 @@ tape( 'the function supports specifying the generator state (lambda < 30)', func
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( poisson(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( poisson(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -914,7 +915,7 @@ tape( 'the function supports specifying the generator state (lambda > 30)', func
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( poisson(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( poisson(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -964,8 +965,8 @@ tape( 'the function supports specifying a shared generator state (lambda < 30)',
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -982,8 +983,8 @@ tape( 'the function supports specifying a shared generator state (lambda < 30)',
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1034,8 +1035,8 @@ tape( 'the function supports specifying a shared generator state (lambda > 30)',
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1052,8 +1053,8 @@ tape( 'the function supports specifying a shared generator state (lambda > 30)',
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1084,7 +1085,7 @@ tape( 'the returned function supports setting the generator state (lambda < 30)'
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( poisson(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( poisson(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1114,7 +1115,7 @@ tape( 'the returned function supports setting the generator state (lambda > 30)'
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( poisson(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( poisson(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/poisson/test/test.js b/lib/node_modules/@stdlib/random/base/poisson/test/test.js
index e2be5c4e8155..d9be26a9c148 100644
--- a/lib/node_modules/@stdlib/random/base/poisson/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/poisson/test/test.js
@@ -36,47 +36,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof poisson.factory, 'function', 'has method' );
+	t.strictEqual( typeof poisson.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof poisson.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof poisson.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( poisson.NAME, 'poisson', 'has property' );
+	t.strictEqual( poisson.NAME, 'poisson', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof poisson.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof poisson.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( poisson.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( poisson.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof poisson.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof poisson.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( poisson.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( poisson.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof poisson.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof poisson.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof poisson.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof poisson.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -115,7 +115,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( poisson( 10.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( poisson( 10.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/randi/test/test.factory.js b/lib/node_modules/@stdlib/random/base/randi/test/test.factory.js
index e030791bfc57..41d042030202 100644
--- a/lib/node_modules/@stdlib/random/base/randi/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/randi/test/test.factory.js
@@ -195,9 +195,9 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	randi = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randi();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( isInteger( v ), true, 'returns an integer' );
-		t.equal( v >= randi.MIN && v <= randi.MAX, true, 'returns a number between MIN (inclusive) and MAX (inclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( isInteger( v ), true, 'returns an integer' );
+		t.strictEqual( v >= randi.MIN && v <= randi.MAX, true, 'returns a number between MIN (inclusive) and MAX (inclusive)' );
 	}
 	t.end();
 });
@@ -224,7 +224,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 1e2; i++ ) {
 		v1 = randi1();
 		v2 = randi2();
-		t.equal( v1, v2, 'both return same number' );
+		t.strictEqual( v1, v2, 'both return same number' );
 	}
 	t.end();
 });
@@ -251,34 +251,34 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 1e2; i++ ) {
 		v1 = randi1();
 		v2 = randi2();
-		t.equal( v1, v2, 'both return same number' );
+		t.strictEqual( v1, v2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var randi = factory();
-	t.equal( randi.NAME, 'randi', 'has property' );
+	t.strictEqual( randi.NAME, 'randi', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the minimum possible generated number', function test( t ) {
 	var randi = factory();
-	t.equal( typeof randi.MIN, 'number', 'has property' );
-	t.equal( isInteger( randi.MIN ), true, 'is an integer' );
+	t.strictEqual( typeof randi.MIN, 'number', 'has property' );
+	t.strictEqual( isInteger( randi.MIN ), true, 'is an integer' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the maximum possible generated number', function test( t ) {
 	var randi = factory();
-	t.equal( typeof randi.MAX, 'number', 'has property' );
-	t.equal( isInteger( randi.MAX ), true, 'is an integer' );
+	t.strictEqual( typeof randi.MAX, 'number', 'has property' );
+	t.strictEqual( isInteger( randi.MAX ), true, 'is an integer' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var randi = factory();
-	t.equal( typeof randi.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof randi.PRNG, 'function', 'has property' );
 	t.end();
 });
 
@@ -286,8 +286,8 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var randi = factory({
 		'seed': 12345
 	});
-	t.equal( isArrayLikeObject( randi.seed ), true, 'has property' );
-	t.equal( randi.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isArrayLikeObject( randi.seed ), true, 'has property' );
+	t.strictEqual( randi.seed[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -303,34 +303,34 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isArrayLikeObject( actual ), true, 'has property' );
+	t.strictEqual( isArrayLikeObject( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var randi = factory();
-	t.equal( typeof randi.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof randi.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var randi = factory();
-	t.equal( isArrayLikeObject( randi.state ), true, 'has property' );
+	t.strictEqual( isArrayLikeObject( randi.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var randi = factory();
-	t.equal( typeof randi.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof randi.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var randi = factory();
-	t.equal( typeof randi.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof randi.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -339,11 +339,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	randi = factory();
-	t.equal( typeof randi.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof randi.toJSON, 'function', 'has method' );
 
 	o = randi.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, randi.NAME + '-' + randi.PRNG.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, randi.NAME + '-' + randi.PRNG.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( randi.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -359,11 +359,11 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 		'name': 'minstd'
 	});
 
-	t.equal( randi.PRNG.NAME, 'minstd', 'expected `PRNG` value' );
+	t.strictEqual( randi.PRNG.NAME, 'minstd', 'expected `PRNG` value' );
 
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randi();
-		t.equal( v >= randi.MIN && v <= randi.MAX, true, 'returns a number between MIN (inclusive) and MAX (inclusive)' );
+		t.strictEqual( v >= randi.MIN && v <= randi.MAX, true, 'returns a number between MIN (inclusive) and MAX (inclusive)' );
 	}
 	t.end();
 });
@@ -396,7 +396,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randi(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randi(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -450,8 +450,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -468,8 +468,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -500,7 +500,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randi(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randi(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/randi/test/test.js b/lib/node_modules/@stdlib/random/base/randi/test/test.js
index 2d8425567a4f..c7772a8b4ee9 100644
--- a/lib/node_modules/@stdlib/random/base/randi/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/randi/test/test.js
@@ -35,59 +35,59 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof randi.factory, 'function', 'has method' );
+	t.strictEqual( typeof randi.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof randi.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof randi.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( randi.NAME, 'randi', 'has property' );
+	t.strictEqual( randi.NAME, 'randi', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof randi.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof randi.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the minimum possible generated number', function test( t ) {
-	t.equal( typeof randi.MIN, 'number', 'has property' );
-	t.equal( isInteger( randi.MIN ), true, 'is an integer' );
+	t.strictEqual( typeof randi.MIN, 'number', 'has property' );
+	t.strictEqual( isInteger( randi.MIN ), true, 'is an integer' );
 	t.end();
 });
 
 tape( 'attached to the main export is the maximum possible generated number', function test( t ) {
-	t.equal( typeof randi.MAX, 'number', 'has property' );
-	t.equal( isInteger( randi.MAX ), true, 'is an integer' );
+	t.strictEqual( typeof randi.MAX, 'number', 'has property' );
+	t.strictEqual( isInteger( randi.MAX ), true, 'is an integer' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isArrayLikeObject( randi.seed ), true, 'has property' );
+	t.strictEqual( isArrayLikeObject( randi.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof randi.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof randi.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isArrayLikeObject( randi.state ), true, 'has property' );
+	t.strictEqual( isArrayLikeObject( randi.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof randi.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof randi.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof randi.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof randi.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -96,9 +96,9 @@ tape( 'the function returns pseudorandom numbers between a minimum (inclusive) a
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randi();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( isInteger( v ), true, 'returns an integer' );
-		t.equal( v >= randi.MIN && v <= randi.MAX, true, 'returns a number between MIN (inclusive) and MAX (inclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( isInteger( v ), true, 'returns an integer' );
+		t.strictEqual( v >= randi.MIN && v <= randi.MAX, true, 'returns a number between MIN (inclusive) and MAX (inclusive)' );
 	}
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randi(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randi(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/randn/test/test.factory.js b/lib/node_modules/@stdlib/random/base/randn/test/test.factory.js
index 90454fc1199e..69b4e0fd3a52 100644
--- a/lib/node_modules/@stdlib/random/base/randn/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/randn/test/test.factory.js
@@ -28,6 +28,7 @@ var isArrayLikeObject = require( '@stdlib/assert/is-array-like-object' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -234,7 +235,7 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	randn = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randn();
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -261,7 +262,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 1e2; i++ ) {
 		v1 = randn1();
 		v2 = randn2();
-		t.equal( v1, v2, 'both return same number' );
+		t.strictEqual( v1, v2, 'both return same number' );
 	}
 	t.end();
 });
@@ -288,25 +289,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 1e2; i++ ) {
 		v1 = randn1();
 		v2 = randn2();
-		t.equal( v1, v2, 'both return same number' );
+		t.strictEqual( v1, v2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var randn = factory();
-	t.equal( randn.NAME, 'randn', 'has property' );
+	t.strictEqual( randn.NAME, 'randn', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var randn = factory();
-	t.equal( typeof randn.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof randn.PRNG, 'function', 'has property' );
 
 	randn = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( randn.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( randn.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -314,14 +315,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var randn = factory({
 		'seed': 12345
 	});
-	t.equal( isArrayLikeObject( randn.seed ), true, 'has property' );
-	t.equal( randn.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isArrayLikeObject( randn.seed ), true, 'has property' );
+	t.strictEqual( randn.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	randn = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( randn.seed, null, 'equal to `null`' );
+	t.strictEqual( randn.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -337,54 +338,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isArrayLikeObject( actual ), true, 'has property' );
+	t.strictEqual( isArrayLikeObject( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var randn = factory();
-	t.equal( typeof randn.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.seedLength, 'number', 'has property' );
 
 	randn = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( randn.seedLength, null, 'equal to `null`' );
+	t.strictEqual( randn.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var randn = factory();
-	t.equal( isArrayLikeObject( randn.state ), true, 'has property' );
+	t.strictEqual( isArrayLikeObject( randn.state ), true, 'has property' );
 
 	randn = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( randn.state, null, 'equal to `null`' );
+	t.strictEqual( randn.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var randn = factory();
-	t.equal( typeof randn.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.stateLength, 'number', 'has property' );
 
 	randn = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( randn.stateLength, null, 'equal to `null`' );
+	t.strictEqual( randn.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var randn = factory();
-	t.equal( typeof randn.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.byteLength, 'number', 'has property' );
 
 	randn = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( randn.byteLength, null, 'equal to `null`' );
+	t.strictEqual( randn.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -395,19 +396,19 @@ tape( 'attached to the returned function is a method to serialize the generator
 	randn = factory({
 		'name': 'improved-ziggurat'
 	});
-	t.equal( typeof randn.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof randn.toJSON, 'function', 'has method' );
 
 	o = randn.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, randn.NAME + '-improved-ziggurat', 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, randn.NAME + '-improved-ziggurat', 'has property' );
 	t.deepEqual( o.state, typedarray2json( randn.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
 	randn = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof randn.toJSON, 'function', 'has method' );
-	t.equal( randn.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof randn.toJSON, 'function', 'has method' );
+	t.strictEqual( randn.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -423,7 +424,7 @@ tape( 'the function supports specifying the PRNG name', function test( t ) {
 
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randn();
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -439,7 +440,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = randn();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -474,7 +475,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = randn1();
 		r2 = randn2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -488,7 +489,7 @@ tape( 'the function returns a PRNG for generating pseudorandom numbers from a st
 
 	threshold = 0.10;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -514,7 +515,7 @@ tape( 'the function returns a PRNG for generating pseudorandom numbers from a st
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'normal', 0.0, 1.0 ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue <= 0.05 ) {
 				rejected += 1;
 			}
@@ -573,7 +574,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -627,8 +628,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -645,8 +646,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -677,7 +678,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/randn/test/test.js b/lib/node_modules/@stdlib/random/base/randn/test/test.js
index e02365de4c5d..200b9052a9c9 100644
--- a/lib/node_modules/@stdlib/random/base/randn/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/randn/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof randn.factory, 'function', 'has method' );
+	t.strictEqual( typeof randn.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( randn.NAME, 'randn', 'has property' );
+	t.strictEqual( randn.NAME, 'randn', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof randn.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof randn.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isArrayLikeObject( randn.seed ), true, 'has property' );
+	t.strictEqual( isArrayLikeObject( randn.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof randn.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isArrayLikeObject( randn.state ), true, 'has property' );
+	t.strictEqual( isArrayLikeObject( randn.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof randn.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof randn.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof randn.byteLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof randn.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof randn.toJSON, 'function', 'has method' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns standard normally distributed pseudorandom numbers',
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randn();
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randn(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/randu/test/test.factory.js b/lib/node_modules/@stdlib/random/base/randu/test/test.factory.js
index 59f5f86a5132..cd9b520bf062 100644
--- a/lib/node_modules/@stdlib/random/base/randu/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/randu/test/test.factory.js
@@ -27,6 +27,7 @@ var kstest = require( '@stdlib/stats/kstest' );
 var isArrayLikeObject = require( '@stdlib/assert/is-array-like-object' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -203,8 +204,8 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	randu = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randu();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
 });
@@ -231,7 +232,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 1e2; i++ ) {
 		v1 = randu1();
 		v2 = randu2();
-		t.equal( v1, v2, 'both return same number' );
+		t.strictEqual( v1, v2, 'both return same number' );
 	}
 	t.end();
 });
@@ -258,33 +259,33 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 1e2; i++ ) {
 		v1 = randu1();
 		v2 = randu2();
-		t.equal( v1, v2, 'both return same number' );
+		t.strictEqual( v1, v2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var randu = factory();
-	t.equal( randu.NAME, 'randu', 'has property' );
+	t.strictEqual( randu.NAME, 'randu', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the minimum possible generated number', function test( t ) {
 	var randu = factory();
-	t.equal( typeof randu.MIN, 'number', 'has property' );
-	t.equal( randu.MIN, 0.0, 'equals 0.0' );
+	t.strictEqual( typeof randu.MIN, 'number', 'has property' );
+	t.strictEqual( randu.MIN, 0.0, 'equals 0.0' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the maximum possible generated number', function test( t ) {
 	var randu = factory();
-	t.equal( typeof randu.MAX, 'number', 'has property' );
+	t.strictEqual( typeof randu.MAX, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var randu = factory();
-	t.equal( typeof randu.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof randu.PRNG, 'function', 'has property' );
 	t.end();
 });
 
@@ -292,8 +293,8 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var randu = factory({
 		'seed': 12345
 	});
-	t.equal( isArrayLikeObject( randu.seed ), true, 'has property' );
-	t.equal( randu.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isArrayLikeObject( randu.seed ), true, 'has property' );
+	t.strictEqual( randu.seed[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -309,34 +310,34 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isArrayLikeObject( actual ), true, 'has property' );
+	t.strictEqual( isArrayLikeObject( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var randu = factory();
-	t.equal( typeof randu.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof randu.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var randu = factory();
-	t.equal( isArrayLikeObject( randu.state ), true, 'has property' );
+	t.strictEqual( isArrayLikeObject( randu.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var randu = factory();
-	t.equal( typeof randu.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof randu.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var randu = factory();
-	t.equal( typeof randu.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof randu.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -345,11 +346,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	randu = factory();
-	t.equal( typeof randu.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof randu.toJSON, 'function', 'has method' );
 
 	o = randu.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, randu.NAME+'-'+randu.PRNG.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, randu.NAME+'-'+randu.PRNG.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( randu.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -365,11 +366,11 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 		'name': 'minstd'
 	});
 
-	t.equal( randu.PRNG.NAME, 'minstd', 'expected `PRNG` value' );
+	t.strictEqual( randu.PRNG.NAME, 'minstd', 'expected `PRNG` value' );
 
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randu();
-		t.equal( v >= 0.0 && v < 1, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
+		t.strictEqual( v >= 0.0 && v < 1, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
 });
@@ -383,7 +384,7 @@ tape( 'the function returns a PRNG for generating pseudorandom numbers from a un
 
 	threshold = 0.10;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 500;
 
 	count = -1;
@@ -412,7 +413,7 @@ tape( 'the function returns a PRNG for generating pseudorandom numbers from a un
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'uniform', 0.0, 1.0 ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -471,7 +472,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randu(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randu(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -525,8 +526,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -543,8 +544,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -575,7 +576,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randu(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randu(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/randu/test/test.js b/lib/node_modules/@stdlib/random/base/randu/test/test.js
index 87ef36d1ff5b..2e6da00c6241 100644
--- a/lib/node_modules/@stdlib/random/base/randu/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/randu/test/test.js
@@ -34,58 +34,58 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof randu.factory, 'function', 'has method' );
+	t.strictEqual( typeof randu.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof randu.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof randu.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( randu.NAME, 'randu', 'has property' );
+	t.strictEqual( randu.NAME, 'randu', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the minimum possible generated number', function test( t ) {
-	t.equal( typeof randu.MIN, 'number', 'has property' );
-	t.equal( randu.MIN, 0.0, 'equals 0.0' );
+	t.strictEqual( typeof randu.MIN, 'number', 'has property' );
+	t.strictEqual( randu.MIN, 0.0, 'equals 0.0' );
 	t.end();
 });
 
 tape( 'attached to the main export is the maximum possible generated number', function test( t ) {
-	t.equal( typeof randu.MAX, 'number', 'has property' );
+	t.strictEqual( typeof randu.MAX, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof randu.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof randu.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isArrayLikeObject( randu.seed ), true, 'has property' );
+	t.strictEqual( isArrayLikeObject( randu.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof randu.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof randu.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isArrayLikeObject( randu.state ), true, 'has property' );
+	t.strictEqual( isArrayLikeObject( randu.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof randu.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof randu.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof randu.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof randu.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -94,8 +94,8 @@ tape( 'the function returns pseudorandom numbers between 0 (inclusive) and 1 (ex
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randu();
-		t.equal( typeof v, 'number', 'returns a number' );
-		t.equal( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( randu(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( randu(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/rayleigh/test/test.factory.js b/lib/node_modules/@stdlib/random/base/rayleigh/test/test.factory.js
index aa70f3f5d13e..aeae7af3db25 100644
--- a/lib/node_modules/@stdlib/random/base/rayleigh/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/rayleigh/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -372,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	rayleigh = factory( 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = rayleigh();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameter...
 	rayleigh = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = rayleigh( 10.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -407,7 +408,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = rayleigh1();
 		r2 = rayleigh2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -434,25 +435,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = rayleigh1();
 		r2 = rayleigh2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var rayleigh = factory();
-	t.equal( rayleigh.NAME, 'rayleigh', 'has property' );
+	t.strictEqual( rayleigh.NAME, 'rayleigh', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var rayleigh = factory();
-	t.equal( typeof rayleigh.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof rayleigh.PRNG, 'function', 'has property' );
 
 	rayleigh = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( rayleigh.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( rayleigh.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -460,14 +461,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var rayleigh = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( rayleigh.seed ), true, 'has property' );
-	t.equal( rayleigh.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( rayleigh.seed ), true, 'has property' );
+	t.strictEqual( rayleigh.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	rayleigh = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( rayleigh.seed, null, 'equal to `null`' );
+	t.strictEqual( rayleigh.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -483,54 +484,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var rayleigh = factory();
-	t.equal( typeof rayleigh.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof rayleigh.seedLength, 'number', 'has property' );
 
 	rayleigh = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( rayleigh.seedLength, null, 'equal to `null`' );
+	t.strictEqual( rayleigh.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var rayleigh = factory();
-	t.equal( isUint32Array( rayleigh.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( rayleigh.state ), true, 'has property' );
 
 	rayleigh = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( rayleigh.state, null, 'equal to `null`' );
+	t.strictEqual( rayleigh.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var rayleigh = factory();
-	t.equal( typeof rayleigh.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof rayleigh.stateLength, 'number', 'has property' );
 
 	rayleigh = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( rayleigh.stateLength, null, 'equal to `null`' );
+	t.strictEqual( rayleigh.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var rayleigh = factory();
-	t.equal( typeof rayleigh.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof rayleigh.byteLength, 'number', 'has property' );
 
 	rayleigh = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( rayleigh.byteLength, null, 'equal to `null`' );
+	t.strictEqual( rayleigh.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -539,11 +540,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	rayleigh = factory();
-	t.equal( typeof rayleigh.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof rayleigh.toJSON, 'function', 'has method' );
 
 	o = rayleigh.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, rayleigh.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, rayleigh.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( rayleigh.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -555,8 +556,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	rayleigh = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof rayleigh.toJSON, 'function', 'has method' );
-	t.equal( rayleigh.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof rayleigh.toJSON, 'function', 'has method' );
+	t.strictEqual( rayleigh.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -601,7 +602,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rayleigh();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -617,7 +618,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rayleigh( 10.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -652,7 +653,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = rayleigh1();
 		r2 = rayleigh2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -687,7 +688,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = rayleigh1( 10.0 );
 		r2 = rayleigh2( 10.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -704,7 +705,7 @@ tape( 'the function returns a PRNG for generating random numbers from an Rayleig
 
 	sigma = 4.25;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -730,7 +731,7 @@ tape( 'the function returns a PRNG for generating random numbers from an Rayleig
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'rayleigh', sigma ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -789,7 +790,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( rayleigh(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( rayleigh(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -839,8 +840,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -857,8 +858,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -889,7 +890,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( rayleigh(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( rayleigh(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/rayleigh/test/test.js b/lib/node_modules/@stdlib/random/base/rayleigh/test/test.js
index d557d7049c54..c553f660d685 100644
--- a/lib/node_modules/@stdlib/random/base/rayleigh/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/rayleigh/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof rayleigh.factory, 'function', 'has method' );
+	t.strictEqual( typeof rayleigh.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof rayleigh.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof rayleigh.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( rayleigh.NAME, 'rayleigh', 'has property' );
+	t.strictEqual( rayleigh.NAME, 'rayleigh', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof rayleigh.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof rayleigh.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( rayleigh.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( rayleigh.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof rayleigh.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof rayleigh.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( rayleigh.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( rayleigh.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof rayleigh.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof rayleigh.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof rayleigh.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof rayleigh.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( rayleigh( 3.14 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( rayleigh( 3.14 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/reviver/test/test.js b/lib/node_modules/@stdlib/random/base/reviver/test/test.js
index cf0ea05d8ef4..710ed00b8137 100644
--- a/lib/node_modules/@stdlib/random/base/reviver/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/reviver/test/test.js
@@ -66,7 +66,7 @@ tape( 'values which are not recognized as serialized PRNGs are unaffected', func
 
 	// Null edge case:
 	actual = parseJSON( 'null', reviver );
-	t.equal( actual, null, 'equals null' );
+	t.strictEqual( actual, null, 'equals null' );
 
 	t.end();
 });
@@ -238,11 +238,11 @@ tape( 'the function will revive a JSON-serialized PRNG', function test( t ) {
 		rand = values[ i ];
 		json = setup( rand.NAME, rand.state, params[ i ] );
 		r = parseJSON( JSON.stringify( json ), reviver );
-		t.equal( isPRNGLike( r ), true, 'returns a PRNG' );
+		t.strictEqual( isPRNGLike( r ), true, 'returns a PRNG' );
 		for ( j = 0; j < 10; j++ ) {
 			expected = rand();
 			actual = r();
-			t.equal( actual, expected, 'returns expected value for PRNG '+rand.NAME );
+			t.strictEqual( actual, expected, 'returns expected value for PRNG '+rand.NAME );
 		}
 	}
 	t.end();
@@ -272,11 +272,11 @@ tape( 'the function will revive deeply nested serialized error objects', functio
 	for ( i = 0; i < values.length; i++ ) {
 		rand = values[ i ];
 		r = out[ i ];
-		t.equal( isPRNGLike( r ), true, 'returns a PRNG' );
+		t.strictEqual( isPRNGLike( r ), true, 'returns a PRNG' );
 		for ( j = 0; j < 10; j++ ) {
 			expected = rand();
 			actual = r();
-			t.equal( actual, expected, 'returns expected value for PRNG '+rand.NAME );
+			t.strictEqual( actual, expected, 'returns expected value for PRNG '+rand.NAME );
 		}
 	}
 
@@ -287,13 +287,13 @@ tape( 'the function will revive deeply nested serialized error objects', functio
 	};
 
 	actual = parseJSON( JSON.stringify( json ), reviver );
-	t.equal( isPRNGLike( actual.beep.boop ), true, 'returns a PRNG' );
+	t.strictEqual( isPRNGLike( actual.beep.boop ), true, 'returns a PRNG' );
 
 	r = actual.beep.boop;
 	for ( i = 0; i < 10; i++ ) {
 		expected = randu();
 		actual = r();
-		t.equal( actual, expected, 'returns expected value' );
+		t.strictEqual( actual, expected, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/t/test/test.factory.js b/lib/node_modules/@stdlib/random/base/t/test/test.factory.js
index b65e03a8051d..c8c3a26c13e3 100644
--- a/lib/node_modules/@stdlib/random/base/t/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/t/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -513,14 +514,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	rt = factory( 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = rt();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameter...
 	rt = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = rt( 100.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -548,7 +549,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = rt1();
 		r2 = rt2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -575,25 +576,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = rt1();
 		r2 = rt2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var rt = factory();
-	t.equal( rt.NAME, 't', 'has property' );
+	t.strictEqual( rt.NAME, 't', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var rt = factory();
-	t.equal( typeof rt.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof rt.PRNG, 'function', 'has property' );
 
 	rt = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( rt.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( rt.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -601,14 +602,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var rt = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( rt.seed ), true, 'has property' );
-	t.equal( rt.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( rt.seed ), true, 'has property' );
+	t.strictEqual( rt.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	rt = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( rt.seed, null, 'equal to `null`' );
+	t.strictEqual( rt.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -624,54 +625,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var rt = factory();
-	t.equal( typeof rt.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof rt.seedLength, 'number', 'has property' );
 
 	rt = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( rt.seedLength, null, 'equal to `null`' );
+	t.strictEqual( rt.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the return function is the generator state', function test( t ) {
 	var rt = factory();
-	t.equal( isUint32Array( rt.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( rt.state ), true, 'has property' );
 
 	rt = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( rt.state, null, 'equal to `null`' );
+	t.strictEqual( rt.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var rt = factory();
-	t.equal( typeof rt.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof rt.stateLength, 'number', 'has property' );
 
 	rt = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( rt.stateLength, null, 'equal to `null`' );
+	t.strictEqual( rt.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var rt = factory();
-	t.equal( typeof rt.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof rt.byteLength, 'number', 'has property' );
 
 	rt = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( rt.byteLength, null, 'equal to `null`' );
+	t.strictEqual( rt.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -680,11 +681,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	rt = factory();
-	t.equal( typeof rt.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof rt.toJSON, 'function', 'has method' );
 
 	o = rt.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, rt.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, rt.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( rt.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -696,8 +697,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	rt = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof rt.toJSON, 'function', 'has method' );
-	t.equal( rt.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof rt.toJSON, 'function', 'has method' );
+	t.strictEqual( rt.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -797,7 +798,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rt();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -813,7 +814,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rt( 9.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -848,7 +849,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = rt1();
 		r2 = rt2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -883,7 +884,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = rt1( 9.0 );
 		r2 = rt2( 9.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -900,7 +901,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Student\
 
 	v = 9.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -926,7 +927,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Student\
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 't', v ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -985,7 +986,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( rt(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( rt(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -1035,8 +1036,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1( 10.0 );
 		v2 = rand2( 10.0 );
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1053,8 +1054,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1( 10.0 );
 		v2 = rand2( 10.0 );
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1105,8 +1106,8 @@ tape( 'the function supports specifying a shared generator state (other argument
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -1123,8 +1124,8 @@ tape( 'the function supports specifying a shared generator state (other argument
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -1155,7 +1156,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( rt(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( rt(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/t/test/test.js b/lib/node_modules/@stdlib/random/base/t/test/test.js
index 0c0109556a3c..26a12042d3a2 100644
--- a/lib/node_modules/@stdlib/random/base/t/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/t/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof rt.factory, 'function', 'has method' );
+	t.strictEqual( typeof rt.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof rt.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof rt.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( rt.NAME, 't', 'has property' );
+	t.strictEqual( rt.NAME, 't', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof rt.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof rt.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( rt.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( rt.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof rt.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof rt.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( rt.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( rt.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof rt.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof rt.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof rt.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof rt.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -110,7 +110,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( rt( 3.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( rt( 3.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/test/test.js b/lib/node_modules/@stdlib/random/base/test/test.js
index a1ae37a2254d..7cb04f6d80c1 100644
--- a/lib/node_modules/@stdlib/random/base/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains random number generators', function test( t ) {
 	var keys = objectKeys( random );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/triangular/test/test.factory.js b/lib/node_modules/@stdlib/random/base/triangular/test/test.factory.js
index b0642e53f206..5c09c8f21e5c 100644
--- a/lib/node_modules/@stdlib/random/base/triangular/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/triangular/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -420,14 +421,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	triangular = factory( -10.0, 10.0, 5.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = triangular();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	triangular = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = triangular( -10.0, 10.0, 5.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -455,7 +456,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = triangular1();
 		r2 = triangular2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -482,25 +483,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = triangular1();
 		r2 = triangular2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var triangular = factory();
-	t.equal( triangular.NAME, 'triangular', 'has property' );
+	t.strictEqual( triangular.NAME, 'triangular', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var triangular = factory();
-	t.equal( typeof triangular.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof triangular.PRNG, 'function', 'has property' );
 
 	triangular = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( triangular.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( triangular.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -508,14 +509,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var triangular = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( triangular.seed ), true, 'has property' );
-	t.equal( triangular.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( triangular.seed ), true, 'has property' );
+	t.strictEqual( triangular.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	triangular = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( triangular.seed, null, 'equal to `null`' );
+	t.strictEqual( triangular.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -531,54 +532,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var triangular = factory();
-	t.equal( typeof triangular.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof triangular.seedLength, 'number', 'has property' );
 
 	triangular = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( triangular.seedLength, null, 'equal to `null`' );
+	t.strictEqual( triangular.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var triangular = factory();
-	t.equal( isUint32Array( triangular.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( triangular.state ), true, 'has property' );
 
 	triangular = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( triangular.state, null, 'equal to `null`' );
+	t.strictEqual( triangular.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var triangular = factory();
-	t.equal( typeof triangular.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof triangular.stateLength, 'number', 'has property' );
 
 	triangular = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( triangular.stateLength, null, 'equal to `null`' );
+	t.strictEqual( triangular.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var triangular = factory();
-	t.equal( typeof triangular.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof triangular.byteLength, 'number', 'has property' );
 
 	triangular = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( triangular.byteLength, null, 'equal to `null`' );
+	t.strictEqual( triangular.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -587,11 +588,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	triangular = factory();
-	t.equal( typeof triangular.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof triangular.toJSON, 'function', 'has method' );
 
 	o = triangular.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, triangular.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, triangular.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( triangular.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -603,8 +604,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	triangular = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof triangular.toJSON, 'function', 'has method' );
-	t.equal( triangular.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof triangular.toJSON, 'function', 'has method' );
+	t.strictEqual( triangular.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -684,7 +685,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = triangular();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -700,7 +701,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = triangular( 1.0, 2.0, 1.5 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -735,7 +736,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = triangular1();
 		r2 = triangular2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -770,7 +771,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = triangular1( 1.0, 2.0, 1.5 );
 		r2 = triangular2( 1.0, 2.0, 1.5 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -791,7 +792,7 @@ tape( 'the function returns a PRNG for generating random numbers from a triangul
 	b = 4.0;
 	c = 3.33;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 500;
 
 	count = -1;
@@ -820,7 +821,7 @@ tape( 'the function returns a PRNG for generating random numbers from a triangul
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'triangular', a, b, c ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -879,7 +880,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( triangular(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( triangular(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -929,8 +930,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -947,8 +948,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -979,7 +980,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( triangular(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( triangular(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/triangular/test/test.js b/lib/node_modules/@stdlib/random/base/triangular/test/test.js
index 09de3fd1c4a0..7981243e1fe4 100644
--- a/lib/node_modules/@stdlib/random/base/triangular/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/triangular/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof triangular.factory, 'function', 'has method' );
+	t.strictEqual( typeof triangular.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof triangular.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof triangular.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( triangular.NAME, 'triangular', 'has property' );
+	t.strictEqual( triangular.NAME, 'triangular', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof triangular.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof triangular.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( triangular.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( triangular.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof triangular.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof triangular.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( triangular.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( triangular.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof triangular.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof triangular.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof triangular.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof triangular.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -90,8 +90,8 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	c = 211.33;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = triangular( a, b, c );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( triangular( 0.0, 1.0, 0.5 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( triangular( 0.0, 1.0, 0.5 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/uniform/test/test.factory.js b/lib/node_modules/@stdlib/random/base/uniform/test/test.factory.js
index 98bc4d7cd29d..a8bda039727e 100644
--- a/lib/node_modules/@stdlib/random/base/uniform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/uniform/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -392,14 +393,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	uniform = factory( -10.0, 10.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = uniform();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	uniform = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = uniform( -10.0, 10.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -426,7 +427,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = uniform1();
 		r2 = uniform2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -453,25 +454,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = uniform1();
 		r2 = uniform2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var uniform = factory();
-	t.equal( uniform.NAME, 'uniform', 'has property' );
+	t.strictEqual( uniform.NAME, 'uniform', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var uniform = factory();
-	t.equal( typeof uniform.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof uniform.PRNG, 'function', 'has property' );
 
 	uniform = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( uniform.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( uniform.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -479,14 +480,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var uniform = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( uniform.seed ), true, 'has property' );
-	t.equal( uniform.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( uniform.seed ), true, 'has property' );
+	t.strictEqual( uniform.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	uniform = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( uniform.seed, null, 'equal to `null`' );
+	t.strictEqual( uniform.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -502,54 +503,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var uniform = factory();
-	t.equal( typeof uniform.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof uniform.seedLength, 'number', 'has property' );
 
 	uniform = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( uniform.seedLength, null, 'equal to `null`' );
+	t.strictEqual( uniform.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var uniform = factory();
-	t.equal( isUint32Array( uniform.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( uniform.state ), true, 'has property' );
 
 	uniform = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( uniform.state, null, 'equal to `null`' );
+	t.strictEqual( uniform.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var uniform = factory();
-	t.equal( typeof uniform.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof uniform.stateLength, 'number', 'has property' );
 
 	uniform = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( uniform.stateLength, null, 'equal to `null`' );
+	t.strictEqual( uniform.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var uniform = factory();
-	t.equal( typeof uniform.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof uniform.byteLength, 'number', 'has property' );
 
 	uniform = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( uniform.byteLength, null, 'equal to `null`' );
+	t.strictEqual( uniform.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -558,11 +559,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	uniform = factory();
-	t.equal( typeof uniform.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof uniform.toJSON, 'function', 'has method' );
 
 	o = uniform.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, uniform.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, uniform.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( uniform.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -574,8 +575,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	uniform = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof uniform.toJSON, 'function', 'has method' );
-	t.equal( uniform.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof uniform.toJSON, 'function', 'has method' );
+	t.strictEqual( uniform.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -644,7 +645,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = uniform();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -660,7 +661,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = uniform( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -695,7 +696,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = uniform1();
 		r2 = uniform2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -730,7 +731,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = uniform1( 1.0, 2.0 );
 		r2 = uniform2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -749,7 +750,7 @@ tape( 'the function returns a PRNG for generating random numbers from a uniform
 	a = 2.0;
 	b = 4.0;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 500;
 
 	count = -1;
@@ -778,7 +779,7 @@ tape( 'the function returns a PRNG for generating random numbers from a uniform
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'uniform', a, b ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -837,7 +838,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( uniform(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( uniform(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -887,8 +888,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -905,8 +906,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -937,7 +938,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( uniform(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( uniform(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/uniform/test/test.js b/lib/node_modules/@stdlib/random/base/uniform/test/test.js
index d1a835809ab5..9de47691ccb5 100644
--- a/lib/node_modules/@stdlib/random/base/uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/uniform/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof uniform.factory, 'function', 'has method' );
+	t.strictEqual( typeof uniform.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof uniform.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof uniform.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( uniform.NAME, 'uniform', 'has property' );
+	t.strictEqual( uniform.NAME, 'uniform', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof uniform.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof uniform.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( uniform.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( uniform.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof uniform.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof uniform.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( uniform.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( uniform.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof uniform.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof uniform.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof uniform.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof uniform.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -88,8 +88,8 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	b = 4.0;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = uniform( a, b );
-		t.equal( typeof r, 'number', 'returns a number' );
-		t.equal( r >= a && r <= b, true, 'within support: '+r );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( uniform( 2.0, 4.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( uniform( 2.0, 4.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/weibull/test/test.factory.js b/lib/node_modules/@stdlib/random/base/weibull/test/test.factory.js
index 7e054c76658b..091bf686760b 100644
--- a/lib/node_modules/@stdlib/random/base/weibull/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/weibull/test/test.factory.js
@@ -30,6 +30,7 @@ var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var typedarray2json = require( '@stdlib/array/to-json' );
 var minstd = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var factory = require( './../lib/factory.js' );
 
 
@@ -374,14 +375,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	weibull = factory( 2.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = weibull();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	// Without binding distribution parameters...
 	weibull = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = weibull( 2.5, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 
 	t.end();
@@ -409,7 +410,7 @@ tape( 'the function returns a seeded pseudorandom number generator (integer seed
 	for ( i = 0; i < 100; i++ ) {
 		r1 = weibull1();
 		r2 = weibull2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -436,25 +437,25 @@ tape( 'the function returns a seeded pseudorandom number generator (array seed)'
 	for ( i = 0; i < 100; i++ ) {
 		r1 = weibull1();
 		r2 = weibull2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator name', function test( t ) {
 	var weibull = factory();
-	t.equal( weibull.NAME, 'weibull', 'has property' );
+	t.strictEqual( weibull.NAME, 'weibull', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var weibull = factory();
-	t.equal( typeof weibull.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof weibull.PRNG, 'function', 'has property' );
 
 	weibull = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( weibull.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( weibull.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -462,14 +463,14 @@ tape( 'attached to the returned function is the generator seed (integer seed)',
 	var weibull = factory({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( weibull.seed ), true, 'has property' );
-	t.equal( weibull.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( weibull.seed ), true, 'has property' );
+	t.strictEqual( weibull.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	weibull = factory({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( weibull.seed, null, 'equal to `null`' );
+	t.strictEqual( weibull.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -485,54 +486,54 @@ tape( 'attached to the returned function is the generator seed (array seed)', fu
 	});
 
 	actual = rand.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator seed length', function test( t ) {
 	var weibull = factory();
-	t.equal( typeof weibull.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof weibull.seedLength, 'number', 'has property' );
 
 	weibull = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( weibull.seedLength, null, 'equal to `null`' );
+	t.strictEqual( weibull.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state', function test( t ) {
 	var weibull = factory();
-	t.equal( isUint32Array( weibull.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( weibull.state ), true, 'has property' );
 
 	weibull = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( weibull.state, null, 'equal to `null`' );
+	t.strictEqual( weibull.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state length', function test( t ) {
 	var weibull = factory();
-	t.equal( typeof weibull.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof weibull.stateLength, 'number', 'has property' );
 
 	weibull = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( weibull.stateLength, null, 'equal to `null`' );
+	t.strictEqual( weibull.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the generator state size', function test( t ) {
 	var weibull = factory();
-	t.equal( typeof weibull.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof weibull.byteLength, 'number', 'has property' );
 
 	weibull = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( weibull.byteLength, null, 'equal to `null`' );
+	t.strictEqual( weibull.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -541,11 +542,11 @@ tape( 'attached to the returned function is a method to serialize the generator
 	var o;
 
 	weibull = factory();
-	t.equal( typeof weibull.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof weibull.toJSON, 'function', 'has method' );
 
 	o = weibull.toJSON();
-	t.equal( o.type, 'PRNG', 'has property' );
-	t.equal( o.name, weibull.NAME, 'has property' );
+	t.strictEqual( o.type, 'PRNG', 'has property' );
+	t.strictEqual( o.name, weibull.NAME, 'has property' );
 	t.deepEqual( o.state, typedarray2json( weibull.state ), 'has property' );
 	t.deepEqual( o.params, [], 'has property' );
 
@@ -557,8 +558,8 @@ tape( 'attached to the returned function is a method to serialize the generator
 	weibull = factory({
 		'prng': minstd.normalized
 	});
-	t.equal( typeof weibull.toJSON, 'function', 'has method' );
-	t.equal( weibull.toJSON(), null, 'returns expected value' );
+	t.strictEqual( typeof weibull.toJSON, 'function', 'has method' );
+	t.strictEqual( weibull.toJSON(), null, 'returns expected value' );
 
 	t.end();
 });
@@ -637,7 +638,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = weibull();
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -653,7 +654,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = weibull( 1.0, 2.0 );
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -688,7 +689,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = weibull1();
 		r2 = weibull2();
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -723,7 +724,7 @@ tape( 'the function supports providing a seeded underlying PRNG (parameters)', f
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = weibull1( 1.0, 2.0 );
 		r2 = weibull2( 1.0, 2.0 );
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -742,7 +743,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Weibull
 	lambda = 3.14;
 	k = 1.2;
 
-	x = new Array( 1e3 );
+	x = zeros( 1e3 );
 	N = 300;
 
 	count = -1;
@@ -768,7 +769,7 @@ tape( 'the function returns a PRNG for generating random numbers from a Weibull
 			}
 			// Test using Kolmogorov-Smirnov goodness-of-fit test:
 			pValue = kstest( x, 'weibull', k, lambda ).pValue;
-			t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+			t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 			if ( pValue < 0.05 ) {
 				rejected += 1;
 			}
@@ -827,7 +828,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( weibull(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( weibull(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -877,8 +878,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -895,8 +896,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = rand1();
 		v2 = rand2();
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -927,7 +928,7 @@ tape( 'the returned function supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( weibull(), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( weibull(), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/weibull/test/test.js b/lib/node_modules/@stdlib/random/base/weibull/test/test.js
index 92d84dede1d9..f107b8c26878 100644
--- a/lib/node_modules/@stdlib/random/base/weibull/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/weibull/test/test.js
@@ -34,47 +34,47 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to generate pseudorandom number generators', function test( t ) {
-	t.equal( typeof weibull.factory, 'function', 'has method' );
+	t.strictEqual( typeof weibull.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to serialize a pseudorandom number generator as JSON', function test( t ) {
-	t.equal( typeof weibull.toJSON, 'function', 'has method' );
+	t.strictEqual( typeof weibull.toJSON, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator name', function test( t ) {
-	t.equal( weibull.NAME, 'weibull', 'has property' );
+	t.strictEqual( weibull.NAME, 'weibull', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof weibull.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof weibull.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( weibull.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( weibull.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof weibull.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof weibull.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( weibull.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( weibull.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof weibull.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof weibull.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof weibull.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof weibull.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function supports setting the generator state', function test( t ) {
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( weibull( 2.0, 4.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( weibull( 2.0, 4.0 ), arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/exponential/test/test.js b/lib/node_modules/@stdlib/random/exponential/test/test.js
index 301c6bb9b5c1..b6145c92f9b5 100644
--- a/lib/node_modules/@stdlib/random/exponential/test/test.js
+++ b/lib/node_modules/@stdlib/random/exponential/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'returns expected value' );
+	t.strictEqual( typeof random.PRNG, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'returns expected value' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'returns expected value' );
+	t.strictEqual( typeof random.seedLength, 'number', 'returns expected value' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'returns expected value' );
+	t.strictEqual( isUint32Array( random.state ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'returns expected value' );
+	t.strictEqual( typeof random.stateLength, 'number', 'returns expected value' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'returns expected value' );
+	t.strictEqual( typeof random.byteLength, 'number', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/arcsine/test/test.js b/lib/node_modules/@stdlib/random/iter/arcsine/test/test.js
index 51df1df7b4c3..d0068adabb33 100644
--- a/lib/node_modules/@stdlib/random/iter/arcsine/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/arcsine/test/test.js
@@ -355,12 +355,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( -10.0, 10.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -387,19 +387,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -407,14 +407,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -430,54 +430,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -496,7 +496,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -518,11 +518,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -535,20 +535,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -560,20 +560,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -589,18 +589,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -614,7 +614,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -630,7 +630,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -665,7 +665,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -698,7 +698,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -748,8 +748,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -766,8 +766,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -798,7 +798,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/bernoulli/test/test.js b/lib/node_modules/@stdlib/random/iter/bernoulli/test/test.js
index 330f0de37d34..6aa6e19b3d29 100644
--- a/lib/node_modules/@stdlib/random/iter/bernoulli/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/bernoulli/test/test.js
@@ -307,12 +307,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 0.7 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -339,19 +339,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 0.3 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -359,14 +359,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 0.3, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 0.3, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -382,54 +382,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 0.3 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 0.3 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 0.3 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 0.3 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -448,7 +448,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -470,11 +470,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -487,20 +487,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -512,20 +512,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -541,18 +541,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 0.3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -566,7 +566,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 0.3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -617,7 +617,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -650,7 +650,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -700,8 +700,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -718,8 +718,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -750,7 +750,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/beta/test/test.js b/lib/node_modules/@stdlib/random/iter/beta/test/test.js
index 3466dd4a0e37..af3c0aa387e7 100644
--- a/lib/node_modules/@stdlib/random/iter/beta/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/beta/test/test.js
@@ -337,12 +337,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 1.0, 1.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -369,19 +369,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -389,14 +389,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -412,54 +412,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -478,7 +478,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -500,11 +500,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -517,20 +517,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -542,20 +542,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -571,18 +571,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -596,7 +596,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -647,7 +647,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -680,7 +680,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -730,8 +730,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -748,8 +748,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -780,7 +780,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/betaprime/test/test.js b/lib/node_modules/@stdlib/random/iter/betaprime/test/test.js
index 001869cef2a3..df97ac14c55f 100644
--- a/lib/node_modules/@stdlib/random/iter/betaprime/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/betaprime/test/test.js
@@ -337,12 +337,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 1.0, 1.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -369,19 +369,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -389,14 +389,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -412,54 +412,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -478,7 +478,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -500,11 +500,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -517,20 +517,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -542,20 +542,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -571,18 +571,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -596,7 +596,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -647,7 +647,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -680,7 +680,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -730,8 +730,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -748,8 +748,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -780,7 +780,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/binomial/test/test.js b/lib/node_modules/@stdlib/random/iter/binomial/test/test.js
index 03d5ca3fc900..b05774254234 100644
--- a/lib/node_modules/@stdlib/random/iter/binomial/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/binomial/test/test.js
@@ -339,12 +339,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 100, 0.7 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -371,19 +371,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 8, 0.3 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 8, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -391,14 +391,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 8, 0.3, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 8, 0.3, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -414,54 +414,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 8, 0.3 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 8, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 8, 0.3 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 8, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 8, 0.3 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 8, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 8, 0.3 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 8, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -480,7 +480,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -502,11 +502,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -519,20 +519,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 20, 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -544,20 +544,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 20, 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -573,18 +573,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 20, 0.3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -598,7 +598,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 20, 0.3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -614,7 +614,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -649,7 +649,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -682,7 +682,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -732,8 +732,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -750,8 +750,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -782,7 +782,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/box-muller/test/test.js b/lib/node_modules/@stdlib/random/iter/box-muller/test/test.js
index 4d26afff9392..8c5fb331f273 100644
--- a/lib/node_modules/@stdlib/random/iter/box-muller/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/box-muller/test/test.js
@@ -277,12 +277,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -309,19 +309,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -329,14 +329,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -352,54 +352,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator();
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -409,7 +409,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	var i;
 
 	// Note: we assume that the underlying generator is the following PRNG...
-	rand = randn( {
+	rand = randn({
 		'seed': 12345
 	});
 
@@ -418,7 +418,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -440,11 +440,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -457,20 +457,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -482,20 +482,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -511,18 +511,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -536,7 +536,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -552,7 +552,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -587,7 +587,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -620,7 +620,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -671,13 +671,13 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 		// NOTE: more complicated to test due to the generation of two pseudorandom variates at a time...
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+2 ], 'returns expected value. i: '+(j+2)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+2 ], 'returns expected value. i: '+(j+2)+'.' );
 
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
-		t.equal( v2, arr[ j+3 ], 'returns expected value. i: '+(j+3)+'.' );
+		t.strictEqual( v1, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v2, arr[ j+3 ], 'returns expected value. i: '+(j+3)+'.' );
 
 		j += 4; // stride
 	}
@@ -696,13 +696,13 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 		// NOTE: more complicated to test due to the generation of two pseudorandom variates at a time...
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+2 ], 'returns expected value. i: '+(j+2)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+2 ], 'returns expected value. i: '+(j+2)+'.' );
 
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
-		t.equal( v2, arr[ j+3 ], 'returns expected value. i: '+(j+3)+'.' );
+		t.strictEqual( v1, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v2, arr[ j+3 ], 'returns expected value. i: '+(j+3)+'.' );
 		j += 4; // stride
 	}
 	t.end();
@@ -733,7 +733,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/cauchy/test/test.js b/lib/node_modules/@stdlib/random/iter/cauchy/test/test.js
index 26b571d2ccc6..0b146e917a79 100644
--- a/lib/node_modules/@stdlib/random/iter/cauchy/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/cauchy/test/test.js
@@ -335,12 +335,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( -10.0, 10.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -367,19 +367,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -387,14 +387,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -410,54 +410,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -476,7 +476,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -498,11 +498,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -515,20 +515,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -540,20 +540,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -569,18 +569,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -594,7 +594,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -645,7 +645,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -678,7 +678,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -728,8 +728,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -746,8 +746,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -778,7 +778,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/chi/test/test.js b/lib/node_modules/@stdlib/random/iter/chi/test/test.js
index d7d4329081d5..da4aee0c201a 100644
--- a/lib/node_modules/@stdlib/random/iter/chi/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/chi/test/test.js
@@ -307,12 +307,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 0.7 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -339,19 +339,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -359,14 +359,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -382,54 +382,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -448,7 +448,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -470,11 +470,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -487,20 +487,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -512,20 +512,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -541,18 +541,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -566,7 +566,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -617,7 +617,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -650,7 +650,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -700,8 +700,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -718,8 +718,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -750,7 +750,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/chisquare/test/test.js b/lib/node_modules/@stdlib/random/iter/chisquare/test/test.js
index 0fd905d0bfd9..36b7a5daf03c 100644
--- a/lib/node_modules/@stdlib/random/iter/chisquare/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/chisquare/test/test.js
@@ -307,12 +307,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 0.7 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -339,19 +339,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -359,14 +359,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -382,54 +382,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -448,7 +448,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -470,11 +470,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -487,20 +487,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -512,20 +512,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -541,18 +541,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -566,7 +566,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -617,7 +617,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -650,7 +650,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -700,8 +700,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -718,8 +718,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -750,7 +750,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/cosine/test/test.js b/lib/node_modules/@stdlib/random/iter/cosine/test/test.js
index 7c025683aad0..5628aa87993d 100644
--- a/lib/node_modules/@stdlib/random/iter/cosine/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/cosine/test/test.js
@@ -335,12 +335,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( -10.0, 10.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -367,19 +367,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -387,14 +387,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -410,54 +410,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -476,7 +476,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -498,11 +498,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -515,20 +515,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -540,20 +540,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -569,18 +569,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -594,7 +594,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -645,7 +645,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -678,7 +678,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -728,8 +728,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -746,8 +746,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -778,7 +778,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/discrete-uniform/test/test.js b/lib/node_modules/@stdlib/random/iter/discrete-uniform/test/test.js
index a6a881988b5d..cbc52bc0ed79 100644
--- a/lib/node_modules/@stdlib/random/iter/discrete-uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/discrete-uniform/test/test.js
@@ -431,12 +431,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( -10, 10 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -463,19 +463,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2, 5 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2, 5, {
 		'prng': minstd
 	});
-	t.equal( it.PRNG, minstd, 'has property' );
+	t.strictEqual( it.PRNG, minstd, 'has property' );
 	t.end();
 });
 
@@ -483,14 +483,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2, 5, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2, 5, {
 		'seed': 12345,
 		'prng': minstd
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -506,54 +506,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2, 5 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2, 5, {
 		'prng': minstd
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2, 5 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2, 5, {
 		'prng': minstd
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2, 5 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2, 5, {
 		'prng': minstd
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2, 5 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2, 5, {
 		'prng': minstd
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -572,7 +572,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -594,11 +594,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -611,20 +611,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10, 10 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -636,20 +636,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10, 10 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -665,18 +665,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2, 5 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -690,7 +690,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2, 5 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -706,7 +706,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -741,7 +741,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -774,7 +774,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -824,8 +824,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -842,8 +842,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -874,7 +874,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/erlang/test/test.js b/lib/node_modules/@stdlib/random/iter/erlang/test/test.js
index d01ab869ca71..4f7a8c502748 100644
--- a/lib/node_modules/@stdlib/random/iter/erlang/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/erlang/test/test.js
@@ -338,12 +338,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 1, 1.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -370,19 +370,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -390,14 +390,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -413,54 +413,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -479,7 +479,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -501,11 +501,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -518,20 +518,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -543,20 +543,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -572,18 +572,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 8, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -597,7 +597,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 10, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -613,7 +613,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -648,7 +648,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -681,7 +681,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -731,8 +731,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -749,8 +749,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -781,7 +781,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/exponential/test/test.js b/lib/node_modules/@stdlib/random/iter/exponential/test/test.js
index bd02454007fb..fb83cf72ed79 100644
--- a/lib/node_modules/@stdlib/random/iter/exponential/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/exponential/test/test.js
@@ -307,12 +307,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 0.7 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -339,19 +339,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -359,14 +359,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -382,54 +382,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -448,7 +448,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -470,11 +470,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -487,20 +487,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -512,20 +512,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -541,18 +541,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -566,7 +566,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -617,7 +617,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -650,7 +650,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -700,8 +700,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -718,8 +718,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -750,7 +750,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/f/test/test.js b/lib/node_modules/@stdlib/random/iter/f/test/test.js
index 9b192d395569..e77c4df21170 100644
--- a/lib/node_modules/@stdlib/random/iter/f/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/f/test/test.js
@@ -337,12 +337,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 1.0, 1.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -369,19 +369,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -389,14 +389,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -412,54 +412,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -478,7 +478,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -500,11 +500,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -517,20 +517,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -542,20 +542,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -571,18 +571,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -596,7 +596,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -647,7 +647,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -680,7 +680,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -730,8 +730,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -748,8 +748,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -780,7 +780,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/frechet/test/test.js b/lib/node_modules/@stdlib/random/iter/frechet/test/test.js
index 42a601a7ce81..577184c228e8 100644
--- a/lib/node_modules/@stdlib/random/iter/frechet/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/frechet/test/test.js
@@ -365,12 +365,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 1.0, 1.0, 0.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -397,19 +397,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0, 2.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -417,14 +417,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, 2.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, 2.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -440,54 +440,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0, 2.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0, 2.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0, 2.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0, 2.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -506,7 +506,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -528,11 +528,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -545,20 +545,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0, 0.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -570,20 +570,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0, 0.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -599,18 +599,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0, 3.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -624,7 +624,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0, 3.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -640,7 +640,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -675,7 +675,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -708,7 +708,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -758,8 +758,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -776,8 +776,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -808,7 +808,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/gamma/test/test.js b/lib/node_modules/@stdlib/random/iter/gamma/test/test.js
index 02ae83ed661f..3b3a6f80c181 100644
--- a/lib/node_modules/@stdlib/random/iter/gamma/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/gamma/test/test.js
@@ -337,12 +337,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 1.0, 1.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -369,19 +369,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -389,14 +389,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -412,54 +412,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -478,7 +478,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -500,11 +500,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -517,20 +517,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -542,20 +542,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -571,18 +571,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -596,7 +596,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -647,7 +647,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -680,7 +680,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -730,8 +730,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -748,8 +748,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -780,7 +780,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/geometric/test/test.js b/lib/node_modules/@stdlib/random/iter/geometric/test/test.js
index 8e0790da2f7a..57a723817e30 100644
--- a/lib/node_modules/@stdlib/random/iter/geometric/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/geometric/test/test.js
@@ -307,12 +307,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 0.7 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -339,19 +339,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 0.3 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -359,14 +359,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 0.3, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 0.3, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -382,54 +382,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 0.3 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 0.3 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 0.3 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 0.3 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -448,7 +448,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -470,11 +470,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -487,20 +487,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -512,20 +512,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -541,18 +541,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 0.3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -566,7 +566,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 0.3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -617,7 +617,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -650,7 +650,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -700,8 +700,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -718,8 +718,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -750,7 +750,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/gumbel/test/test.js b/lib/node_modules/@stdlib/random/iter/gumbel/test/test.js
index 72c1b398d637..e2638c033222 100644
--- a/lib/node_modules/@stdlib/random/iter/gumbel/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/gumbel/test/test.js
@@ -335,12 +335,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( -10.0, 10.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -367,19 +367,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -387,14 +387,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -410,54 +410,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -476,7 +476,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -498,11 +498,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -515,20 +515,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -540,20 +540,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -569,18 +569,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -594,7 +594,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -645,7 +645,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -678,7 +678,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -728,8 +728,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -746,8 +746,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -778,7 +778,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/hypergeometric/test/test.js b/lib/node_modules/@stdlib/random/iter/hypergeometric/test/test.js
index 2037fe1c5c8c..0d1579c7863c 100644
--- a/lib/node_modules/@stdlib/random/iter/hypergeometric/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/hypergeometric/test/test.js
@@ -414,12 +414,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 100, 20, 50 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -446,19 +446,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 8, 4, 6 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 8, 4, 6, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -466,14 +466,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 8, 4, 6, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 8, 4, 6, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -489,54 +489,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 8, 4, 6 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 8, 4, 6, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 8, 4, 6 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 8, 4, 6, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 8, 4, 6 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 8, 4, 6, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 8, 4, 6 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 8, 4, 6, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -555,7 +555,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -577,11 +577,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -594,20 +594,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 20, 10, 10 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -619,20 +619,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 20, 20, 10 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -648,18 +648,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 20, 15, 8 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -673,7 +673,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 20, 12, 8 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -689,7 +689,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -724,7 +724,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -757,7 +757,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -807,8 +807,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -825,8 +825,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -857,7 +857,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/improved-ziggurat/test/test.js b/lib/node_modules/@stdlib/random/iter/improved-ziggurat/test/test.js
index ef9a66917084..e52e714cda42 100644
--- a/lib/node_modules/@stdlib/random/iter/improved-ziggurat/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/improved-ziggurat/test/test.js
@@ -277,12 +277,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -309,19 +309,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -329,14 +329,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -352,54 +352,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator();
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -409,7 +409,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	var i;
 
 	// Note: we assume that the underlying generator is the following PRNG...
-	rand = randn( {
+	rand = randn({
 		'seed': 12345
 	});
 
@@ -418,7 +418,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -440,11 +440,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -457,20 +457,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -482,20 +482,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -511,18 +511,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -536,7 +536,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -552,7 +552,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -587,7 +587,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -620,7 +620,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -670,8 +670,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -688,8 +688,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -720,7 +720,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/invgamma/test/test.js b/lib/node_modules/@stdlib/random/iter/invgamma/test/test.js
index 961f75731cc7..59393dbd9324 100644
--- a/lib/node_modules/@stdlib/random/iter/invgamma/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/invgamma/test/test.js
@@ -337,12 +337,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 1.0, 1.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -369,19 +369,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -389,14 +389,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -412,54 +412,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -478,7 +478,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -500,11 +500,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -517,20 +517,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -542,20 +542,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -571,18 +571,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -596,7 +596,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -647,7 +647,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -680,7 +680,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -730,8 +730,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -748,8 +748,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -780,7 +780,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/kumaraswamy/test/test.js b/lib/node_modules/@stdlib/random/iter/kumaraswamy/test/test.js
index 5eca546d48e8..ff72267a0c59 100644
--- a/lib/node_modules/@stdlib/random/iter/kumaraswamy/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/kumaraswamy/test/test.js
@@ -337,12 +337,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 1.0, 1.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -369,19 +369,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -389,14 +389,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -412,54 +412,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -478,7 +478,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -500,11 +500,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -517,20 +517,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -542,20 +542,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -571,18 +571,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -596,7 +596,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -647,7 +647,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -680,7 +680,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -730,8 +730,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -748,8 +748,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -780,7 +780,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/laplace/test/test.js b/lib/node_modules/@stdlib/random/iter/laplace/test/test.js
index 1bf500fda565..87a90e6a12df 100644
--- a/lib/node_modules/@stdlib/random/iter/laplace/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/laplace/test/test.js
@@ -335,12 +335,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( -10.0, 10.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -367,19 +367,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -387,14 +387,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -410,54 +410,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -476,7 +476,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -498,11 +498,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -515,20 +515,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -540,20 +540,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -569,18 +569,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -594,7 +594,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -645,7 +645,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -678,7 +678,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -728,8 +728,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -746,8 +746,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -778,7 +778,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/levy/test/test.js b/lib/node_modules/@stdlib/random/iter/levy/test/test.js
index b4cdc4be4805..42a29282165b 100644
--- a/lib/node_modules/@stdlib/random/iter/levy/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/levy/test/test.js
@@ -335,12 +335,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( -10.0, 10.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -367,19 +367,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -387,14 +387,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -410,54 +410,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -476,7 +476,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -498,11 +498,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -515,20 +515,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -540,20 +540,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -569,18 +569,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -594,7 +594,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -645,7 +645,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -678,7 +678,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -728,8 +728,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -746,8 +746,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -778,7 +778,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/logistic/test/test.js b/lib/node_modules/@stdlib/random/iter/logistic/test/test.js
index af0855ea49b6..027353f1f296 100644
--- a/lib/node_modules/@stdlib/random/iter/logistic/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/logistic/test/test.js
@@ -335,12 +335,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( -10.0, 10.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -367,19 +367,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -387,14 +387,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -410,54 +410,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -476,7 +476,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -498,11 +498,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -515,20 +515,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -540,20 +540,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -569,18 +569,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -594,7 +594,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -645,7 +645,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -678,7 +678,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -728,8 +728,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -746,8 +746,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -778,7 +778,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/lognormal/test/test.js b/lib/node_modules/@stdlib/random/iter/lognormal/test/test.js
index 587a3e1f515a..6ca4b4330371 100644
--- a/lib/node_modules/@stdlib/random/iter/lognormal/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/lognormal/test/test.js
@@ -335,12 +335,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( -10.0, 10.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -367,19 +367,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -387,14 +387,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -410,54 +410,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -476,7 +476,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -498,11 +498,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -515,20 +515,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -540,20 +540,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -569,18 +569,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -594,7 +594,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -645,7 +645,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -678,7 +678,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -728,8 +728,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -746,8 +746,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -778,7 +778,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/minstd-shuffle/test/test.js b/lib/node_modules/@stdlib/random/iter/minstd-shuffle/test/test.js
index ca5235e04437..cb60530b3d10 100644
--- a/lib/node_modules/@stdlib/random/iter/minstd-shuffle/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/minstd-shuffle/test/test.js
@@ -277,12 +277,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -309,7 +309,7 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
@@ -318,8 +318,8 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator({
 		'seed': 12345
 	});
-	t.equal( isInt32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isInt32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -335,34 +335,34 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isInt32Array( actual ), true, 'has property' );
+	t.strictEqual( isInt32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator();
-	t.equal( isInt32Array( it.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( it.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -381,7 +381,7 @@ tape( 'the function returns an iterator for generating pseudorandom integers on
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -402,7 +402,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers on t
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand.normalized(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand.normalized(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -424,11 +424,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -441,20 +441,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -466,20 +466,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -495,18 +495,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -520,7 +520,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -553,7 +553,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -603,8 +603,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -621,8 +621,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -653,7 +653,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/minstd/test/test.js b/lib/node_modules/@stdlib/random/iter/minstd/test/test.js
index a08a184e1e21..153e698cdd8a 100644
--- a/lib/node_modules/@stdlib/random/iter/minstd/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/minstd/test/test.js
@@ -277,12 +277,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -309,7 +309,7 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
@@ -318,8 +318,8 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator({
 		'seed': 12345
 	});
-	t.equal( isInt32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isInt32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -335,34 +335,34 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isInt32Array( actual ), true, 'has property' );
+	t.strictEqual( isInt32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator();
-	t.equal( isInt32Array( it.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( it.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -381,7 +381,7 @@ tape( 'the function returns an iterator for generating pseudorandom integers on
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -402,7 +402,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers on t
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand.normalized(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand.normalized(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -424,11 +424,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -441,20 +441,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -466,20 +466,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -495,18 +495,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -520,7 +520,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -553,7 +553,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -603,8 +603,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -621,8 +621,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -653,7 +653,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/mt19937/test/test.js b/lib/node_modules/@stdlib/random/iter/mt19937/test/test.js
index 50b1a6b81ebb..39778f3f3038 100644
--- a/lib/node_modules/@stdlib/random/iter/mt19937/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/mt19937/test/test.js
@@ -277,12 +277,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -309,7 +309,7 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
@@ -318,8 +318,8 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -335,34 +335,34 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator();
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -381,7 +381,7 @@ tape( 'the function returns an iterator for generating pseudorandom integers on
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -402,7 +402,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers on t
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand.normalized(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand.normalized(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -424,11 +424,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -441,20 +441,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -466,20 +466,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -495,18 +495,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -520,7 +520,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -553,7 +553,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -603,8 +603,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -621,8 +621,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -653,7 +653,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/negative-binomial/test/test.js b/lib/node_modules/@stdlib/random/iter/negative-binomial/test/test.js
index 81c6bcf8eb26..4d892fb37734 100644
--- a/lib/node_modules/@stdlib/random/iter/negative-binomial/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/negative-binomial/test/test.js
@@ -338,12 +338,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 100, 0.7 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -370,19 +370,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 10, 0.3 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 10, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -390,14 +390,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 10, 0.3, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 10, 0.3, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -413,54 +413,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 10, 0.3 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 10, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 10, 0.3 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 10, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 10, 0.3 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 10, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 10, 0.3 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 10, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -479,7 +479,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -501,11 +501,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -518,20 +518,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 20, 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -543,20 +543,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 20, 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -572,18 +572,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 20, 0.3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -597,7 +597,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 20, 0.3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -613,7 +613,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -648,7 +648,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -681,7 +681,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -731,8 +731,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -749,8 +749,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -781,7 +781,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/normal/test/test.js b/lib/node_modules/@stdlib/random/iter/normal/test/test.js
index 5b0a89b7ee0f..ebc679ed557a 100644
--- a/lib/node_modules/@stdlib/random/iter/normal/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/normal/test/test.js
@@ -335,12 +335,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( -10.0, 10.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -367,19 +367,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -387,14 +387,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -410,54 +410,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -476,7 +476,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -498,11 +498,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -515,20 +515,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -540,20 +540,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -569,18 +569,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -594,7 +594,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -645,7 +645,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -678,7 +678,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -728,8 +728,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -746,8 +746,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -778,7 +778,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/pareto-type1/test/test.js b/lib/node_modules/@stdlib/random/iter/pareto-type1/test/test.js
index f3520270a062..546e1dfd7f24 100644
--- a/lib/node_modules/@stdlib/random/iter/pareto-type1/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/pareto-type1/test/test.js
@@ -337,12 +337,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 1.0, 1.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -369,19 +369,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -389,14 +389,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -412,54 +412,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -478,7 +478,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -500,11 +500,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -517,20 +517,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -542,20 +542,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -571,18 +571,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -596,7 +596,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -647,7 +647,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -680,7 +680,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -730,8 +730,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -748,8 +748,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -780,7 +780,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/poisson/test/test.js b/lib/node_modules/@stdlib/random/iter/poisson/test/test.js
index b8688ddfa0ef..8429cb0a8bfe 100644
--- a/lib/node_modules/@stdlib/random/iter/poisson/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/poisson/test/test.js
@@ -307,12 +307,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 0.7 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -339,19 +339,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -359,14 +359,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -382,54 +382,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -448,7 +448,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -470,11 +470,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -487,20 +487,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -512,20 +512,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -541,18 +541,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -566,7 +566,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -617,7 +617,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -650,7 +650,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -700,8 +700,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -718,8 +718,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -750,7 +750,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/randi/test/test.js b/lib/node_modules/@stdlib/random/iter/randi/test/test.js
index 8940c4405277..aebd0dd100f3 100644
--- a/lib/node_modules/@stdlib/random/iter/randi/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/randi/test/test.js
@@ -226,12 +226,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -258,19 +258,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator({
 		'name': 'minstd'
 	});
-	t.equal( it.PRNG.NAME, 'minstd', 'has property' );
+	t.strictEqual( it.PRNG.NAME, 'minstd', 'has property' );
 	t.end();
 });
 
@@ -279,8 +279,8 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 		'name': 'mt19937',
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -297,16 +297,16 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -314,19 +314,19 @@ tape( 'attached to the returned iterator is the generator state', function test(
 	var it = iterator({
 		'name': 'mt19937'
 	});
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -336,7 +336,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers havi
 	var i;
 
 	// Note: we assume that the underlying generator is the following PRNG...
-	rand = randi( {
+	rand = randi({
 		'seed': 12345
 	});
 
@@ -345,7 +345,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers havi
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -367,11 +367,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -384,20 +384,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -409,20 +409,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -438,18 +438,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -463,7 +463,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -496,7 +496,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -550,8 +550,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -568,8 +568,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -600,7 +600,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/randn/test/test.js b/lib/node_modules/@stdlib/random/iter/randn/test/test.js
index 0731a757fa18..82dac0f6b64c 100644
--- a/lib/node_modules/@stdlib/random/iter/randn/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/randn/test/test.js
@@ -306,12 +306,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -338,19 +338,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -358,14 +358,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator({
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -381,54 +381,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator();
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator({
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -438,7 +438,7 @@ tape( 'the function returns an iterator for generating standard normally distrib
 	var i;
 
 	// Note: we assume that the underlying generator is the following PRNG...
-	rand = randn( {
+	rand = randn({
 		'seed': 12345
 	});
 
@@ -447,7 +447,7 @@ tape( 'the function returns an iterator for generating standard normally distrib
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -469,11 +469,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -486,20 +486,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -511,20 +511,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -540,18 +540,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -565,7 +565,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -581,7 +581,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -616,7 +616,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -649,7 +649,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -699,8 +699,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -717,8 +717,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -749,7 +749,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/randu/test/test.js b/lib/node_modules/@stdlib/random/iter/randu/test/test.js
index 892d0bc16f2f..2974456ea96b 100644
--- a/lib/node_modules/@stdlib/random/iter/randu/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/randu/test/test.js
@@ -226,12 +226,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -258,19 +258,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator({
 		'name': 'minstd'
 	});
-	t.equal( it.PRNG.NAME, 'minstd', 'has property' );
+	t.strictEqual( it.PRNG.NAME, 'minstd', 'has property' );
 	t.end();
 });
 
@@ -279,8 +279,8 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 		'name': 'mt19937',
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 	t.end();
 });
 
@@ -297,16 +297,16 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -314,19 +314,19 @@ tape( 'attached to the returned iterator is the generator state', function test(
 	var it = iterator({
 		'name': 'mt19937'
 	});
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator();
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -336,7 +336,7 @@ tape( 'the function returns an iterator for generating uniformly distributed pse
 	var i;
 
 	// Note: we assume that the underlying generator is the following PRNG...
-	rand = randu( {
+	rand = randu({
 		'seed': 12345
 	});
 
@@ -345,7 +345,7 @@ tape( 'the function returns an iterator for generating uniformly distributed pse
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -367,11 +367,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -384,20 +384,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -409,20 +409,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -438,18 +438,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -463,7 +463,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -496,7 +496,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -550,8 +550,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -568,8 +568,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -600,7 +600,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/rayleigh/test/test.js b/lib/node_modules/@stdlib/random/iter/rayleigh/test/test.js
index 57cf7c9b3509..9d3a3a142f14 100644
--- a/lib/node_modules/@stdlib/random/iter/rayleigh/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/rayleigh/test/test.js
@@ -307,12 +307,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 0.7 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -339,19 +339,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -359,14 +359,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -382,54 +382,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -448,7 +448,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -470,11 +470,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -487,20 +487,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -512,20 +512,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -541,18 +541,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -566,7 +566,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -617,7 +617,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -650,7 +650,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -700,8 +700,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -718,8 +718,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -750,7 +750,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/t/test/test.js b/lib/node_modules/@stdlib/random/iter/t/test/test.js
index 092faae3cb44..102ac7b546b4 100644
--- a/lib/node_modules/@stdlib/random/iter/t/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/t/test/test.js
@@ -307,12 +307,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 0.7 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -339,19 +339,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -359,14 +359,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -382,54 +382,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -448,7 +448,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -470,11 +470,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -487,20 +487,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -512,20 +512,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -541,18 +541,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -566,7 +566,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -617,7 +617,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -650,7 +650,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -700,8 +700,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -718,8 +718,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -750,7 +750,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/test/test.js b/lib/node_modules/@stdlib/random/iter/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/random/iter/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/triangular/test/test.js b/lib/node_modules/@stdlib/random/iter/triangular/test/test.js
index d3fde10a2a35..53f0ee1140ce 100644
--- a/lib/node_modules/@stdlib/random/iter/triangular/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/triangular/test/test.js
@@ -384,12 +384,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( -10.0, 10.0, 0.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -416,19 +416,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0, 4.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, 4.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -436,14 +436,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, 4.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, 4.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -459,54 +459,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0, 4.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, 4.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0, 4.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, 4.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0, 4.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, 4.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0, 4.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, 4.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -525,7 +525,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -547,11 +547,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -564,20 +564,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0, 0.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -589,20 +589,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0, 0.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -618,18 +618,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0, 2.5 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -643,7 +643,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0, 2.5 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -659,7 +659,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -694,7 +694,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -727,7 +727,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -777,8 +777,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -795,8 +795,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -827,7 +827,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/uniform/test/test.js b/lib/node_modules/@stdlib/random/iter/uniform/test/test.js
index 501c9344c62a..dbe2b502670b 100644
--- a/lib/node_modules/@stdlib/random/iter/uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/uniform/test/test.js
@@ -355,12 +355,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( -10.0, 10.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -387,19 +387,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -407,14 +407,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -430,54 +430,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -496,7 +496,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -518,11 +518,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -535,20 +535,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -560,20 +560,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -589,18 +589,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -614,7 +614,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -630,7 +630,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -665,7 +665,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -698,7 +698,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -748,8 +748,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -766,8 +766,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -798,7 +798,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/weibull/test/test.js b/lib/node_modules/@stdlib/random/iter/weibull/test/test.js
index 361409246842..27b2c437ad40 100644
--- a/lib/node_modules/@stdlib/random/iter/weibull/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/weibull/test/test.js
@@ -337,12 +337,12 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 	var i;
 
 	it = iterator( 1.0, 1.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -369,19 +369,19 @@ tape( 'the function returns an iterator protocol-compliant object (seed)', funct
 	for ( i = 0; i < 100; i++ ) {
 		r1 = it1.next();
 		r2 = it2.next();
-		t.equal( r1.value, r2.value, 'both return same number' );
+		t.strictEqual( r1.value, r2.value, 'both return same number' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the underlying PRNG', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'has property' );
 	t.end();
 });
 
@@ -389,14 +389,14 @@ tape( 'attached to the returned iterator is the generator seed', function test(
 	var it = iterator( 2.0, 5.0, {
 		'seed': 12345
 	});
-	t.equal( isUint32Array( it.seed ), true, 'has property' );
-	t.equal( it.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( it.seed ), true, 'has property' );
+	t.strictEqual( it.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterator( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -412,54 +412,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterator( 2.0, 5.0 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterator( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -478,7 +478,7 @@ tape( 'the function returns an iterator for generating pseudorandom numbers from
 	});
 
 	for ( i = 0; i < 1e3; i++ ) {
-		t.equal( rand(), it.next().value, 'returns expected value' );
+		t.strictEqual( rand(), it.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -500,11 +500,11 @@ tape( 'the function supports limiting the number of iterations', function test(
 		r = it.next();
 		j = i + 1;
 		if ( j <= niter ) {
-			t.equal( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, false, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( typeof r.value, 'number', 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, false, 'returns expected `done` value. iteration: '+j );
 		} else {
-			t.equal( r.value, void 0, 'returns expected `value` value. iteration: '+j );
-			t.equal( r.done, true, 'returns expected `done` value. iteration: '+j );
+			t.strictEqual( r.value, void 0, 'returns expected `value` value. iteration: '+j );
+			t.strictEqual( r.done, true, 'returns expected `done` value. iteration: '+j );
 		}
 	}
 	t.end();
@@ -517,20 +517,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -542,20 +542,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -571,18 +571,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterator( 2.0, 5.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
 	t.deepEqual( it2.state, it1.state, 'has expected state' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -596,7 +596,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterator( 2.0, 5.0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.equal( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns a number' );
 	}
 	t.end();
 });
@@ -647,7 +647,7 @@ tape( 'the function supports providing a seeded underlying PRNG', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r1 = it1.next().value;
 		r2 = it2.next().value;
-		t.equal( r1, r2, 'both return same number' );
+		t.strictEqual( r1, r2, 'both return same number' );
 	}
 	t.end();
 });
@@ -680,7 +680,7 @@ tape( 'the function supports specifying the underlying generator state', functio
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -730,8 +730,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -748,8 +748,8 @@ tape( 'the function supports specifying a shared underlying generator state', fu
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -780,7 +780,7 @@ tape( 'the returned iterator supports setting the underlying generator state', f
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/sample/test/test.factory.js b/lib/node_modules/@stdlib/random/sample/test/test.factory.js
index c2628d2b62a8..c5286fc6e36e 100644
--- a/lib/node_modules/@stdlib/random/sample/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/sample/test/test.factory.js
@@ -105,14 +105,14 @@ tape( 'the function allows setting a default `replace` strategy for the returned
 
 	expected = [ 2, 1, 3, 6, 4, 5 ];
 	actual = sample( [ 1, 2, 3, 4, 5, 6 ] );
-	t.equal( actual.length, 6, 'returned array has six elements' );
+	t.strictEqual( actual.length, 6, 'returned array has six elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	expected = [ 6, 5, 6, 6, 6, 3 ];
 	actual = sample( [ 1, 2, 3, 4, 5, 6 ], {
 		'replace': true
 	});
-	t.equal( actual.length, 6, 'returned array has six elements' );
+	t.strictEqual( actual.length, 6, 'returned array has six elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	// When supplying `pool`...
@@ -125,21 +125,21 @@ tape( 'the function allows setting a default `replace` strategy for the returned
 	actual = sample({
 		'replace': true
 	});
-	t.equal( actual.length, 6, 'returned array has six elements' );
+	t.strictEqual( actual.length, 6, 'returned array has six elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	expected = [ 2, 1, 3 ];
 	actual = sample({
 		'size': 3
 	});
-	t.equal( actual.length, 3, 'returned array has three elements' );
+	t.strictEqual( actual.length, 3, 'returned array has three elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	expected = [ 6, 5, 4 ];
 	actual = sample({
 		'size': 3
 	});
-	t.equal( actual.length, 3, 'returned array has three elements' );
+	t.strictEqual( actual.length, 3, 'returned array has three elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	t.end();
@@ -160,7 +160,7 @@ tape( 'the function allows setting a default `mutate` strategy for the returned
 	actual = sample({
 		'size': 3
 	});
-	t.equal( actual.length, 3, 'returned array has three elements' );
+	t.strictEqual( actual.length, 3, 'returned array has three elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	expected = [ 6, 4, 5 ];
@@ -168,14 +168,14 @@ tape( 'the function allows setting a default `mutate` strategy for the returned
 		'size': 3,
 		'mutate': false
 	});
-	t.equal( actual.length, 3, 'returned array has three elements' );
+	t.strictEqual( actual.length, 3, 'returned array has three elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	expected = [ 6, 4, 5 ];
 	actual = sample({
 		'size': 3
 	});
-	t.equal( actual.length, 3, 'returned array has three elements' );
+	t.strictEqual( actual.length, 3, 'returned array has three elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	t.end();
@@ -197,18 +197,18 @@ tape( 'the returned function allows overriding the default mutate strategy', fun
 	actual = sample({
 		'mutate': true
 	});
-	t.equal( actual.length, 3, 'returned array has three elements' );
+	t.strictEqual( actual.length, 3, 'returned array has three elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	expected = [ 6, 4, 5 ];
 	actual = sample({
 		'mutate': true
 	});
-	t.equal( actual.length, 3, 'returned array has three elements' );
+	t.strictEqual( actual.length, 3, 'returned array has three elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	actual = sample();
-	t.equal( actual, null, 'returns null' );
+	t.strictEqual( actual, null, 'returns null' );
 
 	t.end();
 });
@@ -225,7 +225,7 @@ tape( 'the function allows setting a default `size` strategy for the returned fu
 
 	expected = [ 1, 1, 1, 1, 0 ];
 	actual = sample( [ 0, 1 ] );
-	t.equal( actual.length, 5, 'returned array has five elements' );
+	t.strictEqual( actual.length, 5, 'returned array has five elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	sample = factory( [ 0, 1 ], {
@@ -235,7 +235,7 @@ tape( 'the function allows setting a default `size` strategy for the returned fu
 
 	expected = [ 1, 1, 1, 1, 0 ];
 	actual = sample();
-	t.equal( actual.length, 5, 'returned array has five elements' );
+	t.strictEqual( actual.length, 5, 'returned array has five elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	t.end();
@@ -257,7 +257,7 @@ tape( 'the function fixes the population from which to sample when supplied an a
 		'seed': 329
 	});
 	actual = sample();
-	t.equal( actual.length, len, 'returned array has two elements' );
+	t.strictEqual( actual.length, len, 'returned array has two elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	x = 'abcdef';
@@ -269,17 +269,17 @@ tape( 'the function fixes the population from which to sample when supplied an a
 	actual = sample({
 		'size': 3
 	});
-	t.equal( actual.length, 3, 'returned array has three elements' );
+	t.strictEqual( actual.length, 3, 'returned array has three elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	x = [ 0, 1 ];
 	len = x.length;
 	sample = factory( x );
 	actual = sample();
-	t.equal( actual.length, len, 'returned array has two elements' );
+	t.strictEqual( actual.length, len, 'returned array has two elements' );
 	for ( i = 0; i < len; i++ ) {
 		bool = ( actual[i] === 0 || actual[i] === 1 );
-		t.equal( bool, true, 'element is zero or one' );
+		t.strictEqual( bool, true, 'element is zero or one' );
 	}
 
 	x = 'abcdef';
@@ -287,7 +287,7 @@ tape( 'the function fixes the population from which to sample when supplied an a
 	actual = sample({
 		'size': 3
 	});
-	t.equal( actual.length, 3, 'returned array has three elements' );
+	t.strictEqual( actual.length, 3, 'returned array has three elements' );
 	for ( i = 0; i < 3; i++ ) {
 		bool = (
 			actual[i] === 'a' ||
@@ -297,7 +297,7 @@ tape( 'the function fixes the population from which to sample when supplied an a
 			actual[i] === 'e' ||
 			actual[i] === 'f'
 		);
-		t.equal( bool, true, 'element is a, b, c, d, e, or f' );
+		t.strictEqual( bool, true, 'element is a, b, c, d, e, or f' );
 	}
 
 	t.end();
@@ -320,11 +320,11 @@ tape( 'when the population is fixed, the returned function returns `null` after
 	});
 
 	actual = sample();
-	t.equal( actual.length, len, 'returned array has six elements' );
+	t.strictEqual( actual.length, len, 'returned array has six elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	actual = sample();
-	t.equal( actual, null, 'returns null' );
+	t.strictEqual( actual, null, 'returns null' );
 
 	t.end();
 });
@@ -504,14 +504,14 @@ tape( 'attached to the returned function is the generator seed', function test(
 	var sample = factory({
 		'seed': 311
 	});
-	t.equal( isUint32Array( sample.seed ), true, 'has property' );
-	t.equal( sample.seed[ 0 ], 311, 'has expected value' );
+	t.strictEqual( isUint32Array( sample.seed ), true, 'has property' );
+	t.strictEqual( sample.seed[ 0 ], 311, 'has expected value' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var sample = factory();
-	t.equal( typeof sample.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof sample.PRNG, 'function', 'has property' );
 	t.end();
 });
 
@@ -527,8 +527,8 @@ tape( 'the returned function samples characters with replacement from a string',
 	expected = [ 'c', 'c', 'e', 'c', 'b', 'd' ];
 	actual = sample( 'abcdef' );
 
-	t.equal( isStringArray( actual ), true, 'returns an array of characters' );
-	t.equal( actual.length, 6, 'returned array has six elements' );
+	t.strictEqual( isStringArray( actual ), true, 'returns an array of characters' );
+	t.strictEqual( actual.length, 6, 'returned array has six elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	t.end();
@@ -547,16 +547,16 @@ tape( 'the returned function samples with replacement from an array', function t
 	expected = [ 2, 2, 3, 2 ];
 	actual = sample( [ 1, 2, 3, 4 ] );
 
-	t.equal( isNumberArray( actual ), true, 'returns an array of numbers' );
-	t.equal( actual.length, 4, 'returned array has four elements' );
+	t.strictEqual( isNumberArray( actual ), true, 'returns an array of numbers' );
+	t.strictEqual( actual.length, 4, 'returned array has four elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	// Typed array:
 	expected = [ 5, 8, 6, 7, 9 ];
 	actual = sample( new Float64Array( [ 5, 6, 7, 8, 9 ] ) );
 
-	t.equal( isNumberArray( actual ), true, 'returns an array of numbers' );
-	t.equal( actual.length, 5, 'returned array has five elements' );
+	t.strictEqual( isNumberArray( actual ), true, 'returns an array of numbers' );
+	t.strictEqual( actual.length, 5, 'returned array has five elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	t.end();
@@ -583,8 +583,8 @@ tape( 'the returned function samples without replacement from an array', functio
 		'replace': false
 	});
 
-	t.equal( isNumberArray( actual ), true, 'returns an array of numbers' );
-	t.equal( actual.length, 5, 'returned array has five elements' );
+	t.strictEqual( isNumberArray( actual ), true, 'returns an array of numbers' );
+	t.strictEqual( actual.length, 5, 'returned array has five elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	t.end();
@@ -605,8 +605,8 @@ tape( 'the returned function draws a sample with a specified size from an array
 		'size': 10
 	});
 
-	t.equal( isNumberArray( actual ), true, 'returns an array of numbers' );
-	t.equal( actual.length, 10, 'returned array has ten elements' );
+	t.strictEqual( isNumberArray( actual ), true, 'returns an array of numbers' );
+	t.strictEqual( actual.length, 10, 'returned array has ten elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	// Typed array:
@@ -615,8 +615,8 @@ tape( 'the returned function draws a sample with a specified size from an array
 		'size': 10
 	});
 
-	t.equal( isNumberArray( actual ), true, 'returns an array of numbers' );
-	t.equal( actual.length, 10, 'returned array has ten elements' );
+	t.strictEqual( isNumberArray( actual ), true, 'returns an array of numbers' );
+	t.strictEqual( actual.length, 10, 'returned array has ten elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	t.end();
@@ -638,8 +638,8 @@ tape( 'the returned function draws a sample with a specified size from an array
 		'replace': false
 	});
 
-	t.equal( isNumberArray( actual ), true, 'returns an array of numbers' );
-	t.equal( actual.length, 4, 'returned array has four elements' );
+	t.strictEqual( isNumberArray( actual ), true, 'returns an array of numbers' );
+	t.strictEqual( actual.length, 4, 'returned array has four elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	// Typed array:
@@ -649,8 +649,8 @@ tape( 'the returned function draws a sample with a specified size from an array
 		'replace': false
 	});
 
-	t.equal( isNumberArray( actual ), true, 'returns an array of numbers' );
-	t.equal( actual.length, 5, 'returned array has five elements' );
+	t.strictEqual( isNumberArray( actual ), true, 'returns an array of numbers' );
+	t.strictEqual( actual.length, 5, 'returned array has five elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	t.end();
@@ -672,8 +672,8 @@ tape( 'the returned function draws a sample from an array using specified probab
 		'probs': [ 1.0/12.0, 2.0/6.0, 2.0/6.0, 1.0/12.0, 1.0/12.0, 1.0/12.0 ]
 	});
 
-	t.equal( isNumberArray( actual ), true, 'returns an array of numbers' );
-	t.equal( actual.length, 4, 'returned array has four elements' );
+	t.strictEqual( isNumberArray( actual ), true, 'returns an array of numbers' );
+	t.strictEqual( actual.length, 4, 'returned array has four elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	// Typed array:
@@ -683,8 +683,8 @@ tape( 'the returned function draws a sample from an array using specified probab
 		'probs': [ 0.0, 1.0/12.0, 1.0/12.0, 3.0/6.0, 2.0/6.0, 0.0 ]
 	});
 
-	t.equal( isNumberArray( actual ), true, 'returns an array of numbers' );
-	t.equal( actual.length, 5, 'returned array has five elements' );
+	t.strictEqual( isNumberArray( actual ), true, 'returns an array of numbers' );
+	t.strictEqual( actual.length, 5, 'returned array has five elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	expected = [ 1, 2, 1, 2, 1 ];
@@ -693,8 +693,8 @@ tape( 'the returned function draws a sample from an array using specified probab
 		'probs': [ 0.5, 0.2, 0.2, 0.1 ]
 	});
 
-	t.equal( isNumberArray( actual ), true, 'returns an array of numbers' );
-	t.equal( actual.length, 5, 'returned array has five elements' );
+	t.strictEqual( isNumberArray( actual ), true, 'returns an array of numbers' );
+	t.strictEqual( actual.length, 5, 'returned array has five elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	t.end();
@@ -717,8 +717,8 @@ tape( 'the returned function draws a sample from an array using specified probab
 		'replace': false
 	});
 
-	t.equal( isNumberArray( actual ), true, 'returns an array of numbers' );
-	t.equal( actual.length, 3, 'returned array has three elements' );
+	t.strictEqual( isNumberArray( actual ), true, 'returns an array of numbers' );
+	t.strictEqual( actual.length, 3, 'returned array has three elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	// Typed array:
@@ -729,8 +729,8 @@ tape( 'the returned function draws a sample from an array using specified probab
 		'replace': false
 	});
 
-	t.equal( isNumberArray( actual ), true, 'returns an array of numbers' );
-	t.equal( actual.length, 4, 'returned array has four elements' );
+	t.strictEqual( isNumberArray( actual ), true, 'returns an array of numbers' );
+	t.strictEqual( actual.length, 4, 'returned array has four elements' );
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/sample/test/test.js b/lib/node_modules/@stdlib/random/sample/test/test.js
index fdde39ac4273..36e8b1addabf 100644
--- a/lib/node_modules/@stdlib/random/sample/test/test.js
+++ b/lib/node_modules/@stdlib/random/sample/test/test.js
@@ -34,16 +34,16 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory function', function test( t ) {
-	t.equal( typeof sample.factory, 'function', 'has method' );
+	t.strictEqual( typeof sample.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( sample.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( sample.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof sample.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof sample.PRNG, 'function', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/sample/test/test.validate.js b/lib/node_modules/@stdlib/random/sample/test/test.validate.js
index 44a6925b3076..b998948841bc 100644
--- a/lib/node_modules/@stdlib/random/sample/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/sample/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -80,7 +80,7 @@ tape( 'the function returns an error if provided a `probs` option which is not a
 		err = validate( {}, {
 			'probs': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -107,7 +107,7 @@ tape( 'the function returns an error if provided a `size` option which is not a
 		err = validate( {}, {
 			'size': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -175,7 +175,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.strictEqual( obj.mutate, opts.mutate, 'sets mutate option' );
 	t.strictEqual( obj.replace, opts.replace, 'sets replace option' );
 	t.strictEqual( obj.size, opts.size, 'sets size option' );
@@ -194,7 +194,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/shuffle/test/test.factory.js b/lib/node_modules/@stdlib/random/shuffle/test/test.factory.js
index 393c26e68ed5..807903cd3eac 100644
--- a/lib/node_modules/@stdlib/random/shuffle/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/shuffle/test/test.factory.js
@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-/* eslint-disable object-curly-newline, object-curly-spacing, no-new-wrappers */
+/* eslint-disable object-curly-newline, object-curly-spacing */
 
 'use strict';
 
@@ -85,14 +85,14 @@ tape( 'the function allows setting a default `copy` option for created shuffle f
 	actual = shuffle( arr );
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( arr, actual, 'mutates the input array' );
+	t.strictEqual( arr, actual, 'mutates the input array' );
 
 	arr = [ 'a', 'b', 'c' ];
 	expected = [ 'b', 'c', 'a' ];
 	actual = shuffle( arr );
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( arr, actual, 'mutates the input array' );
+	t.strictEqual( arr, actual, 'mutates the input array' );
 
 	// Default option can be overridden:
 	arr = [ 1, 2, 3, 4 ];
@@ -171,13 +171,13 @@ tape( 'the returned function throws an error if provided an invalid option', fun
 
 tape( 'attached to the returned function is the generator seed', function test( t ) {
 	var shuffle = factory();
-	t.equal( isUint32Array( shuffle.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( shuffle.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned function is the underlying PRNG', function test( t ) {
 	var shuffle = factory();
-	t.equal( typeof shuffle.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof shuffle.PRNG, 'function', 'has property' );
 	t.end();
 });
 
@@ -214,7 +214,7 @@ tape( 'the returned function shuffles the elements of an array (creating a shall
 
 	t.deepEqual( actual, expected, 'deep equal' );
 	t.notEqual( actual, arr, 'returns a copy' );
-	t.equal( actual[ 1 ], arr[ 2 ], 'returns a shallow copy' );
+	t.strictEqual( actual[ 1 ], arr[ 2 ], 'returns a shallow copy' );
 
 	t.end();
 });
@@ -282,7 +282,7 @@ tape( 'the returned function shuffles the elements of a typed array', function t
 	expected = new Int32Array( [ 6, 2, 4, 5, 3, 1 ] );
 	actual = shuffle( arr );
 
-	t.equal( constructorName( actual ), 'Int32Array', 'returns a typed array' );
+	t.strictEqual( constructorName( actual ), 'Int32Array', 'returns a typed array' );
 	t.deepEqual( actual, expected, 'deep equal' );
 	t.notEqual( actual, arr, 'returns a copy' );
 	t.end();
@@ -305,7 +305,7 @@ tape( 'the returned function shuffles the elements of an array (in-place)', func
 	});
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( arr, actual, 'mutates the input array' );
+	t.strictEqual( arr, actual, 'mutates the input array' );
 	t.end();
 });
 
@@ -325,8 +325,8 @@ tape( 'the returned function shuffles the elements of a typed array (in-place)',
 		'copy': 'none'
 	});
 
-	t.equal( constructorName( actual ), 'Int32Array', 'returns a typed array' );
+	t.strictEqual( constructorName( actual ), 'Int32Array', 'returns a typed array' );
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( arr, actual, 'mutates the input array' );
+	t.strictEqual( arr, actual, 'mutates the input array' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/shuffle/test/test.js b/lib/node_modules/@stdlib/random/shuffle/test/test.js
index 809f64235235..992008500634 100644
--- a/lib/node_modules/@stdlib/random/shuffle/test/test.js
+++ b/lib/node_modules/@stdlib/random/shuffle/test/test.js
@@ -34,16 +34,16 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory function', function test( t ) {
-	t.equal( typeof shuffle.factory, 'function', 'has method' );
+	t.strictEqual( typeof shuffle.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( shuffle.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( shuffle.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof shuffle.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof shuffle.PRNG, 'function', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/shuffle/test/test.validate.js b/lib/node_modules/@stdlib/random/shuffle/test/test.validate.js
index 9a8a45a87ad4..c8d154d9571d 100644
--- a/lib/node_modules/@stdlib/random/shuffle/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/shuffle/test/test.validate.js
@@ -55,7 +55,7 @@ tape( 'the function returns an error if not provided an options object', functio
 	t.end();
 });
 
-tape( 'the function returns an error if provided a `copy` option which is not equal to `deep`, `shallow` or `none`', function test( t ) {
+tape( 'the function returns an error if provided a `copy` option which is not.strictEqual to `deep`, `shallow` or `none`', function test( t ) {
 	var values;
 	var err;
 	var i;
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided a `copy` option which is not eq
 		err = validate( {}, {
 			'copy': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.strictEqual( obj.copy, opts.copy, 'sets copy option' );
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.factory.js
index 700a326cf5de..4ea6cbfa0547 100644
--- a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -768,7 +768,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -780,7 +780,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -792,7 +792,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -804,7 +804,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.js b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.main.js b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.main.js
index cd21a3a02ac3..106fb44b0f9f 100644
--- a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.main.js
@@ -385,7 +385,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -394,13 +394,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -410,7 +410,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -445,7 +445,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -496,12 +496,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -511,14 +511,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -535,9 +535,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -546,12 +546,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -559,12 +559,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -572,12 +572,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -585,12 +585,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -624,7 +624,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -634,9 +634,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -671,7 +671,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -709,11 +709,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -744,11 +744,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -781,11 +781,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -842,7 +842,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -872,7 +872,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1020,7 +1020,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1107,7 +1107,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1141,7 +1141,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1195,7 +1195,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.object_mode.js
index 73a03ebae561..e3425a626403 100644
--- a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.object_mode.js
@@ -377,13 +377,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -406,7 +406,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -434,7 +434,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.validate.js
index ab2b41fa5efe..bb83f7287f79 100644
--- a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.factory.js
index 8cd33e5e9e18..b5e4164429a6 100644
--- a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 0.3 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 0.3, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -673,7 +673,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -685,7 +685,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -697,7 +697,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -709,7 +709,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.js b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.main.js b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.main.js
index be90c158f10d..4649cc764302 100644
--- a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.main.js
@@ -338,7 +338,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 0.8 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -347,13 +347,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 0.8 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 0.8 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -363,7 +363,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 0.8 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -398,7 +398,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 0.8 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -449,12 +449,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 0.8 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 0.8, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -464,14 +464,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 0.8, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -488,9 +488,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -499,12 +499,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 0.8 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 0.8, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -512,12 +512,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 0.8 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 0.8, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -525,12 +525,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 0.8 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 0.8, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -538,12 +538,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 0.8 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 0.8, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -577,7 +577,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -587,9 +587,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -624,7 +624,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -662,11 +662,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -697,11 +697,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -734,11 +734,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -795,7 +795,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -825,7 +825,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -973,7 +973,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1060,7 +1060,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1094,7 +1094,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1148,7 +1148,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.object_mode.js
index 890c53a0844b..100397622a07 100644
--- a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.object_mode.js
@@ -330,13 +330,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 0.3 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 0.3, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -359,7 +359,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -387,7 +387,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.validate.js
index e40b30e2cd55..56cbd6b26adc 100644
--- a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/beta/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/beta/test/test.factory.js
index ece11cf4699d..d11363e72cb4 100644
--- a/lib/node_modules/@stdlib/random/streams/beta/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/beta/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/beta/test/test.js b/lib/node_modules/@stdlib/random/streams/beta/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/beta/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/beta/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/beta/test/test.main.js b/lib/node_modules/@stdlib/random/streams/beta/test/test.main.js
index f991f1b22bcf..a85c5c60e72f 100644
--- a/lib/node_modules/@stdlib/random/streams/beta/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/beta/test/test.main.js
@@ -367,7 +367,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -376,13 +376,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -392,7 +392,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -427,7 +427,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -478,12 +478,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -493,14 +493,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -517,9 +517,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -528,12 +528,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -541,12 +541,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -554,12 +554,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -567,12 +567,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -616,9 +616,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -653,7 +653,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -691,11 +691,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -726,11 +726,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -763,11 +763,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -824,7 +824,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1002,7 +1002,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1089,7 +1089,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1123,7 +1123,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1177,7 +1177,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/beta/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/beta/test/test.object_mode.js
index 6c60e2a410e5..818a3008b1c3 100644
--- a/lib/node_modules/@stdlib/random/streams/beta/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/beta/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/beta/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/beta/test/test.validate.js
index dffca7084875..8ea631fa473b 100644
--- a/lib/node_modules/@stdlib/random/streams/beta/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/beta/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.factory.js
index ece11cf4699d..d11363e72cb4 100644
--- a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.js b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.main.js b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.main.js
index 4fa27be21ec6..bf4893cf1406 100644
--- a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.main.js
@@ -367,7 +367,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -376,13 +376,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -392,7 +392,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -427,7 +427,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -478,12 +478,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -493,14 +493,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -517,9 +517,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -528,12 +528,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -541,12 +541,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -554,12 +554,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -567,12 +567,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -616,9 +616,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -653,7 +653,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -691,11 +691,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -726,11 +726,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -763,11 +763,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -824,7 +824,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1002,7 +1002,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1089,7 +1089,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1123,7 +1123,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1177,7 +1177,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.object_mode.js
index 6c60e2a410e5..818a3008b1c3 100644
--- a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.validate.js
index dffca7084875..8ea631fa473b 100644
--- a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/binomial/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/binomial/test/test.factory.js
index bc1d5e7922b6..0c9fed4d603f 100644
--- a/lib/node_modules/@stdlib/random/streams/binomial/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/binomial/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 20, 0.3 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 20, 0.3, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -732,7 +732,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 20, 0.3 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 20, 0.3 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -744,7 +744,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 20, 0.3 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 20, 0.3 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -756,7 +756,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 20, 0.3 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -768,7 +768,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 20, 0.3, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/binomial/test/test.js b/lib/node_modules/@stdlib/random/streams/binomial/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/binomial/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/binomial/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/binomial/test/test.main.js b/lib/node_modules/@stdlib/random/streams/binomial/test/test.main.js
index b8d7ac787021..da3acc378542 100644
--- a/lib/node_modules/@stdlib/random/streams/binomial/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/binomial/test/test.main.js
@@ -368,7 +368,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 20, 0.3 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -377,13 +377,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 20, 0.3 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 20, 0.3 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -393,7 +393,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 20, 0.3 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -428,7 +428,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 20, 0.3 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -479,12 +479,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 20, 0.3 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 20, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -494,14 +494,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 20, 0.3, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -518,9 +518,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -529,12 +529,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 20, 0.3 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 20, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -542,12 +542,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 20, 0.3 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 20, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -555,12 +555,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 20, 0.3 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 20, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -568,12 +568,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 20, 0.3 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 20, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -607,7 +607,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -617,9 +617,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -654,7 +654,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -692,11 +692,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -727,11 +727,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -764,11 +764,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -825,7 +825,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -855,7 +855,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1003,7 +1003,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1090,7 +1090,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1124,7 +1124,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1178,7 +1178,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/binomial/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/binomial/test/test.object_mode.js
index fc4bf35582d6..b9f3e6a2f0c2 100644
--- a/lib/node_modules/@stdlib/random/streams/binomial/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/binomial/test/test.object_mode.js
@@ -360,13 +360,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 20, 0.3 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 20, 0.3, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -389,7 +389,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -417,7 +417,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/binomial/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/binomial/test/test.validate.js
index 65ef0d0074c4..d96263f01468 100644
--- a/lib/node_modules/@stdlib/random/streams/binomial/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/binomial/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.factory.js
index 427823cdce60..cdefd1890517 100644
--- a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.factory.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -324,7 +324,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -336,7 +336,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.js b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.main.js b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.main.js
index 7010bd5e12e4..b431fb602a16 100644
--- a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.main.js
@@ -307,7 +307,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -316,13 +316,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream();
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -332,7 +332,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -367,7 +367,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -418,12 +418,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream();
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -433,14 +433,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -457,9 +457,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -468,12 +468,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream();
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -481,12 +481,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream();
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -494,12 +494,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream();
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -507,12 +507,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream();
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -546,7 +546,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -556,9 +556,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -593,7 +593,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -631,11 +631,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -666,11 +666,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -703,11 +703,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -764,7 +764,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -794,7 +794,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -942,7 +942,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1029,7 +1029,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1063,7 +1063,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1117,7 +1117,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.object_mode.js
index e6c6ca8fdd5a..5a1cf92647a8 100644
--- a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.object_mode.js
@@ -299,13 +299,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -328,7 +328,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -356,7 +356,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.validate.js
index ab2b41fa5efe..bb83f7287f79 100644
--- a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.factory.js
index 501dda5f8618..6f8ee34a5581 100644
--- a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.js b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.main.js b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.main.js
index b514c12a92f3..120012911741 100644
--- a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.main.js
@@ -365,7 +365,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -374,13 +374,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -390,7 +390,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -425,7 +425,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -476,12 +476,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -491,14 +491,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -515,9 +515,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -526,12 +526,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -539,12 +539,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -552,12 +552,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -565,12 +565,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -614,9 +614,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -651,7 +651,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -689,11 +689,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -724,11 +724,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -761,11 +761,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -822,7 +822,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1000,7 +1000,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1087,7 +1087,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1121,7 +1121,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1175,7 +1175,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.object_mode.js
index 1e7d90f891dd..a6b7c43953f8 100644
--- a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -386,7 +386,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -414,7 +414,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.validate.js
index 5fd3b678fd88..9e65113c7eb6 100644
--- a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/chi/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/chi/test/test.factory.js
index 89f6f18696a5..f7abe486db00 100644
--- a/lib/node_modules/@stdlib/random/streams/chi/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/chi/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 3.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 3.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -670,7 +670,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -682,7 +682,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -694,7 +694,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -706,7 +706,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/chi/test/test.js b/lib/node_modules/@stdlib/random/streams/chi/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/chi/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/chi/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/chi/test/test.main.js b/lib/node_modules/@stdlib/random/streams/chi/test/test.main.js
index 02de2696f171..4ccbc76ab0d0 100644
--- a/lib/node_modules/@stdlib/random/streams/chi/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/chi/test/test.main.js
@@ -337,7 +337,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -346,13 +346,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 3.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -362,7 +362,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -397,7 +397,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -448,12 +448,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -463,14 +463,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 3.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -487,9 +487,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -498,12 +498,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -511,12 +511,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -524,12 +524,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -537,12 +537,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -576,7 +576,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -586,9 +586,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -623,7 +623,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -661,11 +661,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -696,11 +696,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -733,11 +733,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -794,7 +794,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -824,7 +824,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -972,7 +972,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1059,7 +1059,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1093,7 +1093,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1147,7 +1147,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/chi/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/chi/test/test.object_mode.js
index f0e1d4d75acf..b6203a053b66 100644
--- a/lib/node_modules/@stdlib/random/streams/chi/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/chi/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 1.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 1.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/chi/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/chi/test/test.validate.js
index 64edbf0036db..a6daed8d715c 100644
--- a/lib/node_modules/@stdlib/random/streams/chi/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/chi/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.factory.js
index 89f6f18696a5..f7abe486db00 100644
--- a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 3.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 3.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -670,7 +670,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -682,7 +682,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -694,7 +694,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -706,7 +706,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.js b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.main.js b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.main.js
index 3c845a12cebe..8122e62ba672 100644
--- a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.main.js
@@ -337,7 +337,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -346,13 +346,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 3.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -362,7 +362,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -397,7 +397,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -448,12 +448,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -463,14 +463,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 3.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -487,9 +487,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -498,12 +498,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -511,12 +511,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -524,12 +524,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -537,12 +537,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -576,7 +576,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -586,9 +586,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -623,7 +623,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -661,11 +661,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -696,11 +696,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -733,11 +733,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -794,7 +794,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -824,7 +824,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -972,7 +972,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1059,7 +1059,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1093,7 +1093,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1147,7 +1147,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.object_mode.js
index f0e1d4d75acf..b6203a053b66 100644
--- a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 1.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 1.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.validate.js
index 8e8bf0efa6c8..8edb325e7974 100644
--- a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/cosine/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/cosine/test/test.factory.js
index 4e51b866fd12..1f3ef0aea13e 100644
--- a/lib/node_modules/@stdlib/random/streams/cosine/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/cosine/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/cosine/test/test.js b/lib/node_modules/@stdlib/random/streams/cosine/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/cosine/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/cosine/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/cosine/test/test.main.js b/lib/node_modules/@stdlib/random/streams/cosine/test/test.main.js
index a5ed895da4c3..414c139e64a2 100644
--- a/lib/node_modules/@stdlib/random/streams/cosine/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/cosine/test/test.main.js
@@ -365,7 +365,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -374,13 +374,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -390,7 +390,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -425,7 +425,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -476,12 +476,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -491,14 +491,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -515,9 +515,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -526,12 +526,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -539,12 +539,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -552,12 +552,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -565,12 +565,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -614,9 +614,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -651,7 +651,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -689,11 +689,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -724,11 +724,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -761,11 +761,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -822,7 +822,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1000,7 +1000,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1087,7 +1087,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1121,7 +1121,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1175,7 +1175,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/cosine/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/cosine/test/test.object_mode.js
index ed4e16cf3721..c4c067adad6c 100644
--- a/lib/node_modules/@stdlib/random/streams/cosine/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/cosine/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -386,7 +386,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -414,7 +414,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/cosine/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/cosine/test/test.validate.js
index 959496471f48..0592d843660e 100644
--- a/lib/node_modules/@stdlib/random/streams/cosine/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/cosine/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.factory.js
index f807c7948b84..90328dc32bce 100644
--- a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2, 5 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2, 5, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -772,7 +772,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2, 5 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2, 5 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -784,7 +784,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2, 5 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2, 5 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -796,7 +796,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2, 5 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -808,7 +808,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2, 5, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.js b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.main.js b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.main.js
index b0a9036df338..9be7382d63d6 100644
--- a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.main.js
@@ -387,7 +387,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2, 5 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -396,13 +396,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2, 5 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2, 5 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -412,7 +412,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2, 5 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -447,7 +447,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2, 5 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -498,12 +498,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2, 5 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2, 5, {
 		'prng': minstd
 	});
-	t.equal( s.PRNG, minstd, 'has property' );
+	t.strictEqual( s.PRNG, minstd, 'has property' );
 
 	t.end();
 });
@@ -513,14 +513,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2, 5, {
 		'seed': 12345,
 		'prng': minstd
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -537,9 +537,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -548,12 +548,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2, 5 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2, 5, {
 		'prng': minstd
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -561,12 +561,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2, 5 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2, 5, {
 		'prng': minstd
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -574,12 +574,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2, 5 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2, 5, {
 		'prng': minstd
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -587,12 +587,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2, 5 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2, 5, {
 		'prng': minstd
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -626,7 +626,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -636,9 +636,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -673,7 +673,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -711,11 +711,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -746,11 +746,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -783,11 +783,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -844,7 +844,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -874,7 +874,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1022,7 +1022,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1109,7 +1109,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1143,7 +1143,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1197,7 +1197,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.object_mode.js
index 3da88d926080..6c8882251723 100644
--- a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.object_mode.js
@@ -379,13 +379,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2, 5 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2, 5, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -408,7 +408,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -436,7 +436,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.validate.js
index d1f67a27dca0..155c1dad8b5e 100644
--- a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/erlang/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/erlang/test/test.factory.js
index e6a9d0e8b037..bd56b7edc748 100644
--- a/lib/node_modules/@stdlib/random/streams/erlang/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/erlang/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -732,7 +732,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -744,7 +744,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -756,7 +756,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -768,7 +768,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/erlang/test/test.js b/lib/node_modules/@stdlib/random/streams/erlang/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/erlang/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/erlang/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/erlang/test/test.main.js b/lib/node_modules/@stdlib/random/streams/erlang/test/test.main.js
index 5afd52621e16..73c9f4582453 100644
--- a/lib/node_modules/@stdlib/random/streams/erlang/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/erlang/test/test.main.js
@@ -368,7 +368,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -377,13 +377,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -393,7 +393,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -428,7 +428,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -479,12 +479,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -494,14 +494,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -518,9 +518,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -529,12 +529,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -542,12 +542,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -555,12 +555,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -568,12 +568,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -607,7 +607,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -617,9 +617,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -654,7 +654,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -692,11 +692,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -727,11 +727,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -764,11 +764,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -825,7 +825,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -855,7 +855,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1003,7 +1003,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1090,7 +1090,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1124,7 +1124,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1178,7 +1178,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/erlang/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/erlang/test/test.object_mode.js
index 267f5a09c3c6..fd1297811e7f 100644
--- a/lib/node_modules/@stdlib/random/streams/erlang/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/erlang/test/test.object_mode.js
@@ -360,13 +360,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -389,7 +389,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -417,7 +417,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/erlang/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/erlang/test/test.validate.js
index 579a4735c2ae..06d6688fb1aa 100644
--- a/lib/node_modules/@stdlib/random/streams/erlang/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/erlang/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/exponential/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/exponential/test/test.factory.js
index 0b9cd76c41ec..e0453fff2d3c 100644
--- a/lib/node_modules/@stdlib/random/streams/exponential/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/exponential/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 3.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 3.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -670,7 +670,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -682,7 +682,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -694,7 +694,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -706,7 +706,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/exponential/test/test.js b/lib/node_modules/@stdlib/random/streams/exponential/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/exponential/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/exponential/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/exponential/test/test.main.js b/lib/node_modules/@stdlib/random/streams/exponential/test/test.main.js
index 319d2b97581a..b5f4a8951890 100644
--- a/lib/node_modules/@stdlib/random/streams/exponential/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/exponential/test/test.main.js
@@ -337,7 +337,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -346,13 +346,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 3.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -362,7 +362,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -397,7 +397,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -448,12 +448,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -463,14 +463,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 3.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -487,9 +487,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -498,12 +498,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -511,12 +511,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -524,12 +524,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -537,12 +537,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -576,7 +576,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -586,9 +586,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -623,7 +623,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -661,11 +661,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -696,11 +696,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -733,11 +733,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -794,7 +794,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -824,7 +824,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -972,7 +972,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1059,7 +1059,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1093,7 +1093,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1147,7 +1147,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/exponential/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/exponential/test/test.object_mode.js
index c1246ff18783..14e728f19773 100644
--- a/lib/node_modules/@stdlib/random/streams/exponential/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/exponential/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 1.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 1.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/exponential/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/exponential/test/test.validate.js
index 96a10fcbd1a1..3f37d0a09b6a 100644
--- a/lib/node_modules/@stdlib/random/streams/exponential/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/exponential/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/f/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/f/test/test.factory.js
index 7548ae3de51e..c7158693d10f 100644
--- a/lib/node_modules/@stdlib/random/streams/f/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/f/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/f/test/test.js b/lib/node_modules/@stdlib/random/streams/f/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/f/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/f/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/f/test/test.main.js b/lib/node_modules/@stdlib/random/streams/f/test/test.main.js
index 57e21092555d..d5a9a72fd330 100644
--- a/lib/node_modules/@stdlib/random/streams/f/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/f/test/test.main.js
@@ -367,7 +367,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -376,13 +376,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -392,7 +392,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -427,7 +427,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -478,12 +478,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -493,14 +493,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -517,9 +517,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -528,12 +528,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -541,12 +541,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -554,12 +554,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -567,12 +567,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -616,9 +616,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -653,7 +653,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -691,11 +691,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -726,11 +726,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -763,11 +763,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -824,7 +824,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1002,7 +1002,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1089,7 +1089,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1123,7 +1123,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1177,7 +1177,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/f/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/f/test/test.object_mode.js
index 772188efdf84..a33f739e7c5a 100644
--- a/lib/node_modules/@stdlib/random/streams/f/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/f/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/f/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/f/test/test.validate.js
index d61fd1ed279a..1ccfc8d09f4a 100644
--- a/lib/node_modules/@stdlib/random/streams/f/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/f/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/frechet/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/frechet/test/test.factory.js
index 29d456071a88..b4ddbdfc2666 100644
--- a/lib/node_modules/@stdlib/random/streams/frechet/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/frechet/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, 3.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, 3.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -788,7 +788,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0, 3.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0, 3.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -800,7 +800,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0, 3.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0, 3.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -812,7 +812,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, 3.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -824,7 +824,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, 3.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/frechet/test/test.js b/lib/node_modules/@stdlib/random/streams/frechet/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/frechet/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/frechet/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/frechet/test/test.main.js b/lib/node_modules/@stdlib/random/streams/frechet/test/test.main.js
index e71fed0d6d28..2cc29ec60767 100644
--- a/lib/node_modules/@stdlib/random/streams/frechet/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/frechet/test/test.main.js
@@ -395,7 +395,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0, 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -404,13 +404,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0, 3.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0, 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -420,7 +420,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0, 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -455,7 +455,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0, 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -506,12 +506,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0, 3.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -521,14 +521,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, 3.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -545,9 +545,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -556,12 +556,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0, 3.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -569,12 +569,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0, 3.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -582,12 +582,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0, 3.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -595,12 +595,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0, 3.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -634,7 +634,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -644,9 +644,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -681,7 +681,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -719,11 +719,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -754,11 +754,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -791,11 +791,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -852,7 +852,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -882,7 +882,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1030,7 +1030,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1117,7 +1117,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1151,7 +1151,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1205,7 +1205,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/frechet/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/frechet/test/test.object_mode.js
index 83183c861f9c..f73f2e9abfa7 100644
--- a/lib/node_modules/@stdlib/random/streams/frechet/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/frechet/test/test.object_mode.js
@@ -387,13 +387,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0, 3.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, 3.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -416,7 +416,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -444,7 +444,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/frechet/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/frechet/test/test.validate.js
index b683bf7a6d78..36aabcd247d5 100644
--- a/lib/node_modules/@stdlib/random/streams/frechet/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/frechet/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/gamma/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/gamma/test/test.factory.js
index e51ab8bed425..4105d7ccb153 100644
--- a/lib/node_modules/@stdlib/random/streams/gamma/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/gamma/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/gamma/test/test.js b/lib/node_modules/@stdlib/random/streams/gamma/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/gamma/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/gamma/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/gamma/test/test.main.js b/lib/node_modules/@stdlib/random/streams/gamma/test/test.main.js
index 2cff4df965ae..ee6988a1b189 100644
--- a/lib/node_modules/@stdlib/random/streams/gamma/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/gamma/test/test.main.js
@@ -367,7 +367,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -376,13 +376,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -392,7 +392,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -427,7 +427,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -478,12 +478,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -493,14 +493,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -517,9 +517,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -528,12 +528,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -541,12 +541,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -554,12 +554,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -567,12 +567,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -616,9 +616,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -653,7 +653,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -691,11 +691,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -726,11 +726,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -763,11 +763,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -824,7 +824,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1002,7 +1002,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1089,7 +1089,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1123,7 +1123,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1177,7 +1177,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/gamma/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/gamma/test/test.object_mode.js
index 88ee00ba6767..e5216fb0eccb 100644
--- a/lib/node_modules/@stdlib/random/streams/gamma/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/gamma/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/gamma/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/gamma/test/test.validate.js
index 29201567cc25..7134a838b6e0 100644
--- a/lib/node_modules/@stdlib/random/streams/gamma/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/gamma/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/geometric/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/geometric/test/test.factory.js
index 8cd33e5e9e18..b5e4164429a6 100644
--- a/lib/node_modules/@stdlib/random/streams/geometric/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/geometric/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 0.3 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 0.3, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -673,7 +673,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -685,7 +685,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -697,7 +697,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -709,7 +709,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/geometric/test/test.js b/lib/node_modules/@stdlib/random/streams/geometric/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/geometric/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/geometric/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/geometric/test/test.main.js b/lib/node_modules/@stdlib/random/streams/geometric/test/test.main.js
index 74e60fc5e504..09dcd7183da5 100644
--- a/lib/node_modules/@stdlib/random/streams/geometric/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/geometric/test/test.main.js
@@ -338,7 +338,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 0.8 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -347,13 +347,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 0.8 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 0.8 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -363,7 +363,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 0.8 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -398,7 +398,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 0.8 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -449,12 +449,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 0.8 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 0.8, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -464,14 +464,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 0.8, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -488,9 +488,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -499,12 +499,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 0.8 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 0.8, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -512,12 +512,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 0.8 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 0.8, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -525,12 +525,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 0.8 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 0.8, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -538,12 +538,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 0.8 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 0.8, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -577,7 +577,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -587,9 +587,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -624,7 +624,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -662,11 +662,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -697,11 +697,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -734,11 +734,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -795,7 +795,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -825,7 +825,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -973,7 +973,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1060,7 +1060,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1094,7 +1094,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1148,7 +1148,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/geometric/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/geometric/test/test.object_mode.js
index 890c53a0844b..100397622a07 100644
--- a/lib/node_modules/@stdlib/random/streams/geometric/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/geometric/test/test.object_mode.js
@@ -330,13 +330,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 0.3 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 0.3, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -359,7 +359,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -387,7 +387,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/geometric/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/geometric/test/test.validate.js
index d5f197e867cc..8c6a311db403 100644
--- a/lib/node_modules/@stdlib/random/streams/geometric/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/geometric/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.factory.js
index 4ed64ebcaa5f..f20cf72bc7fd 100644
--- a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.js b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.main.js b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.main.js
index 48288b2f7dca..eafbd8319484 100644
--- a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.main.js
@@ -365,7 +365,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -374,13 +374,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -390,7 +390,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -425,7 +425,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -476,12 +476,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -491,14 +491,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -515,9 +515,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -526,12 +526,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -539,12 +539,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -552,12 +552,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -565,12 +565,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -614,9 +614,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -651,7 +651,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -689,11 +689,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -724,11 +724,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -761,11 +761,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -822,7 +822,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1000,7 +1000,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1087,7 +1087,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1121,7 +1121,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1175,7 +1175,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.object_mode.js
index d02331464943..085d0c087f1e 100644
--- a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -386,7 +386,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -414,7 +414,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.validate.js
index 342e80ee1255..80eb94597d0d 100644
--- a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.factory.js
index babc410cb9f6..2e8db6b590f8 100644
--- a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 20, 10, 7 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 20, 10, 7, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -890,7 +890,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 20, 10, 7 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 20, 10, 7 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -902,7 +902,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 20, 10, 7 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 20, 10, 7 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -914,7 +914,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 20, 10, 7 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -926,7 +926,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 20, 10, 7, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.js b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.main.js b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.main.js
index 5b29c0ea26bb..703d54cb1ab1 100644
--- a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.main.js
@@ -444,7 +444,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 20, 10, 7 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -453,13 +453,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 20, 10, 7 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 20, 10, 7 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -469,7 +469,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 20, 10, 7 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -504,7 +504,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 20, 10, 7 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -555,12 +555,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 20, 10, 7 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 20, 10, 7, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -570,14 +570,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 20, 10, 7, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -594,9 +594,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -605,12 +605,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 20, 10, 7 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 20, 10, 7, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -618,12 +618,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 20, 10, 7 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 20, 10, 7, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -631,12 +631,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 20, 10, 7 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 20, 10, 7, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -644,12 +644,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 20, 10, 7 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 20, 10, 7, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -683,7 +683,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -693,9 +693,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -730,7 +730,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -768,11 +768,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -803,11 +803,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -840,11 +840,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -901,7 +901,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -931,7 +931,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1079,7 +1079,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1166,7 +1166,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1200,7 +1200,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1254,7 +1254,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.object_mode.js
index 3ecf710cce90..f7510b11ec7e 100644
--- a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.object_mode.js
@@ -436,13 +436,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 20, 10, 7 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 20, 10, 7, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -465,7 +465,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -493,7 +493,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.validate.js
index d5fdec6f04cc..5a170fd9636a 100644
--- a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.factory.js
index 427823cdce60..cdefd1890517 100644
--- a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.factory.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -324,7 +324,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -336,7 +336,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.js b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.main.js b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.main.js
index 268eb322d740..e31a4907198c 100644
--- a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.main.js
@@ -307,7 +307,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -316,13 +316,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream();
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -332,7 +332,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -367,7 +367,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -418,12 +418,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream();
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -433,14 +433,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -457,9 +457,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -468,12 +468,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream();
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -481,12 +481,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream();
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -494,12 +494,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream();
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -507,12 +507,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream();
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -546,7 +546,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -556,9 +556,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -593,7 +593,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -631,11 +631,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -666,11 +666,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -703,11 +703,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -764,7 +764,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -794,7 +794,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -942,7 +942,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1029,7 +1029,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1063,7 +1063,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1117,7 +1117,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.object_mode.js
index e6c6ca8fdd5a..5a1cf92647a8 100644
--- a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.object_mode.js
@@ -299,13 +299,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -328,7 +328,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -356,7 +356,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.validate.js
index ab2b41fa5efe..bb83f7287f79 100644
--- a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.factory.js
index 2935bea731f8..587b2077bfae 100644
--- a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.js b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.main.js b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.main.js
index f5f7a1ca85e7..ab20faeeadc5 100644
--- a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.main.js
@@ -367,7 +367,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -376,13 +376,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -392,7 +392,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -427,7 +427,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -478,12 +478,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -493,14 +493,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -517,9 +517,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -528,12 +528,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -541,12 +541,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -554,12 +554,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -567,12 +567,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -616,9 +616,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -653,7 +653,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -691,11 +691,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -726,11 +726,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -763,11 +763,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -824,7 +824,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1002,7 +1002,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1089,7 +1089,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1123,7 +1123,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1177,7 +1177,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.object_mode.js
index d98cceed4732..7bf092096ed8 100644
--- a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.validate.js
index 6b74b0550733..766af4795dd5 100644
--- a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.factory.js
index 6962f27e05e0..860ce252181d 100644
--- a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -730,7 +730,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -742,7 +742,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -754,7 +754,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -766,7 +766,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.js b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.main.js b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.main.js
index ae506f955f47..97686295dcd2 100644
--- a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.main.js
@@ -367,7 +367,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -376,13 +376,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -392,7 +392,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -427,7 +427,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -478,12 +478,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -493,14 +493,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -517,9 +517,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -528,12 +528,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -541,12 +541,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -554,12 +554,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -567,12 +567,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -616,9 +616,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -653,7 +653,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -691,11 +691,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -726,11 +726,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -763,11 +763,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -824,7 +824,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1002,7 +1002,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1089,7 +1089,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1123,7 +1123,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1177,7 +1177,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.object_mode.js
index 6777b3d44261..754035543c89 100644
--- a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.validate.js
index b6b61345ae18..a0fa38d4e64d 100644
--- a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/laplace/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/laplace/test/test.factory.js
index 16ee83139060..779baca0b3d6 100644
--- a/lib/node_modules/@stdlib/random/streams/laplace/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/laplace/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/laplace/test/test.js b/lib/node_modules/@stdlib/random/streams/laplace/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/laplace/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/laplace/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/laplace/test/test.main.js b/lib/node_modules/@stdlib/random/streams/laplace/test/test.main.js
index 59c92b2eac0f..65a1d9b3e3e0 100644
--- a/lib/node_modules/@stdlib/random/streams/laplace/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/laplace/test/test.main.js
@@ -365,7 +365,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -374,13 +374,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -390,7 +390,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -425,7 +425,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -476,12 +476,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -491,14 +491,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -515,9 +515,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -526,12 +526,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -539,12 +539,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -552,12 +552,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -565,12 +565,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -614,9 +614,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -651,7 +651,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -689,11 +689,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -724,11 +724,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -761,11 +761,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -822,7 +822,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1000,7 +1000,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1087,7 +1087,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1121,7 +1121,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1175,7 +1175,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/laplace/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/laplace/test/test.object_mode.js
index f560dd1bb873..fb6a8287f44c 100644
--- a/lib/node_modules/@stdlib/random/streams/laplace/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/laplace/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -386,7 +386,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -414,7 +414,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/laplace/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/laplace/test/test.validate.js
index 488b9c834a16..681ae29065bc 100644
--- a/lib/node_modules/@stdlib/random/streams/laplace/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/laplace/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/levy/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/levy/test/test.factory.js
index e9ef57c3146c..e6643169e60b 100644
--- a/lib/node_modules/@stdlib/random/streams/levy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/levy/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/levy/test/test.js b/lib/node_modules/@stdlib/random/streams/levy/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/levy/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/levy/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/levy/test/test.main.js b/lib/node_modules/@stdlib/random/streams/levy/test/test.main.js
index c1ab048ca2c8..803f2b274dd2 100644
--- a/lib/node_modules/@stdlib/random/streams/levy/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/levy/test/test.main.js
@@ -365,7 +365,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -374,13 +374,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -390,7 +390,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -425,7 +425,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -476,12 +476,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -491,14 +491,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -515,9 +515,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -526,12 +526,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -539,12 +539,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -552,12 +552,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -565,12 +565,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -614,9 +614,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -651,7 +651,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -689,11 +689,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -724,11 +724,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -761,11 +761,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -822,7 +822,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1000,7 +1000,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1087,7 +1087,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1121,7 +1121,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1175,7 +1175,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/levy/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/levy/test/test.object_mode.js
index 1c298c92aeb8..e8476849d0b4 100644
--- a/lib/node_modules/@stdlib/random/streams/levy/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/levy/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -386,7 +386,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -414,7 +414,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/levy/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/levy/test/test.validate.js
index dffca7084875..8ea631fa473b 100644
--- a/lib/node_modules/@stdlib/random/streams/levy/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/levy/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/logistic/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/logistic/test/test.factory.js
index fcae3bf650f3..a3872c01b590 100644
--- a/lib/node_modules/@stdlib/random/streams/logistic/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/logistic/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/logistic/test/test.js b/lib/node_modules/@stdlib/random/streams/logistic/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/logistic/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/logistic/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/logistic/test/test.main.js b/lib/node_modules/@stdlib/random/streams/logistic/test/test.main.js
index 44f772897974..a47b971961e0 100644
--- a/lib/node_modules/@stdlib/random/streams/logistic/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/logistic/test/test.main.js
@@ -365,7 +365,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -374,13 +374,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -390,7 +390,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -425,7 +425,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -476,12 +476,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -491,14 +491,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -515,9 +515,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -526,12 +526,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -539,12 +539,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -552,12 +552,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -565,12 +565,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -614,9 +614,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -651,7 +651,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -689,11 +689,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -724,11 +724,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -761,11 +761,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -822,7 +822,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1000,7 +1000,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1087,7 +1087,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1121,7 +1121,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1175,7 +1175,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/logistic/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/logistic/test/test.object_mode.js
index ea4f40d6c8c2..676878d668e6 100644
--- a/lib/node_modules/@stdlib/random/streams/logistic/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/logistic/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -386,7 +386,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -414,7 +414,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/logistic/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/logistic/test/test.validate.js
index dffca7084875..8ea631fa473b 100644
--- a/lib/node_modules/@stdlib/random/streams/logistic/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/logistic/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.factory.js
index 596b747f77ac..0eae2a723807 100644
--- a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.js b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.main.js b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.main.js
index a3f59e7def9c..5d845a2f8434 100644
--- a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.main.js
@@ -365,7 +365,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -374,13 +374,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -390,7 +390,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -425,7 +425,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -476,12 +476,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -491,14 +491,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -515,9 +515,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -526,12 +526,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -539,12 +539,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -552,12 +552,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -565,12 +565,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -614,9 +614,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -651,7 +651,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -689,11 +689,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -724,11 +724,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -761,11 +761,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -822,7 +822,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1000,7 +1000,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1087,7 +1087,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1121,7 +1121,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1175,7 +1175,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.object_mode.js
index 0ce2e0190e8b..eaead34f6c12 100644
--- a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -386,7 +386,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -414,7 +414,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.validate.js
index ae27a15cd9dc..f2ef14f9bbad 100644
--- a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.factory.js
index 0aaebaf5a67c..0197520259a6 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.factory.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -323,7 +323,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -335,7 +335,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.js b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.main.js b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.main.js
index 82f486819e29..0a8dd3aad551 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.main.js
@@ -305,7 +305,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -314,13 +314,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream();
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -330,7 +330,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -365,7 +365,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -418,8 +418,8 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isInt32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isInt32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	t.end();
 });
@@ -436,9 +436,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isInt32Array( actual ), true, 'has property' );
+	t.strictEqual( isInt32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -446,25 +446,25 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream();
-	t.equal( isInt32Array( s.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( s.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -497,7 +497,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers via
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -507,9 +507,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers via
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -546,7 +546,7 @@ tape( 'the constructor returns a stream for generating normalized pseudorandom n
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -556,9 +556,9 @@ tape( 'the constructor returns a stream for generating normalized pseudorandom n
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -593,7 +593,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers via
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -636,7 +636,7 @@ tape( 'the constructor returns a stream for generating normalized pseudorandom n
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -674,11 +674,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -709,11 +709,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -746,11 +746,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -807,7 +807,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -889,7 +889,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -976,7 +976,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1010,7 +1010,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1064,7 +1064,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.object_mode.js
index 833c2708d153..14f71e4fd3ac 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.object_mode.js
@@ -299,13 +299,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -328,8 +328,8 @@ tape( 'the function returns a stream which streams integers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
-		t.equal( isInteger( v ), true, 'returns an integer' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( isInteger( v ), true, 'returns an integer' );
 	}
 
 	function onEnd() {
@@ -357,8 +357,8 @@ tape( 'the function supports returning a stream which streams normalized numbers
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
-		t.equal( v >= 0.0 && v < 1.0, true, 'returns expected range' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns expected range' );
 	}
 
 	function onEnd() {
@@ -386,7 +386,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.validate.js
index bb8760a8bb23..d64aa094d4c3 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `normalized` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/minstd/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/minstd/test/test.factory.js
index 0aaebaf5a67c..0197520259a6 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd/test/test.factory.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -323,7 +323,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -335,7 +335,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/minstd/test/test.js b/lib/node_modules/@stdlib/random/streams/minstd/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/minstd/test/test.main.js b/lib/node_modules/@stdlib/random/streams/minstd/test/test.main.js
index 09d7439414d9..c463a932abcd 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd/test/test.main.js
@@ -305,7 +305,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -314,13 +314,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream();
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -330,7 +330,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -365,7 +365,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -418,8 +418,8 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isInt32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isInt32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	t.end();
 });
@@ -436,9 +436,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isInt32Array( actual ), true, 'has property' );
+	t.strictEqual( isInt32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -446,25 +446,25 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream();
-	t.equal( isInt32Array( s.state ), true, 'has property' );
+	t.strictEqual( isInt32Array( s.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -497,7 +497,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers via
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -507,9 +507,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers via
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -546,7 +546,7 @@ tape( 'the constructor returns a stream for generating normalized pseudorandom n
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -556,9 +556,9 @@ tape( 'the constructor returns a stream for generating normalized pseudorandom n
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -593,7 +593,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers via
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -636,7 +636,7 @@ tape( 'the constructor returns a stream for generating normalized pseudorandom n
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -674,11 +674,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -709,11 +709,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -746,11 +746,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -807,7 +807,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -889,7 +889,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -976,7 +976,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1010,7 +1010,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1064,7 +1064,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/minstd/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/minstd/test/test.object_mode.js
index 833c2708d153..14f71e4fd3ac 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd/test/test.object_mode.js
@@ -299,13 +299,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -328,8 +328,8 @@ tape( 'the function returns a stream which streams integers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
-		t.equal( isInteger( v ), true, 'returns an integer' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( isInteger( v ), true, 'returns an integer' );
 	}
 
 	function onEnd() {
@@ -357,8 +357,8 @@ tape( 'the function supports returning a stream which streams normalized numbers
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
-		t.equal( v >= 0.0 && v < 1.0, true, 'returns expected range' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns expected range' );
 	}
 
 	function onEnd() {
@@ -386,7 +386,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/minstd/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/minstd/test/test.validate.js
index bb8760a8bb23..d64aa094d4c3 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `normalized` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.factory.js
index 0498616a9645..6fa3ce13d03c 100644
--- a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.factory.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -323,7 +323,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -335,7 +335,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.js b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.main.js b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.main.js
index ad309b337920..6464305bb98b 100644
--- a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.main.js
@@ -305,7 +305,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -314,13 +314,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream();
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -330,7 +330,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -365,7 +365,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -418,8 +418,8 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	t.end();
 });
@@ -436,9 +436,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -446,25 +446,25 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream();
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -497,7 +497,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers via
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -507,9 +507,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers via
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -546,7 +546,7 @@ tape( 'the constructor returns a stream for generating normalized pseudorandom n
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -556,9 +556,9 @@ tape( 'the constructor returns a stream for generating normalized pseudorandom n
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -593,7 +593,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers via
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -636,7 +636,7 @@ tape( 'the constructor returns a stream for generating normalized pseudorandom n
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -674,11 +674,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -709,11 +709,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -746,11 +746,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -807,7 +807,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -889,7 +889,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -976,7 +976,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1010,7 +1010,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1064,7 +1064,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.object_mode.js
index 18c8dadb4325..58a3ab549434 100644
--- a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.object_mode.js
@@ -299,13 +299,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -328,8 +328,8 @@ tape( 'the function returns a stream which streams integers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
-		t.equal( isInteger( v ), true, 'returns an integer' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( isInteger( v ), true, 'returns an integer' );
 	}
 
 	function onEnd() {
@@ -357,8 +357,8 @@ tape( 'the function supports returning a stream which streams normalized numbers
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
-		t.equal( v >= 0.0 && v < 1.0, true, 'returns expected range' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns expected range' );
 	}
 
 	function onEnd() {
@@ -386,7 +386,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.validate.js
index 7133ade03566..81da4f1f30da 100644
--- a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `normalized` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.factory.js
index 56492ab8007a..2685745ccf26 100644
--- a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 20.0, 0.3 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 20.0, 0.3, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -730,7 +730,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 20.0, 0.3 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 20.0, 0.3 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -742,7 +742,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 20.0, 0.3 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 20.0, 0.3 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -754,7 +754,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 20.0, 0.3 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -766,7 +766,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 20.0, 0.3, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.js b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.main.js b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.main.js
index e78d7e877539..54aca4b3e6d0 100644
--- a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.main.js
@@ -367,7 +367,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 20.0, 0.3 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -376,13 +376,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 20.0, 0.3 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 20.0, 0.3 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -392,7 +392,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 20.0, 0.3 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -427,7 +427,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 20.0, 0.3 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -478,12 +478,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 20.0, 0.3 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 20.0, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -493,14 +493,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 20.0, 0.3, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -517,9 +517,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -528,12 +528,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 20.0, 0.3 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 20.0, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -541,12 +541,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 20.0, 0.3 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 20.0, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -554,12 +554,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 20.0, 0.3 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 20.0, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -567,12 +567,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 20.0, 0.3 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 20.0, 0.3, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -616,9 +616,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -653,7 +653,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -691,11 +691,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -726,11 +726,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -763,11 +763,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -824,7 +824,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1002,7 +1002,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1089,7 +1089,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1123,7 +1123,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1177,7 +1177,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.object_mode.js
index 5842c083da49..6f41ccb1c126 100644
--- a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 20.0, 0.3 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 20.0, 0.3, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.validate.js
index 7e28c9ef0b00..17aa5dfb15bb 100644
--- a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/normal/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/normal/test/test.factory.js
index f079436a12ef..3cfdf41122c3 100644
--- a/lib/node_modules/@stdlib/random/streams/normal/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/normal/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/normal/test/test.js b/lib/node_modules/@stdlib/random/streams/normal/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/normal/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/normal/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/normal/test/test.main.js b/lib/node_modules/@stdlib/random/streams/normal/test/test.main.js
index a7356a1b6c57..4a93fc87d1d6 100644
--- a/lib/node_modules/@stdlib/random/streams/normal/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/normal/test/test.main.js
@@ -365,7 +365,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -374,13 +374,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -390,7 +390,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -425,7 +425,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -476,12 +476,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -491,14 +491,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -515,9 +515,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -526,12 +526,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -539,12 +539,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -552,12 +552,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -565,12 +565,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -614,9 +614,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -651,7 +651,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -689,11 +689,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -724,11 +724,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -761,11 +761,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -822,7 +822,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1000,7 +1000,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1087,7 +1087,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1121,7 +1121,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1175,7 +1175,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/normal/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/normal/test/test.object_mode.js
index 590c5c8b1b7c..7e6e4fba1e15 100644
--- a/lib/node_modules/@stdlib/random/streams/normal/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/normal/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -386,7 +386,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -414,7 +414,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/normal/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/normal/test/test.validate.js
index 6b03c9b20dc9..98535cbb5183 100644
--- a/lib/node_modules/@stdlib/random/streams/normal/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/normal/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.factory.js
index 2935bea731f8..587b2077bfae 100644
--- a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.js b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.main.js b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.main.js
index ee04565cfb87..f4fc7aaa832b 100644
--- a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.main.js
@@ -367,7 +367,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -376,13 +376,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -392,7 +392,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -427,7 +427,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -478,12 +478,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -493,14 +493,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -517,9 +517,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -528,12 +528,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -541,12 +541,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -554,12 +554,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -567,12 +567,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -616,9 +616,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -653,7 +653,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -691,11 +691,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -726,11 +726,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -763,11 +763,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -824,7 +824,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1002,7 +1002,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1089,7 +1089,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1123,7 +1123,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1177,7 +1177,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.object_mode.js
index d98cceed4732..7bf092096ed8 100644
--- a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.validate.js
index f3856950cc05..b574985fb478 100644
--- a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/poisson/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/poisson/test/test.factory.js
index 207b64717656..fa5d6a364b46 100644
--- a/lib/node_modules/@stdlib/random/streams/poisson/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/poisson/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 3.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 3.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -670,7 +670,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -682,7 +682,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -694,7 +694,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -706,7 +706,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/poisson/test/test.js b/lib/node_modules/@stdlib/random/streams/poisson/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/poisson/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/poisson/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/poisson/test/test.main.js b/lib/node_modules/@stdlib/random/streams/poisson/test/test.main.js
index d971667a3e2a..5560a679e440 100644
--- a/lib/node_modules/@stdlib/random/streams/poisson/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/poisson/test/test.main.js
@@ -337,7 +337,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -346,13 +346,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 3.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -362,7 +362,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -397,7 +397,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -448,12 +448,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -463,14 +463,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 3.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -487,9 +487,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -498,12 +498,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -511,12 +511,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -524,12 +524,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -537,12 +537,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -576,7 +576,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -586,9 +586,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -623,7 +623,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -661,11 +661,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -696,11 +696,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -733,11 +733,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -794,7 +794,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -824,7 +824,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -972,7 +972,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1059,7 +1059,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1093,7 +1093,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1147,7 +1147,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/poisson/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/poisson/test/test.object_mode.js
index 9de4c6302ee2..e493697033da 100644
--- a/lib/node_modules/@stdlib/random/streams/poisson/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/poisson/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 1.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 1.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/poisson/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/poisson/test/test.validate.js
index 18e75fa2c8d3..8d6a0a1c2281 100644
--- a/lib/node_modules/@stdlib/random/streams/poisson/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/poisson/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randi/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/randi/test/test.factory.js
index 1fd4fc3ceed8..72d28a875340 100644
--- a/lib/node_modules/@stdlib/random/streams/randi/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/randi/test/test.factory.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -275,7 +275,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -287,7 +287,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randi/test/test.js b/lib/node_modules/@stdlib/random/streams/randi/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/randi/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/randi/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randi/test/test.main.js b/lib/node_modules/@stdlib/random/streams/randi/test/test.main.js
index 5a90385b2abd..73a457d20f71 100644
--- a/lib/node_modules/@stdlib/random/streams/randi/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/randi/test/test.main.js
@@ -258,7 +258,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -267,13 +267,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream();
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -283,7 +283,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -318,7 +318,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -368,7 +368,7 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 	t.end();
 });
 
@@ -378,8 +378,8 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'name': 'mt19937'
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	t.end();
 });
@@ -397,9 +397,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -407,7 +407,7 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -415,19 +415,19 @@ tape( 'attached to the returned stream is the generator state', function test( t
 	var s = randomStream({
 		'name': 'mt19937'
 	});
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -461,7 +461,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers havi
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -471,9 +471,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers havi
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -509,7 +509,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers havi
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -547,11 +547,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -582,11 +582,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -619,11 +619,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -680,7 +680,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -762,7 +762,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -851,7 +851,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -886,7 +886,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -941,7 +941,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/randi/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/randi/test/test.object_mode.js
index 33c9ff5c4cb5..07e8627cedfe 100644
--- a/lib/node_modules/@stdlib/random/streams/randi/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/randi/test/test.object_mode.js
@@ -253,13 +253,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -282,8 +282,8 @@ tape( 'the function returns a stream which streams integers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
-		t.equal( isInteger( v ), true, 'returns an integer' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( isInteger( v ), true, 'returns an integer' );
 	}
 
 	function onEnd() {
@@ -311,7 +311,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/randi/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/randi/test/test.validate.js
index d0b619d0a611..79d53056cbc2 100644
--- a/lib/node_modules/@stdlib/random/streams/randi/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/randi/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `name` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randn/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/randn/test/test.factory.js
index 2feb21d8771b..aa0801c06ec4 100644
--- a/lib/node_modules/@stdlib/random/streams/randn/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/randn/test/test.factory.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -358,7 +358,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -370,7 +370,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randn/test/test.js b/lib/node_modules/@stdlib/random/streams/randn/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/randn/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/randn/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randn/test/test.main.js b/lib/node_modules/@stdlib/random/streams/randn/test/test.main.js
index 037924efc978..4d448e77b6e5 100644
--- a/lib/node_modules/@stdlib/random/streams/randn/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/randn/test/test.main.js
@@ -339,7 +339,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -348,13 +348,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream();
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -364,7 +364,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -399,7 +399,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -449,12 +449,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -465,14 +465,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'name': 'improved-ziggurat'
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream({
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -490,9 +490,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -500,12 +500,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -514,36 +514,36 @@ tape( 'attached to the returned stream is the generator state', function test( t
 	var s = randomStream({
 		'name': 'improved-ziggurat'
 	});
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream({
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -578,7 +578,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers draw
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -588,9 +588,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers draw
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -626,7 +626,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers draw
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -664,11 +664,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -699,11 +699,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -736,11 +736,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -797,7 +797,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -879,7 +879,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -968,7 +968,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1003,7 +1003,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1058,7 +1058,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/randn/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/randn/test/test.object_mode.js
index ddec99dbfd75..d8f7b47f2549 100644
--- a/lib/node_modules/@stdlib/random/streams/randn/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/randn/test/test.object_mode.js
@@ -332,13 +332,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -361,7 +361,7 @@ tape( 'the function returns a stream which streams normally distributed numbers'
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -389,7 +389,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/randn/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/randn/test/test.validate.js
index ada855e271c1..dd0945812eed 100644
--- a/lib/node_modules/@stdlib/random/streams/randn/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/randn/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `name` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -279,7 +279,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -305,7 +305,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -324,7 +324,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -342,7 +342,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randu/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/randu/test/test.factory.js
index 1fd4fc3ceed8..72d28a875340 100644
--- a/lib/node_modules/@stdlib/random/streams/randu/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/randu/test/test.factory.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -275,7 +275,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -287,7 +287,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randu/test/test.js b/lib/node_modules/@stdlib/random/streams/randu/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/randu/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/randu/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randu/test/test.main.js b/lib/node_modules/@stdlib/random/streams/randu/test/test.main.js
index 4525882b7d0b..15f0fd1f9f46 100644
--- a/lib/node_modules/@stdlib/random/streams/randu/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/randu/test/test.main.js
@@ -258,7 +258,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -267,13 +267,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream();
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -283,7 +283,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -318,7 +318,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -368,7 +368,7 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 	t.end();
 });
 
@@ -378,8 +378,8 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'name': 'mt19937'
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	t.end();
 });
@@ -397,9 +397,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -407,7 +407,7 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -415,19 +415,19 @@ tape( 'attached to the returned stream is the generator state', function test( t
 	var s = randomStream({
 		'name': 'mt19937'
 	});
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream();
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 	t.end();
 });
 
@@ -462,7 +462,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers on t
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -472,9 +472,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers on t
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -511,7 +511,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers on t
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -549,11 +549,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -584,11 +584,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -621,11 +621,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -682,7 +682,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -764,7 +764,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -853,7 +853,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -888,7 +888,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -943,7 +943,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/randu/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/randu/test/test.object_mode.js
index 3aff37bcff7f..4feb66c6168b 100644
--- a/lib/node_modules/@stdlib/random/streams/randu/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/randu/test/test.object_mode.js
@@ -252,13 +252,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -281,8 +281,8 @@ tape( 'the function returns a stream which streams numbers on the interval [0,1)
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
-		t.equal( v >= 0.0 && v < 1.0, true, 'is within expected range' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( v >= 0.0 && v < 1.0, true, 'is within expected range' );
 	}
 
 	function onEnd() {
@@ -310,7 +310,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/randu/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/randu/test/test.validate.js
index d0b619d0a611..79d53056cbc2 100644
--- a/lib/node_modules/@stdlib/random/streams/randu/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/randu/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `name` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.factory.js
index 6a64bf1dc696..ece7cf2bcdbc 100644
--- a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 3.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 3.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -670,7 +670,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -682,7 +682,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -694,7 +694,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -706,7 +706,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.js b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.main.js b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.main.js
index bc8ade9b1af0..2854521c307e 100644
--- a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.main.js
@@ -337,7 +337,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -346,13 +346,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 3.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -362,7 +362,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -397,7 +397,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -448,12 +448,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -463,14 +463,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 3.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -487,9 +487,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -498,12 +498,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -511,12 +511,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -524,12 +524,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -537,12 +537,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -576,7 +576,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -586,9 +586,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -623,7 +623,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -661,11 +661,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -696,11 +696,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -733,11 +733,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -794,7 +794,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -824,7 +824,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -972,7 +972,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1059,7 +1059,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1093,7 +1093,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1147,7 +1147,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.object_mode.js
index e3d9857820d5..35fb75f3110a 100644
--- a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 1.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 1.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.validate.js
index 87e0aa632b8d..6bb614a6373b 100644
--- a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/t/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/t/test/test.factory.js
index e38aab7d8b73..80699b709ccd 100644
--- a/lib/node_modules/@stdlib/random/streams/t/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/t/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 3.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 3.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -670,7 +670,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -682,7 +682,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -694,7 +694,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -706,7 +706,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/t/test/test.js b/lib/node_modules/@stdlib/random/streams/t/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/t/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/t/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/t/test/test.main.js b/lib/node_modules/@stdlib/random/streams/t/test/test.main.js
index 8320b997c8d7..a6b0ec1acf0c 100644
--- a/lib/node_modules/@stdlib/random/streams/t/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/t/test/test.main.js
@@ -337,7 +337,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -346,13 +346,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 3.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 3.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -362,7 +362,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -397,7 +397,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 3.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -448,12 +448,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -463,14 +463,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 3.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -487,9 +487,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -498,12 +498,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -511,12 +511,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -524,12 +524,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -537,12 +537,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 3.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 3.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -576,7 +576,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -586,9 +586,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -623,7 +623,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -661,11 +661,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -696,11 +696,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -733,11 +733,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -794,7 +794,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -824,7 +824,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -972,7 +972,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1059,7 +1059,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1093,7 +1093,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1147,7 +1147,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/t/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/t/test/test.object_mode.js
index 0fb2646a4f74..891841189348 100644
--- a/lib/node_modules/@stdlib/random/streams/t/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/t/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 1.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 1.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/t/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/t/test/test.validate.js
index 2ada3f697f5b..0d7eed589934 100644
--- a/lib/node_modules/@stdlib/random/streams/t/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/t/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/test/test.js b/lib/node_modules/@stdlib/random/streams/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/random/streams/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/triangular/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/triangular/test/test.factory.js
index 84457deab300..bfe23e2ffcd2 100644
--- a/lib/node_modules/@stdlib/random/streams/triangular/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/triangular/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, 4.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, 4.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -803,7 +803,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0, 4.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0, 4.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -815,7 +815,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0, 4.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0, 4.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -827,7 +827,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, 4.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -839,7 +839,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, 4.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/triangular/test/test.js b/lib/node_modules/@stdlib/random/streams/triangular/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/triangular/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/triangular/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/triangular/test/test.main.js b/lib/node_modules/@stdlib/random/streams/triangular/test/test.main.js
index 692b42667068..2ad49af50dcd 100644
--- a/lib/node_modules/@stdlib/random/streams/triangular/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/triangular/test/test.main.js
@@ -413,7 +413,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0, 4.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -422,13 +422,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0, 4.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0, 4.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -438,7 +438,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0, 4.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -473,7 +473,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0, 4.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -524,12 +524,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0, 4.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, 4.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -539,14 +539,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, 4.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -563,9 +563,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -574,12 +574,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0, 4.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, 4.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -587,12 +587,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0, 4.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, 4.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -600,12 +600,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0, 4.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, 4.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -613,12 +613,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0, 4.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, 4.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -652,7 +652,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -662,9 +662,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -699,7 +699,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -737,11 +737,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -772,11 +772,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -809,11 +809,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -870,7 +870,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -900,7 +900,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1048,7 +1048,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1135,7 +1135,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1169,7 +1169,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1223,7 +1223,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/triangular/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/triangular/test/test.object_mode.js
index f3ddab796f37..ebc07288a753 100644
--- a/lib/node_modules/@stdlib/random/streams/triangular/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/triangular/test/test.object_mode.js
@@ -405,13 +405,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0, 4.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, 4.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -434,7 +434,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -462,7 +462,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/triangular/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/triangular/test/test.validate.js
index 66d911fb164a..2cde8d0057a3 100644
--- a/lib/node_modules/@stdlib/random/streams/triangular/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/triangular/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/uniform/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/uniform/test/test.factory.js
index 700a326cf5de..4ea6cbfa0547 100644
--- a/lib/node_modules/@stdlib/random/streams/uniform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/uniform/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -768,7 +768,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -780,7 +780,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -792,7 +792,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -804,7 +804,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/uniform/test/test.js b/lib/node_modules/@stdlib/random/streams/uniform/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/uniform/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/uniform/test/test.main.js b/lib/node_modules/@stdlib/random/streams/uniform/test/test.main.js
index 6848515f33f5..f12f66ce7eb8 100644
--- a/lib/node_modules/@stdlib/random/streams/uniform/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/uniform/test/test.main.js
@@ -385,7 +385,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -394,13 +394,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -410,7 +410,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -445,7 +445,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -496,12 +496,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -511,14 +511,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -535,9 +535,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -546,12 +546,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -559,12 +559,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -572,12 +572,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -585,12 +585,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -624,7 +624,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -634,9 +634,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -671,7 +671,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -709,11 +709,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -744,11 +744,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -781,11 +781,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -842,7 +842,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -872,7 +872,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1020,7 +1020,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1107,7 +1107,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1141,7 +1141,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1195,7 +1195,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/uniform/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/uniform/test/test.object_mode.js
index 73a03ebae561..e3425a626403 100644
--- a/lib/node_modules/@stdlib/random/streams/uniform/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/uniform/test/test.object_mode.js
@@ -377,13 +377,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -406,7 +406,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -434,7 +434,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/uniform/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/uniform/test/test.validate.js
index dffca7084875..8ea631fa473b 100644
--- a/lib/node_modules/@stdlib/random/streams/uniform/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/uniform/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/weibull/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/weibull/test/test.factory.js
index 72b6ea94ffb2..4a4b761d949b 100644
--- a/lib/node_modules/@stdlib/random/streams/weibull/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/weibull/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/weibull/test/test.js b/lib/node_modules/@stdlib/random/streams/weibull/test/test.js
index e54ac256aaa8..3648025d92a0 100644
--- a/lib/node_modules/@stdlib/random/streams/weibull/test/test.js
+++ b/lib/node_modules/@stdlib/random/streams/weibull/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof randomStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof randomStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof randomStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/weibull/test/test.main.js b/lib/node_modules/@stdlib/random/streams/weibull/test/test.main.js
index 623272e2ca9c..2299bbe8554e 100644
--- a/lib/node_modules/@stdlib/random/streams/weibull/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/weibull/test/test.main.js
@@ -367,7 +367,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new RandomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -376,13 +376,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -392,7 +392,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -427,7 +427,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -478,12 +478,12 @@ tape( 'the returned stream does not allow itself to be destroyed more than once'
 tape( 'attached to the returned stream is the underlying PRNG', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof s.PRNG, 'function', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.PRNG, minstd.normalized, 'has property' );
+	t.strictEqual( s.PRNG, minstd.normalized, 'has property' );
 
 	t.end();
 });
@@ -493,14 +493,14 @@ tape( 'attached to the returned stream is the generator seed', function test( t
 		'seed': 12345
 	});
 
-	t.equal( isUint32Array( s.seed ), true, 'has property' );
-	t.equal( s.seed[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( s.seed ), true, 'has property' );
+	t.strictEqual( s.seed[ 0 ], 12345, 'equal to provided seed' );
 
 	s = randomStream( 2.0, 5.0, {
 		'seed': 12345,
 		'prng': minstd.normalized
 	});
-	t.equal( s.seed, null, 'equal to `null`' );
+	t.strictEqual( s.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -517,9 +517,9 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 	});
 
 	actual = s.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 
 	t.end();
@@ -528,12 +528,12 @@ tape( 'attached to the returned stream is the generator seed (array seed)', func
 tape( 'attached to the returned stream is the generator seed length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof s.seedLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.seedLength, null, 'equal to `null`' );
+	t.strictEqual( s.seedLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -541,12 +541,12 @@ tape( 'attached to the returned stream is the generator seed length', function t
 tape( 'attached to the returned stream is the generator state', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( isUint32Array( s.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( s.state ), true, 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.state, null, 'equal to `null`' );
+	t.strictEqual( s.state, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -554,12 +554,12 @@ tape( 'attached to the returned stream is the generator state', function test( t
 tape( 'attached to the returned stream is the generator state length', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof s.stateLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.stateLength, null, 'equal to `null`' );
+	t.strictEqual( s.stateLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -567,12 +567,12 @@ tape( 'attached to the returned stream is the generator state length', function
 tape( 'attached to the returned stream is the generator state size', function test( t ) {
 	var s = randomStream( 2.0, 5.0 );
 
-	t.equal( typeof s.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof s.byteLength, 'number', 'has property' );
 
 	s = randomStream( 2.0, 5.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( s.byteLength, null, 'equal to `null`' );
+	t.strictEqual( s.byteLength, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -616,9 +616,9 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), rand(), 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -653,7 +653,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( rand(), v, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( rand(), v, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -691,11 +691,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -726,11 +726,11 @@ tape( 'by default, the constructor generates newline-delimited pseudorandom numb
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -763,11 +763,11 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( typeof v, 'number', 'returns expected value' );
-			t.equal( isnan( v ), false, 'is not NaN' );
+			t.strictEqual( typeof v, 'number', 'returns expected value' );
+			t.strictEqual( isnan( v ), false, 'is not NaN' );
 		}
 		t.end();
 	}
@@ -824,7 +824,7 @@ tape( 'the constructor supports returning a seeded readable stream', function te
 	}
 
 	function inspect2( v ) {
-		t.equal( v, arr[ i ], 'returns expected value' );
+		t.strictEqual( v, arr[ i ], 'returns expected value' );
 		i += 1;
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns a number' );
 	}
 
 	function onEnd() {
@@ -1002,7 +1002,7 @@ tape( 'the constructor supports specifying the underlying generator state', func
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1089,7 +1089,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect2( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd2() {
@@ -1123,7 +1123,7 @@ tape( 'the constructor supports specifying a shared underlying generator state',
 
 	function inspect3( v ) {
 		count += 1;
-		t.equal( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
+		t.strictEqual( v, arr[ count-1 ], 'returns expected value. i: '+(count-1)+'.' );
 	}
 
 	function onEnd3() {
@@ -1177,7 +1177,7 @@ tape( 'the returned stream supports setting the underlying generator state', fun
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
+		t.strictEqual( v, arr[ i ], 'returns expected value. i: ' + i + '.' );
 		i += 1;
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/weibull/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/weibull/test/test.object_mode.js
index d1fb9cec2f23..96336060d81a 100644
--- a/lib/node_modules/@stdlib/random/streams/weibull/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/weibull/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.equal( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function returns a stream which streams numbers', function test( t )
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -416,7 +416,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( typeof v, 'number', 'returns expected value' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/weibull/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/weibull/test/test.validate.js
index dffca7084875..8ea631fa473b 100644
--- a/lib/node_modules/@stdlib/random/streams/weibull/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/weibull/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEquals( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided an `siter` option which is not
 		err = validate( {}, {
 			'siter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function sets the `iter` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function sets the `prng` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'the function sets the `seed` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'the function sets the `state` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function sets the `copy` option', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 	t.end();
 });
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/bernoulli/test/test.js b/lib/node_modules/@stdlib/random/strided/bernoulli/test/test.js
index e7fde2ada7c6..49d40bb743e9 100644
--- a/lib/node_modules/@stdlib/random/strided/bernoulli/test/test.js
+++ b/lib/node_modules/@stdlib/random/strided/bernoulli/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/chi/test/test.js b/lib/node_modules/@stdlib/random/strided/chi/test/test.js
index e7fde2ada7c6..49d40bb743e9 100644
--- a/lib/node_modules/@stdlib/random/strided/chi/test/test.js
+++ b/lib/node_modules/@stdlib/random/strided/chi/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/chisquare/test/test.js b/lib/node_modules/@stdlib/random/strided/chisquare/test/test.js
index e7fde2ada7c6..49d40bb743e9 100644
--- a/lib/node_modules/@stdlib/random/strided/chisquare/test/test.js
+++ b/lib/node_modules/@stdlib/random/strided/chisquare/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/exponential/test/test.js b/lib/node_modules/@stdlib/random/strided/exponential/test/test.js
index 99a8accde269..50ff7c9ead83 100644
--- a/lib/node_modules/@stdlib/random/strided/exponential/test/test.js
+++ b/lib/node_modules/@stdlib/random/strided/exponential/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/geometric/test/test.js b/lib/node_modules/@stdlib/random/strided/geometric/test/test.js
index e7fde2ada7c6..49d40bb743e9 100644
--- a/lib/node_modules/@stdlib/random/strided/geometric/test/test.js
+++ b/lib/node_modules/@stdlib/random/strided/geometric/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/poisson/test/test.js b/lib/node_modules/@stdlib/random/strided/poisson/test/test.js
index e7fde2ada7c6..49d40bb743e9 100644
--- a/lib/node_modules/@stdlib/random/strided/poisson/test/test.js
+++ b/lib/node_modules/@stdlib/random/strided/poisson/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/rayleigh/test/test.js b/lib/node_modules/@stdlib/random/strided/rayleigh/test/test.js
index e7fde2ada7c6..49d40bb743e9 100644
--- a/lib/node_modules/@stdlib/random/strided/rayleigh/test/test.js
+++ b/lib/node_modules/@stdlib/random/strided/rayleigh/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/t/test/test.js b/lib/node_modules/@stdlib/random/strided/t/test/test.js
index e7fde2ada7c6..49d40bb743e9 100644
--- a/lib/node_modules/@stdlib/random/strided/t/test/test.js
+++ b/lib/node_modules/@stdlib/random/strided/t/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/test/test.js b/lib/node_modules/@stdlib/random/strided/test/test.js
index 9fdab6e77188..93a939a5f431 100644
--- a/lib/node_modules/@stdlib/random/strided/test/test.js
+++ b/lib/node_modules/@stdlib/random/strided/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/tools/test/test.js b/lib/node_modules/@stdlib/random/strided/tools/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/random/strided/tools/test/test.js
+++ b/lib/node_modules/@stdlib/random/strided/tools/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/test/test.js b/lib/node_modules/@stdlib/random/test/test.js
index b59ac90426f0..364c30f447f2 100644
--- a/lib/node_modules/@stdlib/random/test/test.js
+++ b/lib/node_modules/@stdlib/random/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains generic random functions', function test( t ) {
 	var keys = objectKeys( rand );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/tools/binary/test/test.validate.js b/lib/node_modules/@stdlib/random/tools/binary/test/test.validate.js
index b68e30a4aef7..c79201a58185 100644
--- a/lib/node_modules/@stdlib/random/tools/binary/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/tools/binary/test/test.validate.js
@@ -37,7 +37,7 @@ var DTYPES = [
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, DTYPES, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'the function returns an error if provided a `dtype` option which is not a
 		err = validate( {}, DTYPES, {
 			'dtype': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function supports the `order` array creation option', function test(
 	opts = {};
 	err = validate( opts, DTYPES, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'returns expected value' );
 
 	t.end();
@@ -120,7 +120,7 @@ tape( 'the function supports the `mode` array creation option', function test( t
 	opts = {};
 	err = validate( opts, DTYPES, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'returns expected value' );
 
 	t.end();
@@ -137,7 +137,7 @@ tape( 'the function supports the `submode` array creation option', function test
 	opts = {};
 	err = validate( opts, DTYPES, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'returns expected value' );
 
 	t.end();
@@ -154,7 +154,7 @@ tape( 'the function supports the `readonly` array creation option', function tes
 	opts = {};
 	err = validate( opts, DTYPES, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'returns expected value' );
 
 	t.end();
@@ -175,7 +175,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, DTYPES, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'returns expected value' );
 
 	t.end();
@@ -193,7 +193,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, DTYPES, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/tools/test/test.js b/lib/node_modules/@stdlib/random/tools/test/test.js
index d1e6eeb4039e..30bee535777f 100644
--- a/lib/node_modules/@stdlib/random/tools/test/test.js
+++ b/lib/node_modules/@stdlib/random/tools/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'returns expected value' );
+	t.strictEqual( keys.length > 0, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/tools/unary/test/test.validate.js b/lib/node_modules/@stdlib/random/tools/unary/test/test.validate.js
index b68e30a4aef7..c79201a58185 100644
--- a/lib/node_modules/@stdlib/random/tools/unary/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/tools/unary/test/test.validate.js
@@ -37,7 +37,7 @@ var DTYPES = [
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, DTYPES, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'the function returns an error if provided a `dtype` option which is not a
 		err = validate( {}, DTYPES, {
 			'dtype': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function supports the `order` array creation option', function test(
 	opts = {};
 	err = validate( opts, DTYPES, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'returns expected value' );
 
 	t.end();
@@ -120,7 +120,7 @@ tape( 'the function supports the `mode` array creation option', function test( t
 	opts = {};
 	err = validate( opts, DTYPES, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'returns expected value' );
 
 	t.end();
@@ -137,7 +137,7 @@ tape( 'the function supports the `submode` array creation option', function test
 	opts = {};
 	err = validate( opts, DTYPES, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'returns expected value' );
 
 	t.end();
@@ -154,7 +154,7 @@ tape( 'the function supports the `readonly` array creation option', function tes
 	opts = {};
 	err = validate( opts, DTYPES, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'returns expected value' );
 
 	t.end();
@@ -175,7 +175,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, DTYPES, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'returns expected value' );
 
 	t.end();
@@ -193,7 +193,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, DTYPES, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/uniform/test/test.js b/lib/node_modules/@stdlib/random/uniform/test/test.js
index 301c6bb9b5c1..b6145c92f9b5 100644
--- a/lib/node_modules/@stdlib/random/uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/uniform/test/test.js
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'returns expected value' );
+	t.strictEqual( typeof random.PRNG, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'returns expected value' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'returns expected value' );
+	t.strictEqual( typeof random.seedLength, 'number', 'returns expected value' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'returns expected value' );
+	t.strictEqual( isUint32Array( random.state ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'returns expected value' );
+	t.strictEqual( typeof random.stateLength, 'number', 'returns expected value' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'returns expected value' );
+	t.strictEqual( typeof random.byteLength, 'number', 'returns expected value' );
 	t.end();
 });

From 65ddf8d4d51ccfda52d1c5a06408e43fb386c27e Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Tue, 12 Aug 2025 21:29:09 -0500
Subject: [PATCH 03/32] test: use .strictEqual() instead of .equal() and fix
 lint errors

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/math/array/special/test/test.js   |   2 +-
 .../@stdlib/math/array/test/test.js           |   2 +-
 .../@stdlib/math/array/tools/test/test.js     |   2 +-
 .../base/assert/is-composite/test/test.js     |  18 +-
 .../assert/is-composite/test/test.native.js   |  18 +-
 .../math/base/assert/is-coprime/test/test.js  |  48 +--
 .../math/base/assert/is-even/test/test.js     |  16 +-
 .../base/assert/is-even/test/test.native.js   |  16 +-
 .../math/base/assert/is-evenf/test/test.js    |  16 +-
 .../base/assert/is-evenf/test/test.native.js  |  16 +-
 .../math/base/assert/is-finite/test/test.js   |  12 +-
 .../base/assert/is-finite/test/test.native.js |   8 +-
 .../math/base/assert/is-finitef/test/test.js  |  12 +-
 .../assert/is-finitef/test/test.native.js     |   8 +-
 .../math/base/assert/is-infinite/test/test.js |   6 +-
 .../assert/is-infinite/test/test.native.js    |   6 +-
 .../base/assert/is-infinitef/test/test.js     |   6 +-
 .../assert/is-infinitef/test/test.native.js   |   4 +-
 .../math/base/assert/is-integer/test/test.js  |  10 +-
 .../assert/is-integer/test/test.native.js     |  10 +-
 .../math/base/assert/is-integerf/test/test.js |  10 +-
 .../assert/is-integerf/test/test.native.js    |  10 +-
 .../math/base/assert/is-nan/test/test.js      |   4 +-
 .../base/assert/is-nan/test/test.native.js    |   4 +-
 .../math/base/assert/is-nanf/test/test.js     |   4 +-
 .../base/assert/is-nanf/test/test.native.js   |   2 +-
 .../assert/is-negative-finite/test/test.js    |  14 +-
 .../is-negative-finite/test/test.native.js    |  14 +-
 .../assert/is-negative-integer/test/test.js   |  12 +-
 .../is-negative-integer/test/test.native.js   |  12 +-
 .../assert/is-negative-integerf/test/test.js  |  16 +-
 .../is-negative-integerf/test/test.native.js  |  16 +-
 .../base/assert/is-negative-zero/test/test.js |   6 +-
 .../is-negative-zero/test/test.native.js      |   6 +-
 .../assert/is-negative-zerof/test/test.js     |   8 +-
 .../is-negative-zerof/test/test.native.js     |   8 +-
 .../assert/is-nonnegative-finite/test/test.js |   4 +-
 .../is-nonnegative-finite/test/test.native.js |   4 +-
 .../is-nonnegative-integer/test/test.js       |  14 +-
 .../test/test.native.js                       |  14 +-
 .../is-nonnegative-integerf/test/test.js      |  14 +-
 .../test/test.native.js                       |  14 +-
 .../assert/is-nonpositive-finite/test/test.js |  16 +-
 .../is-nonpositive-finite/test/test.native.js |   6 +-
 .../is-nonpositive-integer/test/test.js       |  14 +-
 .../test/test.native.js                       |  14 +-
 .../math/base/assert/is-odd/test/test.js      |  16 +-
 .../base/assert/is-odd/test/test.native.js    |  16 +-
 .../math/base/assert/is-oddf/test/test.js     |  16 +-
 .../base/assert/is-oddf/test/test.native.js   |  16 +-
 .../assert/is-positive-finite/test/test.js    |  18 +-
 .../is-positive-finite/test/test.native.js    |  18 +-
 .../assert/is-positive-integer/test/test.js   |  12 +-
 .../is-positive-integer/test/test.native.js   |  12 +-
 .../base/assert/is-positive-zero/test/test.js |   8 +-
 .../is-positive-zero/test/test.native.js      |   8 +-
 .../assert/is-positive-zerof/test/test.js     |   8 +-
 .../is-positive-zerof/test/test.native.js     |   8 +-
 .../math/base/assert/is-prime/test/test.js    |  16 +-
 .../base/assert/is-prime/test/test.native.js  |  16 +-
 .../base/assert/is-probability/test/test.js   |  20 +-
 .../assert/is-probability/test/test.native.js |  20 +-
 .../base/assert/is-probabilityf/test/test.js  |  20 +-
 .../is-probabilityf/test/test.native.js       |  20 +-
 .../base/assert/is-safe-integer/test/test.js  |  18 +-
 .../is-safe-integer/test/test.native.js       |  18 +-
 .../@stdlib/math/base/assert/test/test.js     |   2 +-
 .../@stdlib/math/base/napi/test/test.js       |   2 +-
 .../math/base/special/abs/test/test.abs.js    |  16 +-
 .../math/base/special/abs/test/test.high.js   |   8 +-
 .../math/base/special/absf/test/test.abs.js   |  14 +-
 .../base/special/betaln/test/test.dceval.js   |   8 +-
 .../base/special/cabs2f/test/test.native.js   |   2 +-
 .../math/base/special/cexp/test/test.js       |  18 +-
 .../base/special/cexp/test/test.native.js     |  18 +-
 .../special/cflipsignf/test/test.native.js    |   4 +-
 .../math/base/special/cospi/test/test.js      |   2 +-
 .../base/special/cospi/test/test.native.js    |   2 +-
 .../base/special/dirac-delta/test/test.js     |   2 +-
 .../special/dirac-delta/test/test.native.js   |   2 +-
 .../base/special/dirac-deltaf/test/test.js    |   2 +-
 .../special/dirac-deltaf/test/test.native.js  |   2 +-
 .../base/special/factorialln/test/test.js     |   2 +-
 .../special/factorialln/test/test.native.js   |   2 +-
 .../base/special/factoriallnf/test/test.js    |   2 +-
 .../special/factoriallnf/test/test.native.js  |   2 +-
 .../base/special/fresnel/test/test.assign.js  |  50 +--
 .../base/special/fresnel/test/test.main.js    |  32 +-
 .../special/gamma/test/other/xtest.gamma.js   |  22 +-
 .../base/special/gamma/test/test.boost.js     |  20 +-
 .../base/special/kernel-cosf/test/test.js     |   2 +-
 .../special/kernel-cosf/test/test.native.js   |   2 +-
 .../base/special/kernel-sincos/test/test.js   |  38 +--
 .../special/kernel-sincos/test/test.native.js |  26 +-
 .../base/special/kernel-sinf/test/test.js     |   2 +-
 .../special/kernel-sinf/test/test.native.js   |   2 +-
 .../base/special/kronecker-delta/test/test.js |   2 +-
 .../kronecker-delta/test/test.native.js       |   2 +-
 .../special/kronecker-deltaf/test/test.js     |   2 +-
 .../kronecker-deltaf/test/test.native.js      |   2 +-
 .../math/base/special/ldexp/test/test.js      |   2 +-
 .../base/special/ldexp/test/test.native.js    |   2 +-
 .../math/base/special/ldexpf/test/test.js     |   2 +-
 .../base/special/ldexpf/test/test.native.js   |   2 +-
 .../math/base/special/log/test/test.js        |  22 +-
 .../math/base/special/log/test/test.native.js |  22 +-
 .../base/special/modf/test/test.assign.js     |  20 +-
 .../base/special/modff/test/test.assign.js    |  20 +-
 .../base/special/pow/test/test.x_is_zero.js   |  24 +-
 .../math/base/special/powm1/test/test.js      |   2 +-
 .../base/special/powm1/test/test.native.js    |   2 +-
 .../base/special/riemann-zeta/test/test.js    |   2 +-
 .../special/riemann-zeta/test/test.native.js  |   2 +-
 .../base/special/sici/test/test.assign.js     |  22 +-
 .../base/special/sincos/test/test.assign.js   |  74 ++---
 .../base/special/sincos/test/test.main.js     |  36 +--
 .../base/special/sincosd/test/test.assign.js  |  80 ++---
 .../base/special/sincosd/test/test.main.js    |  36 +--
 .../base/special/sincospi/test/test.assign.js |  56 ++--
 .../base/special/sincospi/test/test.main.js   |  30 +-
 .../base/special/sincospi/test/test.native.js |   2 +-
 .../math/base/special/tan/test/test.js        |   4 +-
 .../math/base/special/tan/test/test.native.js |   4 +-
 .../math/base/special/tanf/test/test.js       |   4 +-
 .../base/special/tanf/test/test.native.js     |   4 +-
 .../math/base/special/wrapf/test/test.js      |  66 ++--
 .../base/special/wrapf/test/test.native.js    |  66 ++--
 .../@stdlib/math/base/test/test.js            |   2 +-
 .../tools/continued-fraction/test/test.js     |   3 +-
 .../tools/evalpoly-compile-c/test/test.js     |  58 ++--
 .../base/tools/evalpoly-compile/test/test.js  |  72 ++---
 .../tools/evalrational-compile-c/test/test.js |  66 ++--
 .../tools/evalrational-compile/test/test.js   |  78 ++---
 .../math/base/tools/evalrational/test/test.js |   2 +-
 .../base/tools/evalrationalf/test/test.js     |   2 +-
 .../tools/hermitepoly/test/test.factory.js    |  14 +-
 .../math/base/tools/hermitepoly/test/test.js  |  14 +-
 .../math/base/tools/sum-series/test/test.js   |   4 +-
 .../@stdlib/math/base/tools/test/test.js      |   2 +-
 .../utils/absolute-difference/test/test.js    |  24 +-
 .../float64-epsilon-difference/test/test.js   |  64 ++--
 .../utils/relative-difference/test/test.js    | 106 +++----
 .../@stdlib/math/base/utils/test/test.js      |   2 +-
 .../@stdlib/math/iter/ops/add/test/test.js    | 116 +++----
 .../@stdlib/math/iter/ops/divide/test/test.js | 132 ++++----
 .../@stdlib/math/iter/ops/mod/test/test.js    | 132 ++++----
 .../math/iter/ops/multiply/test/test.js       | 116 +++----
 .../math/iter/ops/subtract/test/test.js       | 132 ++++----
 .../@stdlib/math/iter/ops/test/test.js        |   2 +-
 .../iter/sequences/composites/test/test.js    |  54 ++--
 .../sequences/continued-fraction/test/test.js | 294 +++++++++---------
 .../math/iter/sequences/cubes/test/test.js    |  56 ++--
 .../iter/sequences/even-integers/test/test.js |  58 ++--
 .../iter/sequences/factorials/test/test.js    |  54 ++--
 .../iter/sequences/fibonacci/test/test.js     |  58 ++--
 .../iter/sequences/fifth-powers/test/test.js  |  54 ++--
 .../iter/sequences/fourth-powers/test/test.js |  54 ++--
 .../math/iter/sequences/integers/test/test.js |  56 ++--
 .../math/iter/sequences/lucas/test/test.js    |  58 ++--
 .../iter/sequences/negafibonacci/test/test.js |  58 ++--
 .../iter/sequences/negalucas/test/test.js     |  58 ++--
 .../negative-even-integers/test/test.js       |  58 ++--
 .../sequences/negative-integers/test/test.js  |  56 ++--
 .../negative-odd-integers/test/test.js        |  58 ++--
 .../iter/sequences/nonfibonacci/test/test.js  |  54 ++--
 .../nonnegative-even-integers/test/test.js    |  58 ++--
 .../nonnegative-integers/test/test.js         |  56 ++--
 .../nonpositive-even-integers/test/test.js    |  58 ++--
 .../nonpositive-integers/test/test.js         |  56 ++--
 .../iter/sequences/nonsquares/test/test.js    |  56 ++--
 .../iter/sequences/odd-integers/test/test.js  |  58 ++--
 .../positive-even-integers/test/test.js       |  58 ++--
 .../sequences/positive-integers/test/test.js  |  56 ++--
 .../positive-odd-integers/test/test.js        |  58 ++--
 .../math/iter/sequences/primes/test/test.js   |  54 ++--
 .../sequences/squared-triangular/test/test.js |  58 ++--
 .../math/iter/sequences/squares/test/test.js  |  56 ++--
 .../@stdlib/math/iter/sequences/test/test.js  |   2 +-
 .../iter/sequences/triangular/test/test.js    |  54 ++--
 .../iter/sequences/tribonacci/test/test.js    |  58 ++--
 .../math/iter/special/abs/test/test.js        |  54 ++--
 .../math/iter/special/abs2/test/test.js       |  54 ++--
 .../math/iter/special/acos/test/test.js       |  54 ++--
 .../math/iter/special/acosh/test/test.js      |  54 ++--
 .../math/iter/special/acot/test/test.js       |  54 ++--
 .../math/iter/special/acoth/test/test.js      |  54 ++--
 .../math/iter/special/acovercos/test/test.js  |  54 ++--
 .../math/iter/special/acoversin/test/test.js  |  54 ++--
 .../math/iter/special/ahavercos/test/test.js  |  54 ++--
 .../math/iter/special/ahaversin/test/test.js  |  54 ++--
 .../math/iter/special/asin/test/test.js       |  54 ++--
 .../math/iter/special/asinh/test/test.js      |  54 ++--
 .../math/iter/special/atan/test/test.js       |  54 ++--
 .../math/iter/special/atan2/test/test.js      |  94 +++---
 .../math/iter/special/atanh/test/test.js      |  54 ++--
 .../math/iter/special/avercos/test/test.js    |  54 ++--
 .../math/iter/special/aversin/test/test.js    |  54 ++--
 .../math/iter/special/besselj0/test/test.js   |  54 ++--
 .../math/iter/special/besselj1/test/test.js   |  54 ++--
 .../math/iter/special/bessely0/test/test.js   |  54 ++--
 .../math/iter/special/bessely1/test/test.js   |  54 ++--
 .../math/iter/special/beta/test/test.js       |  94 +++---
 .../math/iter/special/betaln/test/test.js     |  94 +++---
 .../math/iter/special/binet/test/test.js      |  54 ++--
 .../math/iter/special/cbrt/test/test.js       |  54 ++--
 .../math/iter/special/ceil/test/test.js       |  54 ++--
 .../math/iter/special/ceil10/test/test.js     |  54 ++--
 .../math/iter/special/ceil2/test/test.js      |  54 ++--
 .../math/iter/special/cos/test/test.js        |  54 ++--
 .../math/iter/special/cosh/test/test.js       |  54 ++--
 .../math/iter/special/cosm1/test/test.js      |  54 ++--
 .../math/iter/special/cospi/test/test.js      |  54 ++--
 .../math/iter/special/covercos/test/test.js   |  54 ++--
 .../math/iter/special/coversin/test/test.js   |  54 ++--
 .../math/iter/special/deg2rad/test/test.js    |  54 ++--
 .../math/iter/special/digamma/test/test.js    |  54 ++--
 .../iter/special/dirac-delta/test/test.js     |  54 ++--
 .../iter/special/dirichlet-eta/test/test.js   |  54 ++--
 .../math/iter/special/ellipe/test/test.js     |  54 ++--
 .../math/iter/special/ellipk/test/test.js     |  54 ++--
 .../math/iter/special/erf/test/test.js        |  54 ++--
 .../math/iter/special/erfc/test/test.js       |  54 ++--
 .../math/iter/special/erfcinv/test/test.js    |  54 ++--
 .../math/iter/special/erfinv/test/test.js     |  54 ++--
 .../math/iter/special/exp/test/test.js        |  54 ++--
 .../math/iter/special/exp10/test/test.js      |  54 ++--
 .../math/iter/special/exp2/test/test.js       |  54 ++--
 .../math/iter/special/expit/test/test.js      |  54 ++--
 .../math/iter/special/expm1/test/test.js      |  54 ++--
 .../math/iter/special/expm1rel/test/test.js   |  54 ++--
 .../math/iter/special/factorial/test/test.js  |  54 ++--
 .../iter/special/factorialln/test/test.js     |  54 ++--
 .../math/iter/special/floor/test/test.js      |  54 ++--
 .../math/iter/special/floor10/test/test.js    |  54 ++--
 .../math/iter/special/floor2/test/test.js     |  54 ++--
 .../math/iter/special/fresnelc/test/test.js   |  54 ++--
 .../math/iter/special/fresnels/test/test.js   |  54 ++--
 .../math/iter/special/gamma/test/test.js      |  54 ++--
 .../math/iter/special/gamma1pm1/test/test.js  |  54 ++--
 .../math/iter/special/gammaln/test/test.js    |  54 ++--
 .../math/iter/special/hacovercos/test/test.js |  54 ++--
 .../math/iter/special/hacoversin/test/test.js |  54 ++--
 .../math/iter/special/havercos/test/test.js   |  54 ++--
 .../math/iter/special/haversin/test/test.js   |  54 ++--
 .../math/iter/special/inv/test/test.js        |  54 ++--
 .../@stdlib/math/iter/special/ln/test/test.js |  54 ++--
 .../math/iter/special/log/test/test.js        |  94 +++---
 .../math/iter/special/log10/test/test.js      |  54 ++--
 .../math/iter/special/log1mexp/test/test.js   |  54 ++--
 .../math/iter/special/log1p/test/test.js      |  54 ++--
 .../math/iter/special/log1pexp/test/test.js   |  54 ++--
 .../math/iter/special/log2/test/test.js       |  54 ++--
 .../math/iter/special/logit/test/test.js      |  54 ++--
 .../math/iter/special/pow/test/test.js        |  94 +++---
 .../math/iter/special/rad2deg/test/test.js    |  54 ++--
 .../math/iter/special/ramp/test/test.js       |  54 ++--
 .../iter/special/riemann-zeta/test/test.js    |  54 ++--
 .../math/iter/special/round/test/test.js      |  54 ++--
 .../math/iter/special/round10/test/test.js    |  54 ++--
 .../math/iter/special/round2/test/test.js     |  54 ++--
 .../math/iter/special/rsqrt/test/test.js      |  54 ++--
 .../math/iter/special/signum/test/test.js     |  54 ++--
 .../math/iter/special/sin/test/test.js        |  54 ++--
 .../math/iter/special/sinc/test/test.js       |  54 ++--
 .../math/iter/special/sinh/test/test.js       |  54 ++--
 .../math/iter/special/sinpi/test/test.js      |  54 ++--
 .../math/iter/special/spence/test/test.js     |  54 ++--
 .../math/iter/special/sqrt/test/test.js       |  54 ++--
 .../math/iter/special/sqrt1pm1/test/test.js   |  54 ++--
 .../math/iter/special/tan/test/test.js        |  54 ++--
 .../math/iter/special/tanh/test/test.js       |  54 ++--
 .../@stdlib/math/iter/special/test/test.js    |   2 +-
 .../math/iter/special/trigamma/test/test.js   |  54 ++--
 .../math/iter/special/trunc/test/test.js      |  54 ++--
 .../math/iter/special/trunc10/test/test.js    |  54 ++--
 .../math/iter/special/trunc2/test/test.js     |  54 ++--
 .../math/iter/special/vercos/test/test.js     |  54 ++--
 .../math/iter/special/versin/test/test.js     |  54 ++--
 .../@stdlib/math/iter/test/test.js            |   2 +-
 .../@stdlib/math/iter/tools/map/test/test.js  |  72 ++---
 .../@stdlib/math/iter/tools/map2/test/test.js | 106 +++----
 .../@stdlib/math/iter/tools/map3/test/test.js | 106 +++----
 .../@stdlib/math/iter/tools/test/test.js      |   2 +-
 .../@stdlib/math/iter/utils/test/test.js      |   2 +-
 .../@stdlib/math/special/test/test.js         |   2 +-
 .../@stdlib/math/strided/ops/test/test.js     |   2 +-
 .../@stdlib/math/strided/special/test/test.js |   2 +-
 .../@stdlib/math/strided/test/test.js         |   2 +-
 lib/node_modules/@stdlib/math/test/test.js    |   2 +-
 .../@stdlib/math/tools/test/test.js           |   2 +-
 290 files changed, 5272 insertions(+), 5271 deletions(-)

diff --git a/lib/node_modules/@stdlib/math/array/special/test/test.js b/lib/node_modules/@stdlib/math/array/special/test/test.js
index 4888b60cd38c..85de573de8c2 100644
--- a/lib/node_modules/@stdlib/math/array/special/test/test.js
+++ b/lib/node_modules/@stdlib/math/array/special/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/array/test/test.js b/lib/node_modules/@stdlib/math/array/test/test.js
index 4888b60cd38c..85de573de8c2 100644
--- a/lib/node_modules/@stdlib/math/array/test/test.js
+++ b/lib/node_modules/@stdlib/math/array/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/array/tools/test/test.js b/lib/node_modules/@stdlib/math/array/tools/test/test.js
index 4888b60cd38c..85de573de8c2 100644
--- a/lib/node_modules/@stdlib/math/array/tools/test/test.js
+++ b/lib/node_modules/@stdlib/math/array/tools/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-composite/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-composite/test/test.js
index 228befec97d5..329546ed6c40 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-composite/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-composite/test/test.js
@@ -49,14 +49,14 @@ tape( 'the function returns `false` if provided a prime number', function test(
 	M = 2e4;
 	for ( i = 0; i < M; i++ ) {
 		v = PRIMES[ i ];
-		t.equal( isComposite( v ), false, 'returns expected value when provided '+v );
+		t.strictEqual( isComposite( v ), false, 'returns expected value when provided '+v );
 	}
 	// Randomly test prime numbers chosen from the remainder of the list of known prime numbers...
 	N = PRIMES.length - 1;
 	for ( i = 0; i < 1e3; i++ ) {
 		j = discreteUniform( M, N );
 		v = PRIMES[ j ];
-		t.equal( isComposite( v ), false, 'returns expected value when provided '+v );
+		t.strictEqual( isComposite( v ), false, 'returns expected value when provided '+v );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns `true` if provided a composite number', function tes
 		if ( hash[ i ] ) {
 			continue;
 		}
-		t.equal( isComposite( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isComposite( i ), true, 'returns expected value when provided '+i );
 	}
 	// Generate random composite integers among the list of primes...
 	MAX = PRIMES[ N-1 ];
@@ -92,7 +92,7 @@ tape( 'the function returns `true` if provided a composite number', function tes
 			i -= 1;
 			continue;
 		}
-		t.equal( isComposite( j ), true, 'returns expected value when provided '+j );
+		t.strictEqual( isComposite( j ), true, 'returns expected value when provided '+j );
 	}
 	t.end();
 });
@@ -103,28 +103,28 @@ tape( 'the function returns `false` if not provided a positive integer', functio
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu()*100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isComposite( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isComposite( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isComposite( NaN ), false, 'returns expected value' );
+	t.strictEqual( isComposite( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', function test( t ) {
-	t.equal( isComposite( PINF ), false, 'returns expected value' );
+	t.strictEqual( isComposite( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', function test( t ) {
-	t.equal( isComposite( NINF ), false, 'returns expected value' );
+	t.strictEqual( isComposite( NINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `1`', function test( t ) {
-	t.equal( isComposite( 1 ), false, 'returns expected value' );
+	t.strictEqual( isComposite( 1 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-composite/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-composite/test/test.native.js
index c601830a1bf6..dbd818fba3cf 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-composite/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-composite/test/test.native.js
@@ -62,14 +62,14 @@ tape( 'the function returns `false` if provided a prime number', opts, function
 	M = 2e4;
 	for ( i = 0; i < M; i++ ) {
 		v = PRIMES[ i ];
-		t.equal( isComposite( v ), false, 'returns expected value when provided ' + v );
+		t.strictEqual( isComposite( v ), false, 'returns expected value when provided ' + v );
 	}
 	// Randomly test prime numbers chosen from the remainder of the list of known prime numbers...
 	N = PRIMES.length - 1;
 	for ( i = 0; i < 1e3; i++ ) {
 		j = discreteUniform( M, N );
 		v = PRIMES[ j ];
-		t.equal( isComposite( v ), false, 'returns expected value when provided ' + v );
+		t.strictEqual( isComposite( v ), false, 'returns expected value when provided ' + v );
 	}
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'the function returns `true` if provided a composite number', opts, functi
 		if ( hash[ i ] ) {
 			continue;
 		}
-		t.equal( isComposite( i ), true, 'returns expected value when provided ' + i );
+		t.strictEqual( isComposite( i ), true, 'returns expected value when provided ' + i );
 	}
 	// Generate random composite integers among the list of primes...
 	MAX = PRIMES[ N-1 ];
@@ -105,7 +105,7 @@ tape( 'the function returns `true` if provided a composite number', opts, functi
 			i -= 1;
 			continue;
 		}
-		t.equal( isComposite( j ), true, 'returns expected value when provided ' + j );
+		t.strictEqual( isComposite( j ), true, 'returns expected value when provided ' + j );
 	}
 	t.end();
 });
@@ -116,28 +116,28 @@ tape( 'the function returns `false` if not provided a positive integer', opts, f
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu()*100.0 ) - 50.0;
 		if ( trunc( v ) !== v ) {
-			t.equal( isComposite( v ), false, 'returns expected value when provided ' + v );
+			t.strictEqual( isComposite( v ), false, 'returns expected value when provided ' + v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isComposite( NaN ), false, 'returns expected value' );
+	t.strictEqual( isComposite( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isComposite( PINF ), false, 'returns expected value' );
+	t.strictEqual( isComposite( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isComposite( NINF ), false, 'returns expected value' );
+	t.strictEqual( isComposite( NINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `1`', opts, function test( t ) {
-	t.equal( isComposite( 1 ), false, 'returns expected value' );
+	t.strictEqual( isComposite( 1 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-coprime/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-coprime/test/test.js
index 332d3d370390..548375cbe3a0 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-coprime/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-coprime/test/test.js
@@ -37,21 +37,21 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided coprime integers', function test( t ) {
-	t.equal( isCoprime( 14.0, 15.0 ), true, 'returns expected value' );
-	t.equal( isCoprime( 5.0, 7.0 ), true, 'returns expected value' );
-	t.equal( isCoprime( 13.0, 19.0 ), true, 'returns expected value' );
+	t.strictEqual( isCoprime( 14.0, 15.0 ), true, 'returns expected value' );
+	t.strictEqual( isCoprime( 5.0, 7.0 ), true, 'returns expected value' );
+	t.strictEqual( isCoprime( 13.0, 19.0 ), true, 'returns expected value' );
 
-	t.equal( isCoprime( -14.0, 15.0 ), true, 'returns expected value' );
-	t.equal( isCoprime( 5.0, -7.0 ), true, 'returns expected value' );
-	t.equal( isCoprime( -13.0, -19.0 ), true, 'returns expected value' );
+	t.strictEqual( isCoprime( -14.0, 15.0 ), true, 'returns expected value' );
+	t.strictEqual( isCoprime( 5.0, -7.0 ), true, 'returns expected value' );
+	t.strictEqual( isCoprime( -13.0, -19.0 ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `false` if provided integers which are not coprime', function test( t ) {
-	t.equal( isCoprime( 14.0, 21.0 ), false, 'returns expected value' );
-	t.equal( isCoprime( 15.0, 45.0 ), false, 'returns expected value' );
-	t.equal( isCoprime( 20.0, 90.0 ), false, 'returns expected value' );
+	t.strictEqual( isCoprime( 14.0, 21.0 ), false, 'returns expected value' );
+	t.strictEqual( isCoprime( 15.0, 45.0 ), false, 'returns expected value' );
+	t.strictEqual( isCoprime( 20.0, 90.0 ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -61,38 +61,38 @@ tape( 'the function returns `false` if not provided an integer', function test(
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu()*100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isCoprime( v, 5.0 ), false, 'returns false when provided '+v );
-			t.equal( isCoprime( 4.0, v ), false, 'returns false when provided '+v );
-			t.equal( isCoprime( v, v ), false, 'returns false when provided '+v );
+			t.strictEqual( isCoprime( v, 5.0 ), false, 'returns false when provided '+v );
+			t.strictEqual( isCoprime( 4.0, v ), false, 'returns false when provided '+v );
+			t.strictEqual( isCoprime( v, v ), false, 'returns false when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isCoprime( NaN, NaN ), false, 'returns expected value' );
-	t.equal( isCoprime( 4.0, NaN ), false, 'returns expected value' );
-	t.equal( isCoprime( NaN, 5.0 ), false, 'returns expected value' );
+	t.strictEqual( isCoprime( NaN, NaN ), false, 'returns expected value' );
+	t.strictEqual( isCoprime( 4.0, NaN ), false, 'returns expected value' );
+	t.strictEqual( isCoprime( NaN, 5.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', function test( t ) {
-	t.equal( isCoprime( PINF, PINF ), false, 'returns expected value' );
-	t.equal( isCoprime( 4.0, PINF ), false, 'returns expected value' );
-	t.equal( isCoprime( PINF, 5.0 ), false, 'returns expected value' );
+	t.strictEqual( isCoprime( PINF, PINF ), false, 'returns expected value' );
+	t.strictEqual( isCoprime( 4.0, PINF ), false, 'returns expected value' );
+	t.strictEqual( isCoprime( PINF, 5.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', function test( t ) {
-	t.equal( isCoprime( NINF, NINF ), false, 'returns expected value' );
-	t.equal( isCoprime( 4.0, NINF ), false, 'returns expected value' );
-	t.equal( isCoprime( NINF, 5.0 ), false, 'returns expected value' );
+	t.strictEqual( isCoprime( NINF, NINF ), false, 'returns expected value' );
+	t.strictEqual( isCoprime( 4.0, NINF ), false, 'returns expected value' );
+	t.strictEqual( isCoprime( NINF, 5.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `1`', function test( t ) {
-	t.equal( isCoprime( 1, 1 ), true, 'returns expected value' );
-	t.equal( isCoprime( 1, 4 ), true, 'returns expected value' );
-	t.equal( isCoprime( 4, 1 ), true, 'returns expected value' );
+	t.strictEqual( isCoprime( 1, 1 ), true, 'returns expected value' );
+	t.strictEqual( isCoprime( 1, 4 ), true, 'returns expected value' );
+	t.strictEqual( isCoprime( 4, 1 ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-even/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-even/test/test.js
index d88dc353b8a5..fbcf3b5d8bca 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-even/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-even/test/test.js
@@ -44,7 +44,7 @@ tape( 'the function returns `true` if provided an even number', function test( t
 		x = round( randu()*1.0e6 ) - 5.0e5;
 		x *= 2; // always even
 		bool = isEven( x );
-		t.equal( bool, true, 'returns expected value when provided '+x );
+		t.strictEqual( bool, true, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -59,29 +59,29 @@ tape( 'the function returns `false` if provided an odd number', function test( t
 			x += 1;
 		}
 		bool = isEven( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `+-0`', function test( t ) {
-	t.equal( isEven( +0.0 ), true, 'returns expected value' );
-	t.equal( isEven( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isEven( +0.0 ), true, 'returns expected value' );
+	t.strictEqual( isEven( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', function test( t ) {
-	t.equal( isEven( PINF ), true, 'returns expected value' );
+	t.strictEqual( isEven( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', function test( t ) {
-	t.equal( isEven( NINF ), true, 'returns expected value' );
+	t.strictEqual( isEven( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isEven( NaN ), false, 'returns expected value' );
-	t.equal( isEven( 0.0/0.0 ), false, 'returns expected value' );
+	t.strictEqual( isEven( NaN ), false, 'returns expected value' );
+	t.strictEqual( isEven( 0.0/0.0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-even/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-even/test/test.native.js
index d55bb996403c..3004b8a401f2 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-even/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-even/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'the function returns `true` if provided an even number', opts, function t
 		x = round( randu()*1.0e6 ) - 5.0e5;
 		x *= 2; // always even
 		bool = isEven( x );
-		t.equal( bool, true, 'returns expected value when provided '+x );
+		t.strictEqual( bool, true, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -68,29 +68,29 @@ tape( 'the function returns `false` if provided an odd number', opts, function t
 			x += 1;
 		}
 		bool = isEven( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `+-0`', opts, function test( t ) {
-	t.equal( isEven( +0.0 ), true, 'returns expected value' );
-	t.equal( isEven( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isEven( +0.0 ), true, 'returns expected value' );
+	t.strictEqual( isEven( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isEven( PINF ), true, 'returns expected value' );
+	t.strictEqual( isEven( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isEven( NINF ), true, 'returns expected value' );
+	t.strictEqual( isEven( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isEven( NaN ), false, 'returns expected value' );
-	t.equal( isEven( 0.0/0.0 ), false, 'returns expected value' );
+	t.strictEqual( isEven( NaN ), false, 'returns expected value' );
+	t.strictEqual( isEven( 0.0/0.0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-evenf/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-evenf/test/test.js
index 45a2fd4b88e3..13266a97bfd0 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-evenf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-evenf/test/test.js
@@ -44,7 +44,7 @@ tape( 'the function returns `true` if provided an even number', function test( t
 		x = roundf( randu() * 1.0e6 ) - 5.0e5;
 		x *= 2; // always even
 		bool = isEvenf( x );
-		t.equal( bool, true, 'returns expected value when provided '+x );
+		t.strictEqual( bool, true, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -59,29 +59,29 @@ tape( 'the function returns `false` if provided an odd number', function test( t
 			x += 1;
 		}
 		bool = isEvenf( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `+-0`', function test( t ) {
-	t.equal( isEvenf( +0.0 ), true, 'returns expected value' );
-	t.equal( isEvenf( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isEvenf( +0.0 ), true, 'returns expected value' );
+	t.strictEqual( isEvenf( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', function test( t ) {
-	t.equal( isEvenf( PINF ), true, 'returns expected value' );
+	t.strictEqual( isEvenf( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', function test( t ) {
-	t.equal( isEvenf( NINF ), true, 'returns expected value' );
+	t.strictEqual( isEvenf( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isEvenf( NaN ), false, 'returns expected value' );
-	t.equal( isEvenf( 0.0 / 0.0 ), false, 'returns expected value' );
+	t.strictEqual( isEvenf( NaN ), false, 'returns expected value' );
+	t.strictEqual( isEvenf( 0.0 / 0.0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-evenf/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-evenf/test/test.native.js
index 3dbc29af5ee4..be4682b3a7e5 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-evenf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-evenf/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'the function returns `true` if provided an even number', opts, function t
 		x = roundf( randu() * 1.0e6 ) - 5.0e5;
 		x *= 2; // always even
 		bool = isEvenf( x );
-		t.equal( bool, true, 'returns expected value when provided '+x );
+		t.strictEqual( bool, true, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -68,29 +68,29 @@ tape( 'the function returns `false` if provided an odd number', opts, function t
 			x += 1;
 		}
 		bool = isEvenf( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `+-0`', opts, function test( t ) {
-	t.equal( isEvenf( +0.0 ), true, 'returns expected value' );
-	t.equal( isEvenf( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isEvenf( +0.0 ), true, 'returns expected value' );
+	t.strictEqual( isEvenf( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isEvenf( PINF ), true, 'returns expected value' );
+	t.strictEqual( isEvenf( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isEvenf( NINF ), true, 'returns expected value' );
+	t.strictEqual( isEvenf( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isEvenf( NaN ), false, 'returns expected value' );
-	t.equal( isEvenf( 0.0 / 0.0 ), false, 'returns expected value' );
+	t.strictEqual( isEvenf( NaN ), false, 'returns expected value' );
+	t.strictEqual( isEvenf( 0.0 / 0.0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-finite/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-finite/test/test.js
index a8706d9ebaa7..3218d8a1eea4 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-finite/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-finite/test/test.js
@@ -48,26 +48,26 @@ tape( 'the function returns `true` if provided a finite number', function test(
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isfinite( values[i] ), true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( isfinite( values[i] ), true, 'returns expected value when provided '+values[i] );
 	}
 	for ( i = -100; i < 101; i++ ) {
-		t.equal( isfinite( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isfinite( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', function test( t ) {
-	t.equal( isfinite( PINF ), false, 'returns expected value' );
+	t.strictEqual( isfinite( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', function test( t ) {
-	t.equal( isfinite( NINF ), false, 'returns expected value' );
+	t.strictEqual( isfinite( NINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isfinite( NaN ), false, 'returns expected value' );
-	t.equal( isfinite( 0/0 ), false, 'returns expected value' );
+	t.strictEqual( isfinite( NaN ), false, 'returns expected value' );
+	t.strictEqual( isfinite( 0/0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-finite/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-finite/test/test.native.js
index bceeb4422aee..399c68e35538 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-finite/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-finite/test/test.native.js
@@ -57,20 +57,20 @@ tape( 'the function returns `true` if provided a finite number', opts, function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isfinite( values[i] ), true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( isfinite( values[i] ), true, 'returns expected value when provided '+values[i] );
 	}
 	for ( i = -100; i < 101; i++ ) {
-		t.equal( isfinite( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isfinite( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isfinite( PINF ), false, 'returns expected value' );
+	t.strictEqual( isfinite( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isfinite( NINF ), false, 'returns expected value' );
+	t.strictEqual( isfinite( NINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-finitef/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-finitef/test/test.js
index 55f0afeeca35..85eafaf1219a 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-finitef/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-finitef/test/test.js
@@ -48,26 +48,26 @@ tape( 'the function returns `true` if provided a finite number', function test(
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isfinitef( values[i] ), true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( isfinitef( values[i] ), true, 'returns expected value when provided '+values[i] );
 	}
 	for ( i = -100; i < 101; i++ ) {
-		t.equal( isfinitef( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isfinitef( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', function test( t ) {
-	t.equal( isfinitef( PINF ), false, 'returns expected value' );
+	t.strictEqual( isfinitef( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', function test( t ) {
-	t.equal( isfinitef( NINF ), false, 'returns expected value' );
+	t.strictEqual( isfinitef( NINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isfinitef( NaN ), false, 'returns expected value' );
-	t.equal( isfinitef( 0/0 ), false, 'returns expected value' );
+	t.strictEqual( isfinitef( NaN ), false, 'returns expected value' );
+	t.strictEqual( isfinitef( 0/0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-finitef/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-finitef/test/test.native.js
index db03d66702b8..103cb960dec1 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-finitef/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-finitef/test/test.native.js
@@ -57,20 +57,20 @@ tape( 'the function returns `true` if provided a finite number', opts, function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isfinitef( values[i] ), true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( isfinitef( values[i] ), true, 'returns expected value when provided '+values[i] );
 	}
 	for ( i = -100; i < 101; i++ ) {
-		t.equal( isfinitef( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isfinitef( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isfinitef( PINF ), false, 'returns expected value' );
+	t.strictEqual( isfinitef( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isfinitef( NINF ), false, 'returns expected value' );
+	t.strictEqual( isfinitef( NINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-infinite/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-infinite/test/test.js
index 7975c74ccc03..8fc8903ba1cb 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-infinite/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-infinite/test/test.js
@@ -35,12 +35,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `+infinity`', function test( t ) {
-	t.equal( isInfinite( PINF ), true, 'returns expected value' );
+	t.strictEqual( isInfinite( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `-infinity`', function test( t ) {
-	t.equal( isInfinite( NINF ), true, 'returns expected value' );
+	t.strictEqual( isInfinite( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,7 +63,7 @@ tape( 'the function returns `false` if not provided an infinite number', functio
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isInfinite( values[i] ), false, 'returns expected value' );
+		t.strictEqual( isInfinite( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-infinite/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-infinite/test/test.native.js
index 10584eb964c9..767e52318f8c 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-infinite/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-infinite/test/test.native.js
@@ -44,12 +44,12 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isInfinite( PINF ), true, 'returns expected value' );
+	t.strictEqual( isInfinite( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isInfinite( NINF ), true, 'returns expected value' );
+	t.strictEqual( isInfinite( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -72,7 +72,7 @@ tape( 'the function returns `false` if not provided an infinite number', opts, f
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isInfinite( values[i] ), false, 'returns expected value' );
+		t.strictEqual( isInfinite( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-infinitef/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-infinitef/test/test.js
index 69648577234e..871831bc7d2e 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-infinitef/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-infinitef/test/test.js
@@ -35,12 +35,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `+infinity`', function test( t ) {
-	t.equal( isInfinitef( PINF ), true, 'returns expected value' );
+	t.strictEqual( isInfinitef( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `-infinity`', function test( t ) {
-	t.equal( isInfinitef( NINF ), true, 'returns expected value' );
+	t.strictEqual( isInfinitef( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,7 +63,7 @@ tape( 'the function returns `false` if not provided an infinite number', functio
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isInfinitef( values[i] ), false, 'returns expected value' );
+		t.strictEqual( isInfinitef( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-infinitef/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-infinitef/test/test.native.js
index b9241f66415e..b1baa0fdbc96 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-infinitef/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-infinitef/test/test.native.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isInfinitef( PINF ), true, 'returns expected value' );
+	t.strictEqual( isInfinitef( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isInfinitef( NINF ), true, 'returns expected value' );
+	t.strictEqual( isInfinitef( NINF ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-integer/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-integer/test/test.js
index 79c36f28f0b6..f6307702102c 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-integer/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-integer/test/test.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided an integer', function test( t ) {
 	var i;
 	for ( i = -50; i < 51; i++ ) {
-		t.equal( isInteger( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isInteger( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -50,23 +50,23 @@ tape( 'the function returns `false` if not provided an integer', function test(
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu()*100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isInteger( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isInteger( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isInteger( NaN ), false, 'returns expected value' );
+	t.strictEqual( isInteger( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: function returns `true` if provided `+infinity`', function test( t ) {
-	t.equal( isInteger( PINF ), true, 'returns expected value' );
+	t.strictEqual( isInteger( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: function returns `true` if provided `-infinity`', function test( t ) {
-	t.equal( isInteger( NINF ), true, 'returns expected value' );
+	t.strictEqual( isInteger( NINF ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-integer/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-integer/test/test.native.js
index 9b97af19a2f0..a65dfda0b18e 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-integer/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-integer/test/test.native.js
@@ -48,7 +48,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns `true` if provided an integer', opts, function test( t ) {
 	var i;
 	for ( i = -50; i < 51; i++ ) {
-		t.equal( isInteger( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isInteger( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -59,23 +59,23 @@ tape( 'the function returns `false` if not provided an integer', opts, function
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu()*100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isInteger( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isInteger( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isInteger( NaN ), false, 'returns expected value' );
+	t.strictEqual( isInteger( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: function returns `true` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isInteger( PINF ), true, 'returns expected value' );
+	t.strictEqual( isInteger( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: function returns `true` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isInteger( NINF ), true, 'returns expected value' );
+	t.strictEqual( isInteger( NINF ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-integerf/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-integerf/test/test.js
index 749ee3a3aeaa..df0d65f1991a 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-integerf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-integerf/test/test.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided an integer', function test( t ) {
 	var i;
 	for ( i = -50; i < 51; i++ ) {
-		t.equal( isIntegerf( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isIntegerf( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -50,23 +50,23 @@ tape( 'the function returns `false` if not provided an integer', function test(
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu() * 100.0 ) - 50.0;
 		if ( truncf( v ) !== v ) {
-			t.equal( isIntegerf( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isIntegerf( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isIntegerf( NaN ), false, 'returns expected value' );
+	t.strictEqual( isIntegerf( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: function returns `true` if provided `+infinity`', function test( t ) {
-	t.equal( isIntegerf( PINF ), true, 'returns expected value' );
+	t.strictEqual( isIntegerf( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: function returns `true` if provided `-infinity`', function test( t ) {
-	t.equal( isIntegerf( NINF ), true, 'returns expected value' );
+	t.strictEqual( isIntegerf( NINF ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-integerf/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-integerf/test/test.native.js
index 24af5f45ff8a..28053c35bb68 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-integerf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-integerf/test/test.native.js
@@ -48,7 +48,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns `true` if provided an integer', opts, function test( t ) {
 	var i;
 	for ( i = -50; i < 51; i++ ) {
-		t.equal( isIntegerf( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isIntegerf( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -59,23 +59,23 @@ tape( 'the function returns `false` if not provided an integer', opts, function
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu() * 100.0 ) - 50.0;
 		if ( truncf( v ) !== v ) {
-			t.equal( isIntegerf( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isIntegerf( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isIntegerf( NaN ), false, 'returns expected value' );
+	t.strictEqual( isIntegerf( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: function returns `true` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isIntegerf( PINF ), true, 'returns expected value' );
+	t.strictEqual( isIntegerf( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: function returns `true` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isIntegerf( NINF ), true, 'returns expected value' );
+	t.strictEqual( isIntegerf( NINF ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nan/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-nan/test/test.js
index de3968bc2eac..fbaccbc5ba54 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nan/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nan/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `NaN`', function test( t ) {
-	t.equal( isnan( NaN ), true, 'returns expected value' );
+	t.strictEqual( isnan( NaN ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if not provided `NaN`', function test( t ) {
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isnan( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isnan( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nan/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-nan/test/test.native.js
index 8f1a7d0fd1ea..5fd674236b9e 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nan/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nan/test/test.native.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `NaN`', opts, function test( t ) {
-	t.equal( isnan( NaN ), true, 'returns expected value' );
+	t.strictEqual( isnan( NaN ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -65,7 +65,7 @@ tape( 'the function returns `false` if not provided `NaN`', opts, function test(
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isnan( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isnan( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nanf/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-nanf/test/test.js
index 556e8a597bee..0dd8e43e1270 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nanf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nanf/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `NaN`', function test( t ) {
-	t.equal( isnanf( NaN ), true, 'returns expected value' );
+	t.strictEqual( isnanf( NaN ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if not provided `NaN`', function test( t ) {
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isnanf( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isnanf( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nanf/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-nanf/test/test.native.js
index d197806b0f46..07e8fa890b47 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nanf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nanf/test/test.native.js
@@ -42,6 +42,6 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `NaN`', opts, function test( t ) {
-	t.equal( isnanf( NaN ), true, 'returns expected value' );
+	t.strictEqual( isnanf( NaN ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-negative-finite/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-negative-finite/test/test.js
index 09f6da4274b0..2a88fa84aab2 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-negative-finite/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-negative-finite/test/test.js
@@ -34,24 +34,24 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a negative finite number', function test( t ) {
-	t.equal( isNegativeFinite( -3.14 ), true, 'returns expected value' );
-	t.equal( isNegativeFinite( -1.0e308 ), true, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( -3.14 ), true, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( -1.0e308 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a negative finite number', function test( t ) {
-	t.equal( isNegativeFinite( 2.0 ), false, 'returns expected value' );
-	t.equal( isNegativeFinite( 0.0 ), false, 'returns expected value' );
-	t.equal( isNegativeFinite( -0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( 2.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( 0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( -0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', function test( t ) {
-	t.equal( isNegativeFinite( NINF ), false, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( NINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isNegativeFinite( NaN ), false, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( NaN ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-negative-finite/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-negative-finite/test/test.native.js
index d27ff55c9dc6..bac01641b3a1 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-negative-finite/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-negative-finite/test/test.native.js
@@ -43,24 +43,24 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a negative finite number', opts, function test( t ) {
-	t.equal( isNegativeFinite( -3.14 ), true, 'returns expected value' );
-	t.equal( isNegativeFinite( -1.0e308 ), true, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( -3.14 ), true, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( -1.0e308 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a negative finite number', opts, function test( t ) {
-	t.equal( isNegativeFinite( 2.0 ), false, 'returns expected value' );
-	t.equal( isNegativeFinite( 0.0 ), false, 'returns expected value' );
-	t.equal( isNegativeFinite( -0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( 2.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( 0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( -0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isNegativeFinite( NINF ), false, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( NINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isNegativeFinite( NaN ), false, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( NaN ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-negative-integer/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-negative-integer/test/test.js
index db5a5cdc49e0..51b72fd1ab8a 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-negative-integer/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-negative-integer/test/test.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `false` if provided a nonnegative integer', function test( t ) {
 	var i;
 	for ( i = 0; i < 101; i++ ) {
-		t.equal( isNegativeInteger( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isNegativeInteger( i ), false, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -47,7 +47,7 @@ tape( 'the function returns `false` if provided a nonnegative integer', function
 tape( 'the function returns `true` if provided a negative integer', function test( t ) {
 	var i;
 	for ( i = -1; i > -101; i-- ) {
-		t.equal( isNegativeInteger( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isNegativeInteger( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -58,23 +58,23 @@ tape( 'the function returns `false` if not provided an integer', function test(
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu()*100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isNegativeInteger( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isNegativeInteger( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isNegativeInteger( NaN ), false, 'returns expected value' );
+	t.strictEqual( isNegativeInteger( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', function test( t ) {
-	t.equal( isNegativeInteger( NINF ), true, 'returns expected value' );
+	t.strictEqual( isNegativeInteger( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', function test( t ) {
-	t.equal( isNegativeInteger( PINF ), false, 'returns expected value' );
+	t.strictEqual( isNegativeInteger( PINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-negative-integer/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-negative-integer/test/test.native.js
index bffb24c3967c..6ee286643893 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-negative-integer/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-negative-integer/test/test.native.js
@@ -48,7 +48,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns `false` if provided a nonnegative integer', opts, function test( t ) {
 	var i;
 	for ( i = 0; i < 101; i++ ) {
-		t.equal( isNegativeInteger( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isNegativeInteger( i ), false, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if provided a nonnegative integer', opts, fu
 tape( 'the function returns `true` if provided a negative integer', opts, function test( t ) {
 	var i;
 	for ( i = -1; i > -101; i-- ) {
-		t.equal( isNegativeInteger( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isNegativeInteger( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -67,23 +67,23 @@ tape( 'the function returns `false` if not provided an integer', opts, function
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu()*100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isNegativeInteger( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isNegativeInteger( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isNegativeInteger( NaN ), false, 'returns expected value' );
+	t.strictEqual( isNegativeInteger( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isNegativeInteger( NINF ), true, 'returns expected value' );
+	t.strictEqual( isNegativeInteger( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isNegativeInteger( PINF ), false, 'returns expected value' );
+	t.strictEqual( isNegativeInteger( PINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-negative-integerf/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-negative-integerf/test/test.js
index d7398085030b..ba892d525b04 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-negative-integerf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-negative-integerf/test/test.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `false` if provided a nonnegative integer', function test( t ) {
 	var i;
 	for ( i = 0; i < 101; i++ ) {
-		t.equal( isNegativeIntegerf( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isNegativeIntegerf( i ), false, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -47,7 +47,7 @@ tape( 'the function returns `false` if provided a nonnegative integer', function
 tape( 'the function returns `true` if provided a negative integer', function test( t ) {
 	var i;
 	for ( i = -1; i > -101; i-- ) {
-		t.equal( isNegativeIntegerf( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isNegativeIntegerf( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -58,33 +58,33 @@ tape( 'the function returns `false` if not provided an integer', function test(
 	for ( i = 0; i < 100; i++ ) {
 		v = uniform( -50.0, 50.0 );
 		if ( truncf( v ) !== v ) {
-			t.equal( isNegativeIntegerf( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isNegativeIntegerf( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isNegativeIntegerf( NaN ), false, 'returns expected value' );
+	t.strictEqual( isNegativeIntegerf( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', function test( t ) {
-	t.equal( isNegativeIntegerf( PINF ), false, 'returns expected value' );
+	t.strictEqual( isNegativeIntegerf( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+0`', function test( t ) {
-	t.equal( isNegativeIntegerf( +0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeIntegerf( +0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-0`', function test( t ) {
-	t.equal( isNegativeIntegerf( -0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeIntegerf( -0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', function test( t ) {
-	t.equal( isNegativeIntegerf( NINF ), true, 'returns expected value' );
+	t.strictEqual( isNegativeIntegerf( NINF ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-negative-integerf/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-negative-integerf/test/test.native.js
index 4b22fb128411..d0737e3c4183 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-negative-integerf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-negative-integerf/test/test.native.js
@@ -48,7 +48,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns `false` if provided a nonnegative integer', opts, function test( t ) {
 	var i;
 	for ( i = 0; i < 101; i++ ) {
-		t.equal( isNegativeIntegerf( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isNegativeIntegerf( i ), false, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if provided a nonnegative integer', opts, fu
 tape( 'the function returns `true` if provided a negative integer', opts, function test( t ) {
 	var i;
 	for ( i = -1; i > -101; i-- ) {
-		t.equal( isNegativeIntegerf( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isNegativeIntegerf( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -67,33 +67,33 @@ tape( 'the function returns `false` if not provided an integer', opts, function
 	for ( i = 0; i < 100; i++ ) {
 		v = uniform( -50.0, 50.0 );
 		if ( truncf( v ) !== v ) {
-			t.equal( isNegativeIntegerf( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isNegativeIntegerf( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isNegativeIntegerf( NaN ), false, 'returns expected value' );
+	t.strictEqual( isNegativeIntegerf( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isNegativeIntegerf( PINF ), false, 'returns expected value' );
+	t.strictEqual( isNegativeIntegerf( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+0`', opts, function test( t ) {
-	t.equal( isNegativeIntegerf( +0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeIntegerf( +0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-0`', opts, function test( t ) {
-	t.equal( isNegativeIntegerf( -0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeIntegerf( -0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isNegativeIntegerf( NINF ), true, 'returns expected value' );
+	t.strictEqual( isNegativeIntegerf( NINF ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-negative-zero/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-negative-zero/test/test.js
index e6028d02230e..638d792ca314 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-negative-zero/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-negative-zero/test/test.js
@@ -33,12 +33,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `-0`', function test( t ) {
-	t.equal( isNegativeZero( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+0`', function test( t ) {
-	t.equal( isNegativeZero( +0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeZero( +0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns `false` if not provided `-0`', function test( t ) {
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNegativeZero( values[i] ), false, 'returns expected value if provided ' + values[ i ] );
+		t.strictEqual( isNegativeZero( values[i] ), false, 'returns expected value if provided ' + values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-negative-zero/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-negative-zero/test/test.native.js
index 5d8be4954a2f..42f0bc298b3a 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-negative-zero/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-negative-zero/test/test.native.js
@@ -42,12 +42,12 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `-0`', opts, function test( t ) {
-	t.equal( isNegativeZero( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+0`', opts, function test( t ) {
-	t.equal( isNegativeZero( +0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeZero( +0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -70,7 +70,7 @@ tape( 'the function returns `false` if not provided `-0`', opts, function test(
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNegativeZero( values[i] ), false, 'returns expected value if provided ' + values[ i ] );
+		t.strictEqual( isNegativeZero( values[i] ), false, 'returns expected value if provided ' + values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-negative-zerof/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-negative-zerof/test/test.js
index 7989ef6601fe..efc62dcc30e8 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-negative-zerof/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-negative-zerof/test/test.js
@@ -33,13 +33,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `-0`', function test( t ) {
-	t.equal( isNegativeZerof( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+0`', function test( t ) {
-	t.equal( isNegativeZerof( 0.0 ), false, 'returns expected value' );
-	t.equal( isNegativeZerof( +0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( 0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( +0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -62,7 +62,7 @@ tape( 'the function returns `false` if not provided `-0`', function test( t ) {
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNegativeZerof( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isNegativeZerof( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-negative-zerof/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-negative-zerof/test/test.native.js
index 9eb3513e96ce..1762e4ce5322 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-negative-zerof/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-negative-zerof/test/test.native.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `-0`', opts, function test( t ) {
-	t.equal( isNegativeZerof( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+0`', opts, function test( t ) {
-	t.equal( isNegativeZerof( 0.0 ), false, 'returns expected value' );
-	t.equal( isNegativeZerof( +0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( 0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( +0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -71,7 +71,7 @@ tape( 'the function returns `false` if not provided `-0`', opts, function test(
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNegativeZerof( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isNegativeZerof( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-finite/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-finite/test/test.js
index 6d28f5e2db26..c888ef63a131 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-finite/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-finite/test/test.js
@@ -46,7 +46,7 @@ tape( 'the function returns `true` if provided a nonnegative finite number', fun
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonNegativeFinite( values[ i ] ), true, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isNonNegativeFinite( values[ i ] ), true, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
@@ -63,7 +63,7 @@ tape( 'the function returns `false` if not provided a nonnegative finite number'
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonNegativeFinite( values[ i ] ), false, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isNonNegativeFinite( values[ i ] ), false, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-finite/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-finite/test/test.native.js
index f83c649d3b8d..50416ce76ae5 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-finite/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-finite/test/test.native.js
@@ -55,7 +55,7 @@ tape( 'the function returns `true` if provided a nonnegative finite number', opt
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonNegativeFinite( values[ i ] ), true, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isNonNegativeFinite( values[ i ] ), true, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'the function returns `false` if not provided a nonnegative finite number'
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonNegativeFinite( values[ i ] ), false, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isNonNegativeFinite( values[ i ] ), false, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integer/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integer/test/test.js
index 13813a085551..b95bbb803aff 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integer/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integer/test/test.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a nonnegative integer', function test( t ) {
 	var i;
 	for ( i = 0; i < 101; i++ ) {
-		t.equal( isNonNegativeInteger( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isNonNegativeInteger( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -47,7 +47,7 @@ tape( 'the function returns `true` if provided a nonnegative integer', function
 tape( 'the function returns `false` if not provided a nonnegative integer', function test( t ) {
 	var i;
 	for ( i = -1; i > -101; i-- ) {
-		t.equal( isNonNegativeInteger( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isNonNegativeInteger( i ), false, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -58,28 +58,28 @@ tape( 'the function returns `false` if not provided an integer', function test(
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu()*100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isNonNegativeInteger( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isNonNegativeInteger( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isNonNegativeInteger( NaN ), false, 'returns expected value' );
+	t.strictEqual( isNonNegativeInteger( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', function test( t ) {
-	t.equal( isNonNegativeInteger( PINF ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeInteger( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function does not distinguish between positive and negative zero and returns `true` if provided `-0`', function test( t ) {
-	t.equal( isNonNegativeInteger( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeInteger( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', function test( t ) {
-	t.equal( isNonNegativeInteger( NINF ), false, 'returns expected value' );
+	t.strictEqual( isNonNegativeInteger( NINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integer/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integer/test/test.native.js
index 2b1d0663fc9e..428a3dc2b38e 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integer/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integer/test/test.native.js
@@ -48,7 +48,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns `true` if provided a nonnegative integer', opts, function test( t ) {
 	var i;
 	for ( i = 0; i < 101; i++ ) {
-		t.equal( isNonNegativeInteger( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isNonNegativeInteger( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -56,7 +56,7 @@ tape( 'the function returns `true` if provided a nonnegative integer', opts, fun
 tape( 'the function returns `false` if not provided a nonnegative integer', opts, function test( t ) {
 	var i;
 	for ( i = -1; i > -101; i-- ) {
-		t.equal( isNonNegativeInteger( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isNonNegativeInteger( i ), false, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -67,28 +67,28 @@ tape( 'the function returns `false` if not provided an integer', opts, function
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu() * 100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isNonNegativeInteger( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isNonNegativeInteger( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isNonNegativeInteger( NaN ), false, 'returns expected value' );
+	t.strictEqual( isNonNegativeInteger( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isNonNegativeInteger( PINF ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeInteger( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function does not distinguish between positive and negative zero and returns `true` if provided `-0`', opts, function test( t ) {
-	t.equal( isNonNegativeInteger( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeInteger( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isNonNegativeInteger( NINF ), false, 'returns expected value' );
+	t.strictEqual( isNonNegativeInteger( NINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integerf/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integerf/test/test.js
index 9cb10f769ce5..20bf2d5d1800 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integerf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integerf/test/test.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a nonnegative integer', function test( t ) {
 	var i;
 	for ( i = 0; i < 101; i++ ) {
-		t.equal( isNonNegativeIntegerf( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isNonNegativeIntegerf( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -47,7 +47,7 @@ tape( 'the function returns `true` if provided a nonnegative integer', function
 tape( 'the function returns `false` if not provided a nonnegative integer', function test( t ) {
 	var i;
 	for ( i = -1; i > -101; i-- ) {
-		t.equal( isNonNegativeIntegerf( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isNonNegativeIntegerf( i ), false, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -58,28 +58,28 @@ tape( 'the function returns `false` if not provided an integer', function test(
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu() * 100.0 ) - 50.0;
 		if ( truncf( v ) !== v ) {
-			t.equal( isNonNegativeIntegerf( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isNonNegativeIntegerf( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isNonNegativeIntegerf( NaN ), false, 'returns expected value' );
+	t.strictEqual( isNonNegativeIntegerf( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', function test( t ) {
-	t.equal( isNonNegativeIntegerf( PINF ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeIntegerf( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function does not distinguish between positive and negative zero and returns `true` if provided `-0`', function test( t ) {
-	t.equal( isNonNegativeIntegerf( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeIntegerf( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', function test( t ) {
-	t.equal( isNonNegativeIntegerf( NINF ), false, 'returns expected value' );
+	t.strictEqual( isNonNegativeIntegerf( NINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integerf/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integerf/test/test.native.js
index fe5ec76a50eb..4965f64f4b27 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integerf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nonnegative-integerf/test/test.native.js
@@ -48,7 +48,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns `true` if provided a nonnegative integer', opts, function test( t ) {
 	var i;
 	for ( i = 0; i < 101; i++ ) {
-		t.equal( isNonNegativeIntegerf( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isNonNegativeIntegerf( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -56,7 +56,7 @@ tape( 'the function returns `true` if provided a nonnegative integer', opts, fun
 tape( 'the function returns `false` if not provided a nonnegative integer', opts, function test( t ) {
 	var i;
 	for ( i = -1; i > -101; i-- ) {
-		t.equal( isNonNegativeIntegerf( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isNonNegativeIntegerf( i ), false, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -67,28 +67,28 @@ tape( 'the function returns `false` if not provided an integer', opts, function
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu() * 100.0 ) - 50.0;
 		if ( truncf( v ) !== v ) {
-			t.equal( isNonNegativeIntegerf( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isNonNegativeIntegerf( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isNonNegativeIntegerf( NaN ), false, 'returns expected value' );
+	t.strictEqual( isNonNegativeIntegerf( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isNonNegativeIntegerf( PINF ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeIntegerf( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function does not distinguish between positive and negative zero and returns `true` if provided `-0`', opts, function test( t ) {
-	t.equal( isNonNegativeIntegerf( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeIntegerf( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isNonNegativeIntegerf( NINF ), false, 'returns expected value' );
+	t.strictEqual( isNonNegativeIntegerf( NINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-finite/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-finite/test/test.js
index b18e661b5e60..68cc27093749 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-finite/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-finite/test/test.js
@@ -35,38 +35,38 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a nonpositive finite number', function test( t ) {
-	t.equal( isNonPositiveFinite( -3.14 ), true, 'returns expected value' );
-	t.equal( isNonPositiveFinite( 0.0 ), true, 'returns expected value' );
-	t.equal( isNonPositiveFinite( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonPositiveFinite( -3.14 ), true, 'returns expected value' );
+	t.strictEqual( isNonPositiveFinite( 0.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonPositiveFinite( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a positive number', function test( t ) {
 	var bool = isNonPositiveFinite( 3.14 );
-	t.equal( bool, false, 'returns expected value' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
 	var bool = isNonPositiveFinite( NaN );
-	t.equal( bool, false, 'returns expected value' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided positive infinity', function test( t ) {
 	var bool = isNonPositiveFinite( PINF );
-	t.equal( bool, false, 'returns expected value' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided negative infinity', function test( t ) {
 	var bool = isNonPositiveFinite( NINF );
-	t.equal( bool, false, 'returns expected value' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
 	var bool = isNonPositiveFinite( NaN );
-	t.equal( bool, false, 'returns expected value' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-finite/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-finite/test/test.native.js
index 385e3df30b2f..9e51c5ecc115 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-finite/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-finite/test/test.native.js
@@ -55,7 +55,7 @@ tape( 'the function returns `true` if provided a nonpositive finite number', opt
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonPositiveFinite( values[ i ] ), true, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isNonPositiveFinite( values[ i ] ), true, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
@@ -72,12 +72,12 @@ tape( 'the function returns `false` if not provided a nonpositive finite number'
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonPositiveFinite( values[ i ] ), false, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isNonPositiveFinite( values[ i ] ), false, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isNonPositiveFinite( NaN ), false, 'returns expected value' );
+	t.strictEqual( isNonPositiveFinite( NaN ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-integer/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-integer/test/test.js
index c917c0ff9ec2..405f6e4dbd91 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-integer/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-integer/test/test.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `false` if provided a positive integer', function test( t ) {
 	var i;
 	for ( i = 1; i < 101; i++ ) {
-		t.equal( isNonPositiveInteger( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isNonPositiveInteger( i ), false, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -47,7 +47,7 @@ tape( 'the function returns `false` if provided a positive integer', function te
 tape( 'the function returns `true` if provided a nonpositive integer', function test( t ) {
 	var i;
 	for ( i = 0; i > -101; i-- ) {
-		t.equal( isNonPositiveInteger( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isNonPositiveInteger( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -58,28 +58,28 @@ tape( 'the function returns `false` if not provided an integer', function test(
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu()*100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isNonPositiveInteger( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isNonPositiveInteger( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isNonPositiveInteger( NaN ), false, 'returns expected value' );
+	t.strictEqual( isNonPositiveInteger( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', function test( t ) {
-	t.equal( isNonPositiveInteger( NINF ), true, 'returns expected value' );
+	t.strictEqual( isNonPositiveInteger( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function does not distinguish between positive and negative zero and returns `true` if provided `+0`', function test( t ) {
-	t.equal( isNonPositiveInteger( +0.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonPositiveInteger( +0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', function test( t ) {
-	t.equal( isNonPositiveInteger( PINF ), false, 'returns expected value' );
+	t.strictEqual( isNonPositiveInteger( PINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-integer/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-integer/test/test.native.js
index c4284f6f0d21..2281db2220ca 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-integer/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-nonpositive-integer/test/test.native.js
@@ -48,7 +48,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns `false` if provided a positive integer', opts, function test( t ) {
 	var i;
 	for ( i = 1; i < 101; i++ ) {
-		t.equal( isNonPositiveInteger( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isNonPositiveInteger( i ), false, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if provided a positive integer', opts, funct
 tape( 'the function returns `true` if provided a nonpositive integer', opts, function test( t ) {
 	var i;
 	for ( i = 0; i > -101; i-- ) {
-		t.equal( isNonPositiveInteger( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isNonPositiveInteger( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -67,28 +67,28 @@ tape( 'the function returns `false` if not provided an integer', opts, function
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu()*100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isNonPositiveInteger( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isNonPositiveInteger( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isNonPositiveInteger( NaN ), false, 'returns expected value' );
+	t.strictEqual( isNonPositiveInteger( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isNonPositiveInteger( NINF ), true, 'returns expected value' );
+	t.strictEqual( isNonPositiveInteger( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function does not distinguish between positive and negative zero and returns `true` if provided `+0`', opts, function test( t ) {
-	t.equal( isNonPositiveInteger( +0.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonPositiveInteger( +0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isNonPositiveInteger( PINF ), false, 'returns expected value' );
+	t.strictEqual( isNonPositiveInteger( PINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-odd/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-odd/test/test.js
index 92d1e0c7798d..85f27eba4164 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-odd/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-odd/test/test.js
@@ -44,7 +44,7 @@ tape( 'the function returns `false` if provided an even number', function test(
 		x = round( randu()*1.0e6 ) - 5.0e5;
 		x *= 2; // always even
 		bool = isOdd( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -59,29 +59,29 @@ tape( 'the function returns `true` if provided an odd number', function test( t
 			x += 1;
 		}
 		bool = isOdd( x );
-		t.equal( bool, true, 'returns expected value when provided '+x );
+		t.strictEqual( bool, true, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+-0`', function test( t ) {
-	t.equal( isOdd( +0.0 ), false, 'returns expected value' );
-	t.equal( isOdd( -0.0 ), false, 'returns expected value' );
+	t.strictEqual( isOdd( +0.0 ), false, 'returns expected value' );
+	t.strictEqual( isOdd( -0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', function test( t ) {
-	t.equal( isOdd( PINF ), true, 'returns expected value' );
+	t.strictEqual( isOdd( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', function test( t ) {
-	t.equal( isOdd( NINF ), true, 'returns expected value' );
+	t.strictEqual( isOdd( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isOdd( NaN ), false, 'returns expected value' );
-	t.equal( isOdd( 0.0/0.0 ), false, 'returns expected value' );
+	t.strictEqual( isOdd( NaN ), false, 'returns expected value' );
+	t.strictEqual( isOdd( 0.0/0.0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-odd/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-odd/test/test.native.js
index ccd195cf2a4e..9ba3bafc48ae 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-odd/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-odd/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'the function returns `false` if provided an even number', opts, function
 		x = round( randu()*1.0e6 ) - 5.0e5;
 		x *= 2; // always even
 		bool = isOdd( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -68,29 +68,29 @@ tape( 'the function returns `true` if provided an odd number', opts, function te
 			x += 1;
 		}
 		bool = isOdd( x );
-		t.equal( bool, true, 'returns expected value when provided '+x );
+		t.strictEqual( bool, true, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+-0`', opts, function test( t ) {
-	t.equal( isOdd( +0.0 ), false, 'returns expected value' );
-	t.equal( isOdd( -0.0 ), false, 'returns expected value' );
+	t.strictEqual( isOdd( +0.0 ), false, 'returns expected value' );
+	t.strictEqual( isOdd( -0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isOdd( PINF ), true, 'returns expected value' );
+	t.strictEqual( isOdd( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isOdd( NINF ), true, 'returns expected value' );
+	t.strictEqual( isOdd( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isOdd( NaN ), false, 'returns expected value' );
-	t.equal( isOdd( 0.0/0.0 ), false, 'returns expected value' );
+	t.strictEqual( isOdd( NaN ), false, 'returns expected value' );
+	t.strictEqual( isOdd( 0.0/0.0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-oddf/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-oddf/test/test.js
index 8914e8c28cc2..32c78a0c3a40 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-oddf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-oddf/test/test.js
@@ -44,7 +44,7 @@ tape( 'the function returns `false` if provided an even number', function test(
 		x = roundf( randu() * 1.0e6 ) - 5.0e5;
 		x *= 2; // always even
 		bool = isOddf( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -59,29 +59,29 @@ tape( 'the function returns `true` if provided an odd number', function test( t
 			x += 1;
 		}
 		bool = isOddf( x );
-		t.equal( bool, true, 'returns expected value when provided '+x );
+		t.strictEqual( bool, true, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+-0`', function test( t ) {
-	t.equal( isOddf( +0.0 ), false, 'returns expected value' );
-	t.equal( isOddf( -0.0 ), false, 'returns expected value' );
+	t.strictEqual( isOddf( +0.0 ), false, 'returns expected value' );
+	t.strictEqual( isOddf( -0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', function test( t ) {
-	t.equal( isOddf( PINF ), true, 'returns expected value' );
+	t.strictEqual( isOddf( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', function test( t ) {
-	t.equal( isOddf( NINF ), true, 'returns expected value' );
+	t.strictEqual( isOddf( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isOddf( NaN ), false, 'returns expected value' );
-	t.equal( isOddf( 0.0 / 0.0 ), false, 'returns expected value' );
+	t.strictEqual( isOddf( NaN ), false, 'returns expected value' );
+	t.strictEqual( isOddf( 0.0 / 0.0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-oddf/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-oddf/test/test.native.js
index a8121037ef01..a1286aed0be6 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-oddf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-oddf/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'the function returns `false` if provided an even number', opts, function
 		x = roundf( randu() * 1.0e6 ) - 5.0e5;
 		x *= 2; // always even
 		bool = isOddf( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -68,29 +68,29 @@ tape( 'the function returns `true` if provided an odd number', opts, function te
 			x += 1;
 		}
 		bool = isOddf( x );
-		t.equal( bool, true, 'returns expected value when provided '+x );
+		t.strictEqual( bool, true, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+-0`', opts, function test( t ) {
-	t.equal( isOddf( +0.0 ), false, 'returns expected value' );
-	t.equal( isOddf( -0.0 ), false, 'returns expected value' );
+	t.strictEqual( isOddf( +0.0 ), false, 'returns expected value' );
+	t.strictEqual( isOddf( -0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isOddf( PINF ), true, 'returns expected value' );
+	t.strictEqual( isOddf( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isOddf( NINF ), true, 'returns expected value' );
+	t.strictEqual( isOddf( NINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isOddf( NaN ), false, 'returns expected value' );
-	t.equal( isOddf( 0.0 / 0.0 ), false, 'returns expected value' );
+	t.strictEqual( isOddf( NaN ), false, 'returns expected value' );
+	t.strictEqual( isOddf( 0.0 / 0.0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-positive-finite/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-positive-finite/test/test.js
index 58871fb75a92..ba5695605b4d 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-positive-finite/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-positive-finite/test/test.js
@@ -35,26 +35,26 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a positive finite number', function test( t ) {
-	t.equal( isPositiveFinite( 1.0 ), true, 'returns expected value' );
-	t.equal( isPositiveFinite( 3.14 ), true, 'returns expected value' );
-	t.equal( isPositiveFinite( 1.0e308 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( 1.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( 3.14 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( 1.0e308 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a negative number', function test( t ) {
-	t.equal( isPositiveFinite( -1.0 ), false, 'returns expected value' );
-	t.equal( isPositiveFinite( -3.14 ), false, 'returns expected value' );
-	t.equal( isPositiveFinite( -1.0e308 ), false, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( -1.0 ), false, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( -3.14 ), false, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( -1.0e308 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided +infinity or -infinity', function test( t ) {
-	t.equal( isPositiveFinite( PINF ), false, 'returns expected value' );
-	t.equal( isPositiveFinite( NINF ), false, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( PINF ), false, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( NINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isPositiveFinite( NaN ), false, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( NaN ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-positive-finite/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-positive-finite/test/test.native.js
index 7ee336c30a2f..ff4e6bb81eee 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-positive-finite/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-positive-finite/test/test.native.js
@@ -44,26 +44,26 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a positive finite number', opts, function test( t ) {
-	t.equal( isPositiveFinite( 1.0 ), true, 'returns expected value' );
-	t.equal( isPositiveFinite( 3.14 ), true, 'returns expected value' );
-	t.equal( isPositiveFinite( 1.0e308 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( 1.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( 3.14 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( 1.0e308 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a negative number', opts, function test( t ) {
-	t.equal( isPositiveFinite( -1.0 ), false, 'returns expected value' );
-	t.equal( isPositiveFinite( -3.14 ), false, 'returns expected value' );
-	t.equal( isPositiveFinite( -1.0e308 ), false, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( -1.0 ), false, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( -3.14 ), false, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( -1.0e308 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided +infinity or -infinity', opts, function test( t ) {
-	t.equal( isPositiveFinite( PINF ), false, 'returns expected value' );
-	t.equal( isPositiveFinite( NINF ), false, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( PINF ), false, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( NINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isPositiveFinite( NaN ), false, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( NaN ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-positive-integer/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-positive-integer/test/test.js
index 72f6952961d2..7f71fdcad046 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-positive-integer/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-positive-integer/test/test.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a positive integer', function test( t ) {
 	var i;
 	for ( i = 1; i < 101; i++ ) {
-		t.equal( isPositiveInteger( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isPositiveInteger( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -47,7 +47,7 @@ tape( 'the function returns `true` if provided a positive integer', function tes
 tape( 'the function returns `false` if not provided a positive integer', function test( t ) {
 	var i;
 	for ( i = 0; i > -101; i-- ) {
-		t.equal( isPositiveInteger( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isPositiveInteger( i ), false, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -58,23 +58,23 @@ tape( 'the function returns `false` if not provided an integer', function test(
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu()*100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isPositiveInteger( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isPositiveInteger( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isPositiveInteger( NaN ), false, 'returns expected value' );
+	t.strictEqual( isPositiveInteger( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', function test( t ) {
-	t.equal( isPositiveInteger( PINF ), true, 'returns expected value' );
+	t.strictEqual( isPositiveInteger( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', function test( t ) {
-	t.equal( isPositiveInteger( NINF ), false, 'returns expected value' );
+	t.strictEqual( isPositiveInteger( NINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-positive-integer/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-positive-integer/test/test.native.js
index 9b70e4b991b9..0e9a64e1d87a 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-positive-integer/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-positive-integer/test/test.native.js
@@ -48,7 +48,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns `true` if provided a positive integer', opts, function test( t ) {
 	var i;
 	for ( i = 1; i < 101; i++ ) {
-		t.equal( isPositiveInteger( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isPositiveInteger( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -56,7 +56,7 @@ tape( 'the function returns `true` if provided a positive integer', opts, functi
 tape( 'the function returns `false` if not provided a positive integer', opts, function test( t ) {
 	var i;
 	for ( i = 0; i > -101; i-- ) {
-		t.equal( isPositiveInteger( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isPositiveInteger( i ), false, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -67,23 +67,23 @@ tape( 'the function returns `false` if not provided an integer', opts, function
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu() * 100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isPositiveInteger( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isPositiveInteger( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isPositiveInteger( NaN ), false, 'returns expected value' );
+	t.strictEqual( isPositiveInteger( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'WARNING: the function returns `true` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isPositiveInteger( PINF ), true, 'returns expected value' );
+	t.strictEqual( isPositiveInteger( PINF ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isPositiveInteger( NINF ), false, 'returns expected value' );
+	t.strictEqual( isPositiveInteger( NINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-positive-zero/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-positive-zero/test/test.js
index 0be6a10689e3..163206b7813f 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-positive-zero/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-positive-zero/test/test.js
@@ -33,13 +33,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `+0`', function test( t ) {
-	t.equal( isPositiveZero( 0.0 ), true, 'returns expected value' );
-	t.equal( isPositiveZero( +0.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( 0.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( +0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-0`', function test( t ) {
-	t.equal( isPositiveZero( -0.0 ), false, 'returns expected value' );
+	t.strictEqual( isPositiveZero( -0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -62,7 +62,7 @@ tape( 'the function returns `false` if not provided `+0`', function test( t ) {
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPositiveZero( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isPositiveZero( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-positive-zero/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-positive-zero/test/test.native.js
index 6cdfeb807f46..9a971824e03b 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-positive-zero/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-positive-zero/test/test.native.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `+0`', opts, function test( t ) {
-	t.equal( isPositiveZero( 0.0 ), true, 'returns expected value' );
-	t.equal( isPositiveZero( +0.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( 0.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( +0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-0`', opts, function test( t ) {
-	t.equal( isPositiveZero( -0.0 ), false, 'returns expected value' );
+	t.strictEqual( isPositiveZero( -0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -71,7 +71,7 @@ tape( 'the function returns `false` if not provided `+0`', opts, function test(
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPositiveZero( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isPositiveZero( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-positive-zerof/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-positive-zerof/test/test.js
index cde934301ef3..761ca0951603 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-positive-zerof/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-positive-zerof/test/test.js
@@ -33,13 +33,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `+0`', function test( t ) {
-	t.equal( isPositiveZerof( 0.0 ), true, 'returns expected value' );
-	t.equal( isPositiveZerof( +0.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( 0.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( +0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-0`', function test( t ) {
-	t.equal( isPositiveZerof( -0.0 ), false, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( -0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -62,7 +62,7 @@ tape( 'the function returns `false` if not provided `+0`', function test( t ) {
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPositiveZerof( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isPositiveZerof( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-positive-zerof/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-positive-zerof/test/test.native.js
index 5e12ea05f2a6..0079ba1d277c 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-positive-zerof/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-positive-zerof/test/test.native.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `+0`', opts, function test( t ) {
-	t.equal( isPositiveZerof( 0.0 ), true, 'returns expected value' );
-	t.equal( isPositiveZerof( +0.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( 0.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( +0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-0`', opts, function test( t ) {
-	t.equal( isPositiveZerof( -0.0 ), false, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( -0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -71,7 +71,7 @@ tape( 'the function returns `false` if not provided `+0`', opts, function test(
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPositiveZerof( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isPositiveZerof( values[i] ), false, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-prime/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-prime/test/test.js
index cfdb16533ca8..b8132a44d403 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-prime/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-prime/test/test.js
@@ -49,14 +49,14 @@ tape( 'the function returns `true` if provided a prime number', function test( t
 	M = 2e4;
 	for ( i = 0; i < M; i++ ) {
 		v = PRIMES[ i ];
-		t.equal( isPrime( v ), true, 'returns expected value when provided '+v );
+		t.strictEqual( isPrime( v ), true, 'returns expected value when provided '+v );
 	}
 	// Randomly test prime numbers chosen from the remainder of the list of known prime numbers...
 	N = PRIMES.length - 1;
 	for ( i = 0; i < 1e3; i++ ) {
 		j = discreteUniform( M, N );
 		v = PRIMES[ j ];
-		t.equal( isPrime( v ), true, 'returns expected value when provided '+v );
+		t.strictEqual( isPrime( v ), true, 'returns expected value when provided '+v );
 	}
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'the function returns `false` if provided a composite number', function te
 		if ( hash[ i ] ) {
 			continue;
 		}
-		t.equal( isPrime( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isPrime( i ), false, 'returns expected value when provided '+i );
 	}
 	// Generate random composite integers...
 	MAX = PRIMES[ N-1 ];
@@ -95,7 +95,7 @@ tape( 'the function returns `false` if provided a composite number', function te
 			i -= 1;
 			continue;
 		}
-		t.equal( isPrime( j ), false, 'returns expected value when provided '+j );
+		t.strictEqual( isPrime( j ), false, 'returns expected value when provided '+j );
 	}
 	t.end();
 });
@@ -106,23 +106,23 @@ tape( 'the function returns `false` if not provided a positive integer', functio
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu() * 100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isPrime( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isPrime( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isPrime( NaN ), false, 'returns expected value' );
+	t.strictEqual( isPrime( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', function test( t ) {
-	t.equal( isPrime( PINF ), false, 'returns expected value' );
+	t.strictEqual( isPrime( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', function test( t ) {
-	t.equal( isPrime( NINF ), false, 'returns expected value' );
+	t.strictEqual( isPrime( NINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-prime/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-prime/test/test.native.js
index 62f1bb118eef..72f0c7213f3a 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-prime/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-prime/test/test.native.js
@@ -58,14 +58,14 @@ tape( 'the function returns `true` if provided a prime number', opts, function t
 	M = 2e4;
 	for ( i = 0; i < M; i++ ) {
 		v = PRIMES[ i ];
-		t.equal( isPrime( v ), true, 'returns expected value when provided '+v );
+		t.strictEqual( isPrime( v ), true, 'returns expected value when provided '+v );
 	}
 	// Randomly test prime numbers chosen from the remainder of the list of known prime numbers...
 	N = PRIMES.length - 1;
 	for ( i = 0; i < 1e3; i++ ) {
 		j = discreteUniform( M, N );
 		v = PRIMES[ j ];
-		t.equal( isPrime( v ), true, 'returns expected value when provided '+v );
+		t.strictEqual( isPrime( v ), true, 'returns expected value when provided '+v );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns `false` if provided a composite number', opts, funct
 		if ( hash[ i ] ) {
 			continue;
 		}
-		t.equal( isPrime( i ), false, 'returns expected value when provided '+i );
+		t.strictEqual( isPrime( i ), false, 'returns expected value when provided '+i );
 	}
 	// Generate random composite integers...
 	MAX = PRIMES[ N-1 ];
@@ -104,7 +104,7 @@ tape( 'the function returns `false` if provided a composite number', opts, funct
 			i -= 1;
 			continue;
 		}
-		t.equal( isPrime( j ), false, 'returns expected value when provided '+j );
+		t.strictEqual( isPrime( j ), false, 'returns expected value when provided '+j );
 	}
 	t.end();
 });
@@ -115,23 +115,23 @@ tape( 'the function returns `false` if not provided a positive integer', opts, f
 	for ( i = 0; i < 100; i++ ) {
 		v = ( randu() * 100.0 ) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isPrime( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isPrime( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isPrime( NaN ), false, 'returns expected value' );
+	t.strictEqual( isPrime( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isPrime( PINF ), false, 'returns expected value' );
+	t.strictEqual( isPrime( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isPrime( NINF ), false, 'returns expected value' );
+	t.strictEqual( isPrime( NINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-probability/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-probability/test/test.js
index 7a5ef76b57e0..cb110a99007a 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-probability/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-probability/test/test.js
@@ -42,7 +42,7 @@ tape( 'the function returns `false` if provided a number less than `0.0`', funct
 	for ( i = 0; i < 1000; i++ ) {
 		x = -1.0 - ( randu() * 1000.0 );
 		bool = isProbability( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -54,7 +54,7 @@ tape( 'the function returns `false` if provided a number greater than `1.0`', fu
 	for ( i = 0; i < 1000; i++ ) {
 		x = ( randu() * 1000.0 ) + 2.0;
 		bool = isProbability( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -66,34 +66,34 @@ tape( 'the function returns `true` if provided a probability', function test( t
 	for ( i = 0; i < 1000; i++ ) {
 		x = randu();
 		bool = isProbability( x );
-		t.equal( bool, true, 'returns expected value when provided '+x );
+		t.strictEqual( bool, true, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `+-0`', function test( t ) {
-	t.equal( isProbability( 0.0 ), true, 'returns expected value' );
-	t.equal( isProbability( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isProbability( 0.0 ), true, 'returns expected value' );
+	t.strictEqual( isProbability( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `1`', function test( t ) {
-	t.equal( isProbability( 1.0 ), true, 'returns expected value' );
+	t.strictEqual( isProbability( 1.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', function test( t ) {
-	t.equal( isProbability( PINF ), false, 'returns expected value' );
+	t.strictEqual( isProbability( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', function test( t ) {
-	t.equal( isProbability( NINF ), false, 'returns expected value' );
+	t.strictEqual( isProbability( NINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isProbability( NaN ), false, 'returns expected value' );
-	t.equal( isProbability( 0.0 / 0.0 ), false, 'returns expected value' );
+	t.strictEqual( isProbability( NaN ), false, 'returns expected value' );
+	t.strictEqual( isProbability( 0.0 / 0.0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-probability/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-probability/test/test.native.js
index a8022bf23cb3..184a2675d041 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-probability/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-probability/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'the function returns `false` if provided a number less than `0.0`', opts,
 	for ( i = 0; i < 1000; i++ ) {
 		x = -1.0 - ( randu() * 1000.0 );
 		bool = isProbability( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -63,7 +63,7 @@ tape( 'the function returns `false` if provided a number greater than `1.0`', op
 	for ( i = 0; i < 1000; i++ ) {
 		x = ( randu() * 1000.0 ) + 2.0;
 		bool = isProbability( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -75,34 +75,34 @@ tape( 'the function returns `true` if provided a probability', opts, function te
 	for ( i = 0; i < 1000; i++ ) {
 		x = randu();
 		bool = isProbability( x );
-		t.equal( bool, true, 'returns expected value when provided '+x );
+		t.strictEqual( bool, true, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `+-0`', opts, function test( t ) {
-	t.equal( isProbability( 0.0 ), true, 'returns expected value' );
-	t.equal( isProbability( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isProbability( 0.0 ), true, 'returns expected value' );
+	t.strictEqual( isProbability( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `1`', opts, function test( t ) {
-	t.equal( isProbability( 1.0 ), true, 'returns expected value' );
+	t.strictEqual( isProbability( 1.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isProbability( PINF ), false, 'returns expected value' );
+	t.strictEqual( isProbability( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isProbability( NINF ), false, 'returns expected value' );
+	t.strictEqual( isProbability( NINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isProbability( NaN ), false, 'returns expected value' );
-	t.equal( isProbability( 0.0 / 0.0 ), false, 'returns expected value' );
+	t.strictEqual( isProbability( NaN ), false, 'returns expected value' );
+	t.strictEqual( isProbability( 0.0 / 0.0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-probabilityf/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-probabilityf/test/test.js
index 0160e5f6efa9..bbd29bfd005e 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-probabilityf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-probabilityf/test/test.js
@@ -42,7 +42,7 @@ tape( 'the function returns `false` if provided a number less than `0.0`', funct
 	for ( i = 0; i < 1000; i++ ) {
 		x = -1.0 - ( randu() * 1000.0 );
 		bool = isProbabilityf( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -54,7 +54,7 @@ tape( 'the function returns `false` if provided a number greater than `1.0`', fu
 	for ( i = 0; i < 1000; i++ ) {
 		x = ( randu() * 1000.0 ) + 2.0;
 		bool = isProbabilityf( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -66,34 +66,34 @@ tape( 'the function returns `true` if provided a probability', function test( t
 	for ( i = 0; i < 1000; i++ ) {
 		x = randu();
 		bool = isProbabilityf( x );
-		t.equal( bool, true, 'returns expected value when provided '+x );
+		t.strictEqual( bool, true, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `+-0`', function test( t ) {
-	t.equal( isProbabilityf( 0.0 ), true, 'returns expected value' );
-	t.equal( isProbabilityf( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isProbabilityf( 0.0 ), true, 'returns expected value' );
+	t.strictEqual( isProbabilityf( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `1`', function test( t ) {
-	t.equal( isProbabilityf( 1.0 ), true, 'returns expected value' );
+	t.strictEqual( isProbabilityf( 1.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', function test( t ) {
-	t.equal( isProbabilityf( PINF ), false, 'returns expected value' );
+	t.strictEqual( isProbabilityf( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', function test( t ) {
-	t.equal( isProbabilityf( NINF ), false, 'returns expected value' );
+	t.strictEqual( isProbabilityf( NINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isProbabilityf( NaN ), false, 'returns expected value' );
-	t.equal( isProbabilityf( 0.0 / 0.0 ), false, 'returns expected value' );
+	t.strictEqual( isProbabilityf( NaN ), false, 'returns expected value' );
+	t.strictEqual( isProbabilityf( 0.0 / 0.0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-probabilityf/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-probabilityf/test/test.native.js
index 5cd7db10e954..45efb25828b3 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-probabilityf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-probabilityf/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'the function returns `false` if provided a number less than `0.0`', opts,
 	for ( i = 0; i < 1000; i++ ) {
 		x = -1.0 - ( randu() * 1000.0 );
 		bool = isProbabilityf( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -63,7 +63,7 @@ tape( 'the function returns `false` if provided a number greater than `1.0`', op
 	for ( i = 0; i < 1000; i++ ) {
 		x = ( randu() * 1000.0 ) + 2.0;
 		bool = isProbabilityf( x );
-		t.equal( bool, false, 'returns expected value when provided '+x );
+		t.strictEqual( bool, false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -75,34 +75,34 @@ tape( 'the function returns `true` if provided a probability', opts, function te
 	for ( i = 0; i < 1000; i++ ) {
 		x = randu();
 		bool = isProbabilityf( x );
-		t.equal( bool, true, 'returns expected value when provided '+x );
+		t.strictEqual( bool, true, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `+-0`', opts, function test( t ) {
-	t.equal( isProbabilityf( 0.0 ), true, 'returns expected value' );
-	t.equal( isProbabilityf( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isProbabilityf( 0.0 ), true, 'returns expected value' );
+	t.strictEqual( isProbabilityf( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided `1`', opts, function test( t ) {
-	t.equal( isProbabilityf( 1.0 ), true, 'returns expected value' );
+	t.strictEqual( isProbabilityf( 1.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isProbabilityf( PINF ), false, 'returns expected value' );
+	t.strictEqual( isProbabilityf( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isProbabilityf( NINF ), false, 'returns expected value' );
+	t.strictEqual( isProbabilityf( NINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isProbabilityf( NaN ), false, 'returns expected value' );
-	t.equal( isProbabilityf( 0.0 / 0.0 ), false, 'returns expected value' );
+	t.strictEqual( isProbabilityf( NaN ), false, 'returns expected value' );
+	t.strictEqual( isProbabilityf( 0.0 / 0.0 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-safe-integer/test/test.js b/lib/node_modules/@stdlib/math/base/assert/is-safe-integer/test/test.js
index b610d38e7721..f9c6fd98efe2 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-safe-integer/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-safe-integer/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a safe integer', function test( t ) {
 	var i;
 	for ( i = -50; i < 51; i++ ) {
-		t.equal( isSafeInteger( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isSafeInteger( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -51,7 +51,7 @@ tape( 'the function returns `false` if provided an integer greater than the max
 	var i;
 	for ( i = 1; i < 100; i++ ) {
 		x = MAX_SAFE_INTEGER + 1 + i;
-		t.equal( isSafeInteger( x ), false, 'returns expected value when provided '+x );
+		t.strictEqual( isSafeInteger( x ), false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -61,7 +61,7 @@ tape( 'the function returns `false` if provided an integer less than the min saf
 	var i;
 	for ( i = 0; i < 100; i++ ) {
 		x = MIN_SAFE_INTEGER - 1 - i;
-		t.equal( isSafeInteger( x ), false, 'returns expected value when provided '+x );
+		t.strictEqual( isSafeInteger( x ), false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -72,33 +72,33 @@ tape( 'the function returns `false` if not provided an integer', function test(
 	for ( i = 0; i < 100; i++ ) {
 		v = (randu()*100.0) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isSafeInteger( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isSafeInteger( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided maximum safe integer', function test( t ) {
-	t.equal( isSafeInteger( MAX_SAFE_INTEGER ), true, 'returns expected value' );
+	t.strictEqual( isSafeInteger( MAX_SAFE_INTEGER ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided minimum safe integer', function test( t ) {
-	t.equal( isSafeInteger( MIN_SAFE_INTEGER ), true, 'returns expected value' );
+	t.strictEqual( isSafeInteger( MIN_SAFE_INTEGER ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', function test( t ) {
-	t.equal( isSafeInteger( NaN ), false, 'returns expected value' );
+	t.strictEqual( isSafeInteger( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', function test( t ) {
-	t.equal( isSafeInteger( PINF ), false, 'returns expected value' );
+	t.strictEqual( isSafeInteger( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', function test( t ) {
-	t.equal( isSafeInteger( NINF ), false, 'returns expected value' );
+	t.strictEqual( isSafeInteger( NINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/is-safe-integer/test/test.native.js b/lib/node_modules/@stdlib/math/base/assert/is-safe-integer/test/test.native.js
index ec951c604d2b..0e8511d74696 100644
--- a/lib/node_modules/@stdlib/math/base/assert/is-safe-integer/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/assert/is-safe-integer/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns `true` if provided a safe integer', opts, function test( t ) {
 	var i;
 	for ( i = -50; i < 51; i++ ) {
-		t.equal( isSafeInteger( i ), true, 'returns expected value when provided '+i );
+		t.strictEqual( isSafeInteger( i ), true, 'returns expected value when provided '+i );
 	}
 	t.end();
 });
@@ -60,7 +60,7 @@ tape( 'the function returns `false` if provided an integer greater than the max
 	var i;
 	for ( i = 1; i < 100; i++ ) {
 		x = MAX_SAFE_INTEGER + 1 + i;
-		t.equal( isSafeInteger( x ), false, 'returns expected value when provided '+x );
+		t.strictEqual( isSafeInteger( x ), false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'the function returns `false` if provided an integer less than the min saf
 	var i;
 	for ( i = 0; i < 100; i++ ) {
 		x = MIN_SAFE_INTEGER - 1 - i;
-		t.equal( isSafeInteger( x ), false, 'returns expected value when provided '+x );
+		t.strictEqual( isSafeInteger( x ), false, 'returns expected value when provided '+x );
 	}
 	t.end();
 });
@@ -81,33 +81,33 @@ tape( 'the function returns `false` if not provided an integer', opts, function
 	for ( i = 0; i < 100; i++ ) {
 		v = (randu()*100.0) - 50.0;
 		if ( trunc(v) !== v ) {
-			t.equal( isSafeInteger( v ), false, 'returns expected value when provided '+v );
+			t.strictEqual( isSafeInteger( v ), false, 'returns expected value when provided '+v );
 		}
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided maximum safe integer', opts, function test( t ) {
-	t.equal( isSafeInteger( MAX_SAFE_INTEGER ), true, 'returns expected value' );
+	t.strictEqual( isSafeInteger( MAX_SAFE_INTEGER ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided minimum safe integer', opts, function test( t ) {
-	t.equal( isSafeInteger( MIN_SAFE_INTEGER ), true, 'returns expected value' );
+	t.strictEqual( isSafeInteger( MIN_SAFE_INTEGER ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `NaN`', opts, function test( t ) {
-	t.equal( isSafeInteger( NaN ), false, 'returns expected value' );
+	t.strictEqual( isSafeInteger( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `+infinity`', opts, function test( t ) {
-	t.equal( isSafeInteger( PINF ), false, 'returns expected value' );
+	t.strictEqual( isSafeInteger( PINF ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided `-infinity`', opts, function test( t ) {
-	t.equal( isSafeInteger( NINF ), false, 'returns expected value' );
+	t.strictEqual( isSafeInteger( NINF ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/assert/test/test.js b/lib/node_modules/@stdlib/math/base/assert/test/test.js
index e4bd98fd14c5..bbe700ffcf3d 100644
--- a/lib/node_modules/@stdlib/math/base/assert/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/assert/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains base math assertion utilities', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/napi/test/test.js b/lib/node_modules/@stdlib/math/base/napi/test/test.js
index 4703875b1edd..e682e93dba4d 100644
--- a/lib/node_modules/@stdlib/math/base/napi/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/napi/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/abs/test/test.abs.js b/lib/node_modules/@stdlib/math/base/special/abs/test/test.abs.js
index b2ef9fb4612d..8824da9cf382 100644
--- a/lib/node_modules/@stdlib/math/base/special/abs/test/test.abs.js
+++ b/lib/node_modules/@stdlib/math/base/special/abs/test/test.abs.js
@@ -38,26 +38,26 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function computes the absolute value of a number', function test( t ) {
-	t.equal( abs( -2.0 ), 2.0, 'negative number' );
-	t.equal( abs( 3.0 ), 3.0, 'positive number' );
-	t.equal( abs( 0.0 ), 0.0, 'zero' );
-	t.equal( abs( -PI ), PI, 'pi' );
+	t.strictEqual( abs( -2.0 ), 2.0, 'negative number' );
+	t.strictEqual( abs( 3.0 ), 3.0, 'positive number' );
+	t.strictEqual( abs( 0.0 ), 0.0, 'zero' );
+	t.strictEqual( abs( -PI ), PI, 'pi' );
 	t.end();
 });
 
 tape( 'the function computes the absolute value of negative zero', function test( t ) {
-	t.equal( isPositiveZero( abs( -0.0 ) ), true, 'returns positive zero' );
+	t.strictEqual( isPositiveZero( abs( -0.0 ) ), true, 'returns positive zero' );
 	t.end();
 });
 
 tape( 'the function computes the absolute value of infinity', function test( t ) {
-	t.equal( abs( PINF ), PINF, 'returns +infinity' );
-	t.equal( abs( NINF ), PINF, 'returns +infinity' );
+	t.strictEqual( abs( PINF ), PINF, 'returns +infinity' );
+	t.strictEqual( abs( NINF ), PINF, 'returns +infinity' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = abs( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/abs/test/test.high.js b/lib/node_modules/@stdlib/math/base/special/abs/test/test.high.js
index b505b360592b..4e4d6a22f352 100644
--- a/lib/node_modules/@stdlib/math/base/special/abs/test/test.high.js
+++ b/lib/node_modules/@stdlib/math/base/special/abs/test/test.high.js
@@ -33,20 +33,20 @@ tape( 'main export is a number', function test( t ) {
 	t.end();
 });
 
-tape( 'if little endian, the export equals 1', function test( t ) {
+tape( 'if little endian, the export.strictEquals 1', function test( t ) {
 	var HIGH = proxyquire( './../lib/high.js', {
 		'@stdlib/assert/is-little-endian': true
 	});
 
-	t.equal( HIGH, 1, 'HIGH equals 1' );
+	t.strictEqual( HIGH, 1, 'HIGH equals 1' );
 	t.end();
 });
 
-tape( 'if big endian, the export equals 0', function test( t ) {
+tape( 'if big endian, the export.strictEquals 0', function test( t ) {
 	var HIGH = proxyquire( './../lib/high.js', {
 		'@stdlib/assert/is-little-endian': 'beep' // a value other than `true`
 	});
 
-	t.equal( HIGH, 0, 'HIGH equals 0' );
+	t.strictEqual( HIGH, 0, 'HIGH equals 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/absf/test/test.abs.js b/lib/node_modules/@stdlib/math/base/special/absf/test/test.abs.js
index 7aff6fe91010..923144efdbca 100644
--- a/lib/node_modules/@stdlib/math/base/special/absf/test/test.abs.js
+++ b/lib/node_modules/@stdlib/math/base/special/absf/test/test.abs.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function computes the absolute value of a number', function test( t ) {
-	t.equal( absf( -2.0 ), 2.0, 'returns expected value' );
-	t.equal( absf( 3.0 ), 3.0, 'returns expected value' );
-	t.equal( absf( 0.0 ), 0.0, 'returns expected value' );
+	t.strictEqual( absf( -2.0 ), 2.0, 'returns expected value' );
+	t.strictEqual( absf( 3.0 ), 3.0, 'returns expected value' );
+	t.strictEqual( absf( 0.0 ), 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function computes the absolute value of negative zero', function test( t ) {
-	t.equal( isPositiveZerof( absf( -0.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( absf( -0.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function computes the absolute value of infinity', function test( t ) {
-	t.equal( absf( PINF ), PINF, 'returns expected value' );
-	t.equal( absf( NINF ), PINF, 'returns expected value' );
+	t.strictEqual( absf( PINF ), PINF, 'returns expected value' );
+	t.strictEqual( absf( NINF ), PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = absf( NaN );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/betaln/test/test.dceval.js b/lib/node_modules/@stdlib/math/base/special/betaln/test/test.dceval.js
index 92226c95e726..7c40d5c513e5 100644
--- a/lib/node_modules/@stdlib/math/base/special/betaln/test/test.dceval.js
+++ b/lib/node_modules/@stdlib/math/base/special/betaln/test/test.dceval.js
@@ -35,16 +35,16 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `NaN` if provided `x` outside `[-1.1,1.1]`', function test( t ) {
 	var y = dceval( 1.5, [1, 2, 3] );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = dceval( 1.11, [1, 2, 3] );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = dceval( -1.11, [1, 2, 3] );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = dceval( -1.5, [1, 2, 3] );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/cabs2f/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/cabs2f/test/test.native.js
index 4d5990cf523b..d1defde8ff2c 100644
--- a/lib/node_modules/@stdlib/math/base/special/cabs2f/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/cabs2f/test/test.native.js
@@ -66,7 +66,7 @@ tape( 'the function computes the squared absolute value of a complex number', op
 	for ( i = 0; i < re.length; i++ ) {
 		y = cabs2f( new Complex64( re[ i ], im[ i ] ) );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 're: '+re[i]+'. im: '+im[i]+'. Expected: '+expected[i] );
+			t.strictEqual( y, expected[ i ], 're: '+re[i]+'. im: '+im[i]+'. Expected: '+expected[i] );
 		} else {
 			delta = absf( y - expected[i] );
 			tol = EPS * absf( expected[i] );
diff --git a/lib/node_modules/@stdlib/math/base/special/cexp/test/test.js b/lib/node_modules/@stdlib/math/base/special/cexp/test/test.js
index 1df455b026ac..926e42f6299b 100644
--- a/lib/node_modules/@stdlib/math/base/special/cexp/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/cexp/test/test.js
@@ -154,7 +154,7 @@ tape( 'if real component is `-Infinity`, the function returns a complex number w
 	t.end();
 });
 
-tape( 'if real component is `+Infinity` and imaginary component is `0.0`, the function returns a complex number with the real component equal to `+Infinity` and imaginary component equal to `0.0`', function test( t ) {
+tape( 'if real component is `+Infinity` and imaginary component is `0.0`, the function returns a complex number with the real component.strictEqual to `+Infinity` and imaginary component.strictEqual to `0.0`', function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( PINF, 0.0 ) );
@@ -163,7 +163,7 @@ tape( 'if real component is `+Infinity` and imaginary component is `0.0`, the fu
 	t.end();
 });
 
-tape( 'if real component is `NaN` and imaginary component is `0.0`, the function returns a complex number with the real component equal to `NaN` and imaginary component equal to `0.0`', function test( t ) {
+tape( 'if real component is `NaN` and imaginary component is `0.0`, the function returns a complex number with the real component.strictEqual to `NaN` and imaginary component.strictEqual to `0.0`', function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( NaN, 0.0 ) );
@@ -190,7 +190,7 @@ tape( 'if imaginary component is `NaN`, the function returns a complex number wi
 	t.end();
 });
 
-tape( 'if imaginary component is `+0.0`, the function returns a complex number with an imaginary component equal to `+0.0`', function test( t ) {
+tape( 'if imaginary component is `+0.0`, the function returns a complex number with an imaginary component.strictEqual to `+0.0`', function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( 3.0, 0.0 ) );
@@ -198,7 +198,7 @@ tape( 'if imaginary component is `+0.0`, the function returns a complex number w
 	t.end();
 });
 
-tape( 'if imaginary component is `-0.0`, the function returns a complex number with an imaginary component equal to `-0.0`', function test( t ) {
+tape( 'if imaginary component is `-0.0`, the function returns a complex number with an imaginary component.strictEqual to `-0.0`', function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( 3.0, -0.0 ) );
@@ -215,7 +215,7 @@ tape( 'if real component is `NaN` and imaginary component is nonzero, the functi
 	t.end();
 });
 
-tape( 'if real component is `NaN` and imaginary component is `+0.0`, the function returns a complex number with an imaginary component equal to `+0.0`', function test( t ) {
+tape( 'if real component is `NaN` and imaginary component is `+0.0`, the function returns a complex number with an imaginary component.strictEqual to `+0.0`', function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( NaN, 0.0 ) );
@@ -224,7 +224,7 @@ tape( 'if real component is `NaN` and imaginary component is `+0.0`, the functio
 	t.end();
 });
 
-tape( 'if real component is `NaN` and imaginary component is `-0.0`, the function returns a complex number with an imaginary component equal to `-0.0`', function test( t ) {
+tape( 'if real component is `NaN` and imaginary component is `-0.0`, the function returns a complex number with an imaginary component.strictEqual to `-0.0`', function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( NaN, -0.0 ) );
@@ -233,7 +233,7 @@ tape( 'if real component is `NaN` and imaginary component is `-0.0`, the functio
 	t.end();
 });
 
-tape( 'if real component is `+Infinity` and imaginary component is `+Infinity`, the function returns a complex number with the real component equal to `-Infinity` and imaginary component equal to `NaN`', function test( t ) {
+tape( 'if real component is `+Infinity` and imaginary component is `+Infinity`, the function returns a complex number with the real component.strictEqual to `-Infinity` and imaginary component.strictEqual to `NaN`', function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( PINF, PINF ) );
@@ -242,7 +242,7 @@ tape( 'if real component is `+Infinity` and imaginary component is `+Infinity`,
 	t.end();
 });
 
-tape( 'if real component is `-Infinity` and imaginary component is `+Infinity`, the function returns a complex number with the real component equal to `-0.0` and imaginary component equal to `+0.0`', function test( t ) {
+tape( 'if real component is `-Infinity` and imaginary component is `+Infinity`, the function returns a complex number with the real component.strictEqual to `-0.0` and imaginary component.strictEqual to `+0.0`', function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( NINF, PINF ) );
@@ -251,7 +251,7 @@ tape( 'if real component is `-Infinity` and imaginary component is `+Infinity`,
 	t.end();
 });
 
-tape( 'if real component is `-Infinity` and imaginary component is `-Infinity`, the function returns a complex number with the real component equal to `-0.0` and imaginary component equal to `-0.0`', function test( t ) {
+tape( 'if real component is `-Infinity` and imaginary component is `-Infinity`, the function returns a complex number with the real component.strictEqual to `-0.0` and imaginary component.strictEqual to `-0.0`', function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( NINF, NINF ) );
diff --git a/lib/node_modules/@stdlib/math/base/special/cexp/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/cexp/test/test.native.js
index b92cc63a6642..40e0ae0d6d8e 100644
--- a/lib/node_modules/@stdlib/math/base/special/cexp/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/cexp/test/test.native.js
@@ -163,7 +163,7 @@ tape( 'if real component is `-Infinity`, the function returns a complex number w
 	t.end();
 });
 
-tape( 'if real component is `+Infinity` and imaginary component is `0.0`, the function returns a complex number with the real component equal to `+Infinity` and imaginary component equal to `0.0`', opts, function test( t ) {
+tape( 'if real component is `+Infinity` and imaginary component is `0.0`, the function returns a complex number with the real component.strictEqual to `+Infinity` and imaginary component.strictEqual to `0.0`', opts, function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( PINF, 0.0 ) );
@@ -172,7 +172,7 @@ tape( 'if real component is `+Infinity` and imaginary component is `0.0`, the fu
 	t.end();
 });
 
-tape( 'if real component is `NaN` and imaginary component is `0.0`, the function returns a complex number with the real component equal to `NaN` and imaginary component equal to `0.0`', opts, function test( t ) {
+tape( 'if real component is `NaN` and imaginary component is `0.0`, the function returns a complex number with the real component.strictEqual to `NaN` and imaginary component.strictEqual to `0.0`', opts, function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( NaN, 0.0 ) );
@@ -199,7 +199,7 @@ tape( 'if imaginary component is `NaN`, the function returns a complex number wi
 	t.end();
 });
 
-tape( 'if imaginary component is `+0.0`, the function returns a complex number with an imaginary component equal to `+0.0`', opts, function test( t ) {
+tape( 'if imaginary component is `+0.0`, the function returns a complex number with an imaginary component.strictEqual to `+0.0`', opts, function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( 3.0, 0.0 ) );
@@ -207,7 +207,7 @@ tape( 'if imaginary component is `+0.0`, the function returns a complex number w
 	t.end();
 });
 
-tape( 'if imaginary component is `-0.0`, the function returns a complex number with an imaginary component equal to `-0.0`', opts, function test( t ) {
+tape( 'if imaginary component is `-0.0`, the function returns a complex number with an imaginary component.strictEqual to `-0.0`', opts, function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( 3.0, -0.0 ) );
@@ -224,7 +224,7 @@ tape( 'if real component is `NaN` and imaginary component is nonzero, the functi
 	t.end();
 });
 
-tape( 'if real component is `NaN` and imaginary component is `+0.0`, the function returns a complex number with an imaginary component equal to `+0.0`', opts, function test( t ) {
+tape( 'if real component is `NaN` and imaginary component is `+0.0`, the function returns a complex number with an imaginary component.strictEqual to `+0.0`', opts, function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( NaN, 0.0 ) );
@@ -233,7 +233,7 @@ tape( 'if real component is `NaN` and imaginary component is `+0.0`, the functio
 	t.end();
 });
 
-tape( 'if real component is `NaN` and imaginary component is `-0.0`, the function returns a complex number with an imaginary component equal to `-0.0`', opts, function test( t ) {
+tape( 'if real component is `NaN` and imaginary component is `-0.0`, the function returns a complex number with an imaginary component.strictEqual to `-0.0`', opts, function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( NaN, -0.0 ) );
@@ -242,7 +242,7 @@ tape( 'if real component is `NaN` and imaginary component is `-0.0`, the functio
 	t.end();
 });
 
-tape( 'if real component is `+Infinity` and imaginary component is `+Infinity`, the function returns a complex number with the real component equal to `-Infinity` and imaginary component equal to `NaN`', opts, function test( t ) {
+tape( 'if real component is `+Infinity` and imaginary component is `+Infinity`, the function returns a complex number with the real component.strictEqual to `-Infinity` and imaginary component.strictEqual to `NaN`', opts, function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( PINF, PINF ) );
@@ -251,7 +251,7 @@ tape( 'if real component is `+Infinity` and imaginary component is `+Infinity`,
 	t.end();
 });
 
-tape( 'if real component is `-Infinity` and imaginary component is `+Infinity`, the function returns a complex number with the real component equal to `-0.0` and imaginary component equal to `+0.0`', opts, function test( t ) {
+tape( 'if real component is `-Infinity` and imaginary component is `+Infinity`, the function returns a complex number with the real component.strictEqual to `-0.0` and imaginary component.strictEqual to `+0.0`', opts, function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( NINF, PINF ) );
@@ -260,7 +260,7 @@ tape( 'if real component is `-Infinity` and imaginary component is `+Infinity`,
 	t.end();
 });
 
-tape( 'if real component is `-Infinity` and imaginary component is `-Infinity`, the function returns a complex number with the real component equal to `-0.0` and imaginary component equal to `-0.0`', opts, function test( t ) {
+tape( 'if real component is `-Infinity` and imaginary component is `-Infinity`, the function returns a complex number with the real component.strictEqual to `-0.0` and imaginary component.strictEqual to `-0.0`', opts, function test( t ) {
 	var v;
 
 	v = cexp( new Complex128( NINF, NINF ) );
diff --git a/lib/node_modules/@stdlib/math/base/special/cflipsignf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/cflipsignf/test/test.native.js
index 96b5bad56fec..bc2f3c4c065e 100644
--- a/lib/node_modules/@stdlib/math/base/special/cflipsignf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/cflipsignf/test/test.native.js
@@ -82,8 +82,8 @@ tape( 'the function evaluates the flipsign function', opts, function test( t ) {
 		are = real( ans );
 		aim = imag( ans );
 		if ( are === ere[ i ] && aim === eim[ i ] ) {
-			t.equal( are, ere[ i ], 're: '+re[ i ]+'. Expected: '+ere[ i ] );
-			t.equal( aim, eim[ i ], 'im: '+im[ i ]+'. Expected: '+eim[ i ] );
+			t.strictEqual( are, ere[ i ], 're: '+re[ i ]+'. Expected: '+ere[ i ] );
+			t.strictEqual( aim, eim[ i ], 'im: '+im[ i ]+'. Expected: '+eim[ i ] );
 		} else {
 			delta = absf( are - ere[ i ] );
 			tol = EPS * absf( ere[ i ] );
diff --git a/lib/node_modules/@stdlib/math/base/special/cospi/test/test.js b/lib/node_modules/@stdlib/math/base/special/cospi/test/test.js
index e34044331ba7..f985bd29bce5 100644
--- a/lib/node_modules/@stdlib/math/base/special/cospi/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/cospi/test/test.js
@@ -104,7 +104,7 @@ tape( 'if provided a value exceeding `2**53` (max (unsafe) float64 integer), the
 	t.end();
 });
 
-tape( 'the function returns `0` for any value with fractional part equal to 1/2', function test( t ) {
+tape( 'the function returns `0` for any value with fractional part.strictEqual to 1/2', function test( t ) {
 	var x;
 	var y;
 	var i;
diff --git a/lib/node_modules/@stdlib/math/base/special/cospi/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/cospi/test/test.native.js
index c048e8f82896..651048e4c355 100644
--- a/lib/node_modules/@stdlib/math/base/special/cospi/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/cospi/test/test.native.js
@@ -113,7 +113,7 @@ tape( 'if provided a value exceeding `2**53` (max (unsafe) float64 integer), the
 	t.end();
 });
 
-tape( 'the function returns `0` for any value with fractional part equal to 1/2', opts, function test( t ) {
+tape( 'the function returns `0` for any value with fractional part.strictEqual to 1/2', opts, function test( t ) {
 	var x;
 	var y;
 	var i;
diff --git a/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.js b/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.js
index 6aa351e95cbb..12ee0ce34138 100644
--- a/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns `0` if `x` does not equal `0`', function test( t ) {
+tape( 'the function returns `0` if `x` does not.strictEqual `0`', function test( t ) {
 	var x;
 	var v;
 	var i;
diff --git a/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.native.js
index 10af746bffef..dcffb6f31103 100644
--- a/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.native.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', opts, function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns `0` if `x` does not equal `0`', opts, function test( t ) {
+tape( 'the function returns `0` if `x` does not.strictEqual `0`', opts, function test( t ) {
 	var x;
 	var v;
 	var i;
diff --git a/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.js b/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.js
index b3c7eeb7f0a6..d28d0a70c7dc 100644
--- a/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns `0` if `x` does not equal `0`', function test( t ) {
+tape( 'the function returns `0` if `x` does not.strictEqual `0`', function test( t ) {
 	var x;
 	var v;
 	var i;
diff --git a/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.native.js
index b52e099b5e38..fe233fd28e00 100644
--- a/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.native.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', opts, function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns `0` if `x` does not equal `0`', opts, function test( t ) {
+tape( 'the function returns `0` if `x` does not.strictEqual `0`', opts, function test( t ) {
 	var x;
 	var v;
 	var i;
diff --git a/lib/node_modules/@stdlib/math/base/special/factorialln/test/test.js b/lib/node_modules/@stdlib/math/base/special/factorialln/test/test.js
index 8a8b2b9a48d9..2257accf0639 100644
--- a/lib/node_modules/@stdlib/math/base/special/factorialln/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/factorialln/test/test.js
@@ -173,7 +173,7 @@ tape( 'the function evaluates the natural logarithm of the factorial of `x` (sma
 	t.end();
 });
 
-tape( 'the function returns a value almost equal to `ln( factorial( x )` for `x` in `[0,171]', function test( t ) {
+tape( 'the function returns a value almost.strictEqual to `ln( factorial( x )` for `x` in `[0,171]', function test( t ) {
 	var expected;
 	var values;
 	var delta;
diff --git a/lib/node_modules/@stdlib/math/base/special/factorialln/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/factorialln/test/test.native.js
index b3c803ddd87c..f9d219b18044 100644
--- a/lib/node_modules/@stdlib/math/base/special/factorialln/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/factorialln/test/test.native.js
@@ -184,7 +184,7 @@ tape( 'the function evaluates the natural logarithm of the factorial of `x` (sma
 	t.end();
 });
 
-tape( 'the function returns a value almost equal to `ln( factorial( x )` for `x` in `[0,171]', opts, function test( t ) {
+tape( 'the function returns a value almost.strictEqual to `ln( factorial( x )` for `x` in `[0,171]', opts, function test( t ) {
 	var expected;
 	var values;
 	var delta;
diff --git a/lib/node_modules/@stdlib/math/base/special/factoriallnf/test/test.js b/lib/node_modules/@stdlib/math/base/special/factoriallnf/test/test.js
index ef31d7ad2b30..5d9f16b67b13 100644
--- a/lib/node_modules/@stdlib/math/base/special/factoriallnf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/factoriallnf/test/test.js
@@ -149,7 +149,7 @@ tape( 'the function evaluates the natural logarithm of the factorial of `x` (sma
 	t.end();
 });
 
-tape( 'the function returns a value almost equal to `lnf( factorial( x )` for `x` in `[0,34]`', function test( t ) {
+tape( 'the function returns a value almost.strictEqual to `lnf( factorial( x )` for `x` in `[0,34]`', function test( t ) {
 	var expected;
 	var values;
 	var v;
diff --git a/lib/node_modules/@stdlib/math/base/special/factoriallnf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/factoriallnf/test/test.native.js
index 6e35f632daa9..4c880268836b 100644
--- a/lib/node_modules/@stdlib/math/base/special/factoriallnf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/factoriallnf/test/test.native.js
@@ -158,7 +158,7 @@ tape( 'the function evaluates the natural logarithm of the factorial of `x` (sma
 	t.end();
 });
 
-tape( 'the function returns a value almost equal to `lnf( factorial( x )` for `x` in `[0,34]`', opts, function test( t ) {
+tape( 'the function returns a value almost.strictEqual to `lnf( factorial( x )` for `x` in `[0,34]`', opts, function test( t ) {
 	var expected;
 	var values;
 	var v;
diff --git a/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.assign.js b/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.assign.js
index 2c2da69c901b..9b6a6258c8c4 100644
--- a/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.assign.js
+++ b/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.assign.js
@@ -64,16 +64,16 @@ tape( 'the function computes Fresnel integrals (small positive values)', functio
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = fresnel( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns expected value' );
+		t.strictEqual( y, z, 'returns expected value' );
 		if ( y[0] === S[i] ) {
-			t.equal( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
+			t.strictEqual( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
 		} else {
 			delta = abs( y[0] - S[i] );
 			tol = 4.0 * EPS * abs( S[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. S: '+y[0]+'. Expected: '+S[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === C[i] ) {
-			t.equal( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
+			t.strictEqual( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
 		} else {
 			delta = abs( y[1] - C[i] );
 			tol = 4.0 * EPS * abs( C[i] );
@@ -100,16 +100,16 @@ tape( 'the function computes Fresnel integrals (medium positive values)', functi
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = fresnel( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns expected value' );
+		t.strictEqual( y, z, 'returns expected value' );
 		if ( y[0] === S[i] ) {
-			t.equal( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
+			t.strictEqual( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
 		} else {
 			delta = abs( y[0] - S[i] );
 			tol = 1.5 * EPS * abs( S[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. S: '+y[0]+'. Expected: '+S[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === C[i] ) {
-			t.equal( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
+			t.strictEqual( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
 		} else {
 			delta = abs( y[1] - C[i] );
 			tol = 1.5 * EPS * abs( C[i] );
@@ -136,16 +136,16 @@ tape( 'the function computes Fresnel integrals (large positive values)', functio
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = fresnel( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns expected value' );
+		t.strictEqual( y, z, 'returns expected value' );
 		if ( y[0] === S[i] ) {
-			t.equal( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
+			t.strictEqual( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
 		} else {
 			delta = abs( y[0] - S[i] );
 			tol = 1.5 * EPS * abs( S[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. S: '+y[0]+'. Expected: '+S[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === C[i] ) {
-			t.equal( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
+			t.strictEqual( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
 		} else {
 			delta = abs( y[1] - C[i] );
 			tol = 1.5 * EPS * abs( C[i] );
@@ -172,16 +172,16 @@ tape( 'the function computes Fresnel integrals (very large positive values)', fu
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = fresnel( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns expected value' );
+		t.strictEqual( y, z, 'returns expected value' );
 		if ( y[0] === S[i] ) {
-			t.equal( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
+			t.strictEqual( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
 		} else {
 			delta = abs( y[0] - S[i] );
 			tol = 1.5 * EPS * abs( S[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. S: '+y[0]+'. Expected: '+S[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === C[i] ) {
-			t.equal( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
+			t.strictEqual( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
 		} else {
 			delta = abs( y[1] - C[i] );
 			tol = 1.5 * EPS * abs( C[i] );
@@ -202,14 +202,14 @@ tape( 'the function is an odd function of x', function test( t ) {
 		x = randu() * 10000.0;
 		z = [ 0.0, 0.0 ];
 		yn = fresnel( -x, z, 1, 0 );
-		t.equal( yn, z, 'returns expected value' );
+		t.strictEqual( yn, z, 'returns expected value' );
 
 		z = [ 0.0, 0.0 ];
 		yp = fresnel( x, z, 1, 0 );
-		t.equal( yp, z, 'returns expected value' );
+		t.strictEqual( yp, z, 'returns expected value' );
 
-		t.equal( yp[0], -yn[0], 'S(x) = -S(-x)' );
-		t.equal( yp[1], -yn[1], 'C(x) = -C(-x)' );
+		t.strictEqual( yp[0], -yn[0], 'S(x) = -S(-x)' );
+		t.strictEqual( yp[1], -yn[1], 'C(x) = -C(-x)' );
 	}
 	t.end();
 });
@@ -220,9 +220,9 @@ tape( 'the function returns `[0.5, 0.5]` if provided `+infinity`', function test
 
 	z = [ 0.0, 0.0 ];
 	v = fresnel( PINF, z, 1, 0 );
-	t.equal( v, z, 'returns expected value' );
-	t.equal( v[0], 0.5, 'returns 0.5' );
-	t.equal( v[1], 0.5, 'returns 0.5' );
+	t.strictEqual( v, z, 'returns expected value' );
+	t.strictEqual( v[0], 0.5, 'returns 0.5' );
+	t.strictEqual( v[1], 0.5, 'returns 0.5' );
 	t.end();
 });
 
@@ -232,9 +232,9 @@ tape( 'the function returns `[-0.5, -0.5]` if provided `-infinity`', function te
 
 	z = [ 0.0, 0.0 ];
 	v = fresnel( NINF, z, 1, 0 );
-	t.equal( v, z, 'returns expected value' );
-	t.equal( v[0], -0.5, 'returns -0.5' );
-	t.equal( v[1], -0.5, 'returns -0.5' );
+	t.strictEqual( v, z, 'returns expected value' );
+	t.strictEqual( v[0], -0.5, 'returns -0.5' );
+	t.strictEqual( v[1], -0.5, 'returns -0.5' );
 	t.end();
 });
 
@@ -244,9 +244,9 @@ tape( 'the function returns `[NaN, NaN]` if provided a `NaN`', function test( t
 
 	z = [ 0.0, 0.0 ];
 	v = fresnel( NaN, z, 1, 0 );
-	t.equal( v, z, 'returns expected value' );
-	t.equal( isnan( v[0] ), true, 'returns NaN' );
-	t.equal( isnan( v[1] ), true, 'returns NaN' );
+	t.strictEqual( v, z, 'returns expected value' );
+	t.strictEqual( isnan( v[0] ), true, 'returns NaN' );
+	t.strictEqual( isnan( v[1] ), true, 'returns NaN' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.main.js b/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.main.js
index 53edfdb124a1..b431532b9826 100644
--- a/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.main.js
+++ b/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.main.js
@@ -62,14 +62,14 @@ tape( 'the function computes Fresnel integrals (small positive values)', functio
 	for ( i = 0; i < x.length; i++ ) {
 		y = fresnel( x[i] );
 		if ( y[0] === S[i] ) {
-			t.equal( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
+			t.strictEqual( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
 		} else {
 			delta = abs( y[0] - S[i] );
 			tol = 4.0 * EPS * abs( S[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. S: '+y[0]+'. Expected: '+S[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === C[i] ) {
-			t.equal( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
+			t.strictEqual( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
 		} else {
 			delta = abs( y[1] - C[i] );
 			tol = 4.0 * EPS * abs( C[i] );
@@ -95,14 +95,14 @@ tape( 'the function computes Fresnel integrals (medium positive values)', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = fresnel( x[i] );
 		if ( y[0] === S[i] ) {
-			t.equal( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
+			t.strictEqual( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
 		} else {
 			delta = abs( y[0] - S[i] );
 			tol = 1.5 * EPS * abs( S[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. S: '+y[0]+'. Expected: '+S[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === C[i] ) {
-			t.equal( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
+			t.strictEqual( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
 		} else {
 			delta = abs( y[1] - C[i] );
 			tol = 1.5 * EPS * abs( C[i] );
@@ -128,14 +128,14 @@ tape( 'the function computes Fresnel integrals (large positive values)', functio
 	for ( i = 0; i < x.length; i++ ) {
 		y = fresnel( x[i] );
 		if ( y[0] === S[i] ) {
-			t.equal( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
+			t.strictEqual( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
 		} else {
 			delta = abs( y[0] - S[i] );
 			tol = 1.5 * EPS * abs( S[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. S: '+y[0]+'. Expected: '+S[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === C[i] ) {
-			t.equal( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
+			t.strictEqual( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
 		} else {
 			delta = abs( y[1] - C[i] );
 			tol = 1.5 * EPS * abs( C[i] );
@@ -161,14 +161,14 @@ tape( 'the function computes Fresnel integrals (very large positive values)', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = fresnel( x[i] );
 		if ( y[0] === S[i] ) {
-			t.equal( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
+			t.strictEqual( y[0], S[i], 'x: '+x[i]+'. Expected: '+S[i] );
 		} else {
 			delta = abs( y[0] - S[i] );
 			tol = 1.5 * EPS * abs( S[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. S: '+y[0]+'. Expected: '+S[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === C[i] ) {
-			t.equal( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
+			t.strictEqual( y[1], C[i], 'x: '+x[i]+'. Expected: '+C[i] );
 		} else {
 			delta = abs( y[1] - C[i] );
 			tol = 1.5 * EPS * abs( C[i] );
@@ -189,29 +189,29 @@ tape( 'the function is an odd function of x', function test( t ) {
 		yn = fresnel( -x );
 		yp = fresnel( x );
 
-		t.equal( yp[0], -yn[0], 'S(x) = -S(-x)' );
-		t.equal( yp[1], -yn[1], 'C(x) = -C(-x)' );
+		t.strictEqual( yp[0], -yn[0], 'S(x) = -S(-x)' );
+		t.strictEqual( yp[1], -yn[1], 'C(x) = -C(-x)' );
 	}
 	t.end();
 });
 
 tape( 'the function returns `[0.5, 0.5]` if provided `+infinity`', function test( t ) {
 	var v = fresnel( PINF );
-	t.equal( v[0], 0.5, 'returns 0.5' );
-	t.equal( v[1], 0.5, 'returns 0.5' );
+	t.strictEqual( v[0], 0.5, 'returns 0.5' );
+	t.strictEqual( v[1], 0.5, 'returns 0.5' );
 	t.end();
 });
 
 tape( 'the function returns `[-0.5, -0.5]` if provided `-infinity`', function test( t ) {
 	var v = fresnel( NINF );
-	t.equal( v[0], -0.5, 'returns -0.5' );
-	t.equal( v[1], -0.5, 'returns -0.5' );
+	t.strictEqual( v[0], -0.5, 'returns -0.5' );
+	t.strictEqual( v[1], -0.5, 'returns -0.5' );
 	t.end();
 });
 
 tape( 'the function returns `[NaN, NaN]` if provided a `NaN`', function test( t ) {
 	var v = fresnel( NaN );
-	t.equal( isnan( v[0] ), true, 'returns NaN' );
-	t.equal( isnan( v[1] ), true, 'returns NaN' );
+	t.strictEqual( isnan( v[0] ), true, 'returns NaN' );
+	t.strictEqual( isnan( v[1] ), true, 'returns NaN' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/gamma/test/other/xtest.gamma.js b/lib/node_modules/@stdlib/math/base/special/gamma/test/other/xtest.gamma.js
index d9867f29f553..b9f250d3210f 100644
--- a/lib/node_modules/@stdlib/math/base/special/gamma/test/other/xtest.gamma.js
+++ b/lib/node_modules/@stdlib/math/base/special/gamma/test/other/xtest.gamma.js
@@ -42,7 +42,7 @@ var expected2 = require( './../fixtures/r/expected2.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof gamma, 'function', 'main export is a function' );
+	t.strictEqual( typeof gamma, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -53,32 +53,32 @@ tape( 'if provided a negative integer, the function returns `NaN`', function tes
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = gamma( values[ i ] );
-		t.equal( isnan( v ), true, 'returns NaN when provided ' + values[ i ] );
+		t.strictEqual( isnan( v ), true, 'returns NaN when provided ' + values[ i ] );
 	}
 	t.end();
 });
 
 tape( 'if provided negative infinity, the function returns `NaN`', function test( t ) {
 	var v = gamma( NINF );
-	t.equal( isnan( v ), true, 'returns NaN when provided negative infinity' );
+	t.strictEqual( isnan( v ), true, 'returns NaN when provided negative infinity' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = gamma( NaN );
-	t.equal( isnan( v ), true, 'returns NaN when provided a NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN when provided a NaN' );
 	t.end();
 });
 
 tape( 'if provided `-0`, the function returns negative infinity', function test( t ) {
 	var v = gamma( -0.0 );
-	t.equal( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns -infinity' );
 	t.end();
 });
 
 tape( 'if provided `+0`, the function returns positive infinity', function test( t ) {
 	var v = gamma( 0.0 );
-	t.equal( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns +infinity' );
 	t.end();
 });
 
@@ -89,7 +89,7 @@ tape( 'if `x > 171.6144...`, the function returns positive infinity', function t
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = gamma( values[ i ] );
-		t.equal( v, PINF, 'returns +infinity when provided ' + values[ i ] );
+		t.strictEqual( v, PINF, 'returns +infinity when provided ' + values[ i ] );
 	}
 	t.end();
 });
@@ -101,7 +101,7 @@ tape( 'if `x < -170.56749...`, the function returns positive infinity', function
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = gamma( values[ i ] );
-		t.equal( v, PINF, 'returns +infinity when provided ' + values[ i ] );
+		t.strictEqual( v, PINF, 'returns +infinity when provided ' + values[ i ] );
 	}
 	t.end();
 });
@@ -137,8 +137,8 @@ tape( 'the function evaluates the gamma function (decimal values)', function tes
 });
 
 tape( 'if provided a positive integer, the function returns the factorial of (n-1)', function test( t ) {
-	t.equal( gamma( 4.0 ), 6.0, 'returns 6' );
-	t.equal( gamma( 5.0 ), 24.0, 'returns 24' );
-	t.equal( gamma( 6.0 ), 120.0, 'returns 120' );
+	t.strictEqual( gamma( 4.0 ), 6.0, 'returns 6' );
+	t.strictEqual( gamma( 5.0 ), 24.0, 'returns 24' );
+	t.strictEqual( gamma( 6.0 ), 120.0, 'returns 120' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/gamma/test/test.boost.js b/lib/node_modules/@stdlib/math/base/special/gamma/test/test.boost.js
index 7b97dbfd2205..dfd2182f43e0 100644
--- a/lib/node_modules/@stdlib/math/base/special/gamma/test/test.boost.js
+++ b/lib/node_modules/@stdlib/math/base/special/gamma/test/test.boost.js
@@ -52,32 +52,32 @@ tape( 'if provided a negative integer, the function returns `NaN`', function tes
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = gamma( values[ i ] );
-		t.equal( isnan( v ), true, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( isnan( v ), true, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
 
 tape( 'if provided negative infinity, the function returns `NaN`', function test( t ) {
 	var v = gamma( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = gamma( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-0`, the function returns negative infinity', function test( t ) {
 	var v = gamma( -0.0 );
-	t.equal( v, NINF, 'returns expected value' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+0`, the function returns positive infinity', function test( t ) {
 	var v = gamma( 0.0 );
-	t.equal( v, PINF, 'returns expected value' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -88,7 +88,7 @@ tape( 'if `x >= 171.63...`, the function returns positive infinity', function te
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = gamma( values[ i ] );
-		t.equal( v, PINF, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( v, PINF, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'if `x <= -170.65`, the function returns zero', function test( t ) {
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = gamma( values[ i ] );
-		t.equal( v, 0, 'returns expected value when provided ' + values[ i ] );
+		t.strictEqual( v, 0, 'returns expected value when provided ' + values[ i ] );
 	}
 	t.end();
 });
@@ -166,8 +166,8 @@ tape( 'the function evaluates the gamma function (values near one)', function te
 });
 
 tape( 'if provided a positive integer, the function returns the factorial of (n-1)', function test( t ) {
-	t.equal( gamma( 4.0 ), 6.0, 'returns 6' );
-	t.equal( gamma( 5.0 ), 24.0, 'returns 24' );
-	t.equal( gamma( 6.0 ), 120.0, 'returns 120' );
+	t.strictEqual( gamma( 4.0 ), 6.0, 'returns 6' );
+	t.strictEqual( gamma( 5.0 ), 24.0, 'returns 24' );
+	t.strictEqual( gamma( 6.0 ), 120.0, 'returns 120' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-cosf/test/test.js b/lib/node_modules/@stdlib/math/base/special/kernel-cosf/test/test.js
index 6deb673a46cb..70770be39be2 100644
--- a/lib/node_modules/@stdlib/math/base/special/kernel-cosf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/kernel-cosf/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var v = kernelCosf( NaN );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-cosf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/kernel-cosf/test/test.native.js
index 9afe187ad0d2..10961c6d2ef9 100644
--- a/lib/node_modules/@stdlib/math/base/special/kernel-cosf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/kernel-cosf/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var v = kernelCosf( NaN );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-sincos/test/test.js b/lib/node_modules/@stdlib/math/base/special/kernel-sincos/test/test.js
index 3f671a1f6dd2..3a5746b193f8 100644
--- a/lib/node_modules/@stdlib/math/base/special/kernel-sincos/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/kernel-sincos/test/test.js
@@ -37,7 +37,7 @@ var largeNegative = require( './fixtures/julia/large_negative.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof kernelSincos, 'function', 'main export is a function' );
+	t.strictEqual( typeof kernelSincos, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -47,9 +47,9 @@ tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 
 	z = [ 0.0, 0.0 ];
 	v = kernelSincos( NaN, 0.0, z, 1, 0 );
-	t.equal( v, z, 'returns output array' );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( v, z, 'returns output array' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -68,9 +68,9 @@ tape( 'the function evaluates the sine and cosine for input values on the interv
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = kernelSincos( x[i], 0.0, z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
-		t.equal( y[0], sine[ i ], 'returns expected value' );
-		t.equal( y[1], cosine[ i ], 'returns expected value' );
+		t.strictEqual( y, z, 'returns output array' );
+		t.strictEqual( y[0], sine[ i ], 'returns expected value' );
+		t.strictEqual( y[1], cosine[ i ], 'returns expected value' );
 	}
 	t.end();
 });
@@ -95,15 +95,15 @@ tape( 'the function can be used to compute the sine and cosine for input values
 		switch ( n & 3 ) {
 		case 0:
 			out = kernelSincos( y[ 0 ], y[ 1 ], z, 1, 0 );
-			t.equal( out, z, 'returns output array' );
-			t.equal( out[ 0 ], sine[ i ], 'returns expected value' );
-			t.equal( out[ 1 ], cosine[ i ], 'returns expected value' );
+			t.strictEqual( out, z, 'returns output array' );
+			t.strictEqual( out[ 0 ], sine[ i ], 'returns expected value' );
+			t.strictEqual( out[ 1 ], cosine[ i ], 'returns expected value' );
 			break;
 		case 2:
 			out = kernelSincos( y[ 0 ], y[ 1 ], z, 1, 0 );
-			t.equal( out, z, 'returns output array' );
-			t.equal( -out[ 0 ], sine[ i ], 'returns expected value' );
-			t.equal( -out[ 1 ], cosine[ i ], 'returns expected value' );
+			t.strictEqual( out, z, 'returns output array' );
+			t.strictEqual( -out[ 0 ], sine[ i ], 'returns expected value' );
+			t.strictEqual( -out[ 1 ], cosine[ i ], 'returns expected value' );
 			break;
 		default:
 			break;
@@ -132,15 +132,15 @@ tape( 'the function can be used to compute the sine and cosine for input values
 		switch ( n & 3 ) {
 		case 0:
 			out = kernelSincos( y[ 0 ], y[ 1 ], z, 1, 0 );
-			t.equal( out, z, 'returns output array' );
-			t.equal( out[ 0 ], sine[ i ], 'returns expected value' );
-			t.equal( out[ 1 ], cosine[ i ], 'returns expected value' );
+			t.strictEqual( out, z, 'returns output array' );
+			t.strictEqual( out[ 0 ], sine[ i ], 'returns expected value' );
+			t.strictEqual( out[ 1 ], cosine[ i ], 'returns expected value' );
 			break;
 		case 2:
 			out = kernelSincos( y[ 0 ], y[ 1 ], z, 1, 0 );
-			t.equal( out, z, 'returns output array' );
-			t.equal( -out[ 0 ], sine[ i ], 'returns expected value' );
-			t.equal( -out[ 1 ], cosine[ i ], 'returns expected value' );
+			t.strictEqual( out, z, 'returns output array' );
+			t.strictEqual( -out[ 0 ], sine[ i ], 'returns expected value' );
+			t.strictEqual( -out[ 1 ], cosine[ i ], 'returns expected value' );
 			break;
 		default:
 			break;
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-sincos/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/kernel-sincos/test/test.native.js
index f09c1e9fb7d0..00489a74b470 100644
--- a/lib/node_modules/@stdlib/math/base/special/kernel-sincos/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/kernel-sincos/test/test.native.js
@@ -48,7 +48,7 @@ var largeNegative = require( './fixtures/julia/large_negative.json' );
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof kernelSincos, 'function', 'main export is a function' );
+	t.strictEqual( typeof kernelSincos, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -56,8 +56,8 @@ tape( 'the function returns `NaN` if provided a `NaN`', opts, function test( t )
 	var v;
 
 	v = kernelSincos( NaN, 0.0 );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -77,7 +77,7 @@ tape( 'the function evaluates the sine and cosine for input values on the interv
 	for ( i = 0; i < x.length; i++ ) {
 		y = kernelSincos( x[i], 0.0 );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'returns expected value' );
+			t.strictEqual( y[0], sine[ i ], 'returns expected value' );
 		} else {
 			delta = abs( y[0] - sine[i] );
 
@@ -85,7 +85,7 @@ tape( 'the function evaluates the sine and cosine for input values on the interv
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
-		t.equal( y[1], cosine[ i ], 'returns expected value' );
+		t.strictEqual( y[1], cosine[ i ], 'returns expected value' );
 	}
 	t.end();
 });
@@ -111,7 +111,7 @@ tape( 'the function can be used to compute the sine and cosine for input values
 		case 0:
 			out = kernelSincos( y[ 0 ], y[ 1 ] );
 			if ( out[0] === sine[ i ] ) {
-				t.equal( out[0], sine[ i ], 'returns expected value' );
+				t.strictEqual( out[0], sine[ i ], 'returns expected value' );
 			} else {
 				delta = abs( out[0] - sine[i] );
 
@@ -119,14 +119,14 @@ tape( 'the function can be used to compute the sine and cosine for input values
 				tol = EPS * abs( sine[i] );
 				t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+out[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
-			t.equal( out[1], cosine[ i ], 'returns expected value' );
+			t.strictEqual( out[1], cosine[ i ], 'returns expected value' );
 			break;
 		case 2:
 			out = kernelSincos( y[ 0 ], y[ 1 ] );
 			out[ 0 ] = -out[ 0 ];
 			out[ 1 ] = -out[ 1 ];
 			if ( out[0] === sine[ i ] ) {
-				t.equal( out[0], sine[ i ], 'returns expected value' );
+				t.strictEqual( out[0], sine[ i ], 'returns expected value' );
 			} else {
 				delta = abs( out[0] - sine[i] );
 
@@ -135,7 +135,7 @@ tape( 'the function can be used to compute the sine and cosine for input values
 				t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+out[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
 			if ( out[1] === cosine[ i ] ) {
-				t.equal( out[1], cosine[ i ], 'returns expected value' );
+				t.strictEqual( out[1], cosine[ i ], 'returns expected value' );
 			} else {
 				delta = abs( out[1] - cosine[i] );
 
@@ -172,7 +172,7 @@ tape( 'the function can be used to compute the sine and cosine for input values
 		case 0:
 			out = kernelSincos( y[ 0 ], y[ 1 ] );
 			if ( out[0] === sine[ i ] ) {
-				t.equal( out[0], sine[ i ], 'returns expected value' );
+				t.strictEqual( out[0], sine[ i ], 'returns expected value' );
 			} else {
 				delta = abs( out[0] - sine[i] );
 
@@ -180,14 +180,14 @@ tape( 'the function can be used to compute the sine and cosine for input values
 				tol = EPS * abs( sine[i] );
 				t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+out[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
-			t.equal( out[1], cosine[ i ], 'returns expected value' );
+			t.strictEqual( out[1], cosine[ i ], 'returns expected value' );
 			break;
 		case 2:
 			out = kernelSincos( y[ 0 ], y[ 1 ] );
 			out[ 0 ] = -out[ 0 ];
 			out[ 1 ] = -out[ 1 ];
 			if ( out[0] === sine[ i ] ) {
-				t.equal( out[0], sine[ i ], 'returns expected value' );
+				t.strictEqual( out[0], sine[ i ], 'returns expected value' );
 			} else {
 				delta = abs( out[0] - sine[i] );
 
@@ -196,7 +196,7 @@ tape( 'the function can be used to compute the sine and cosine for input values
 				t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+out[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
 			if ( out[1] === cosine[ i ] ) {
-				t.equal( out[1], cosine[ i ], 'returns expected value' );
+				t.strictEqual( out[1], cosine[ i ], 'returns expected value' );
 			} else {
 				delta = abs( out[1] - cosine[i] );
 
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-sinf/test/test.js b/lib/node_modules/@stdlib/math/base/special/kernel-sinf/test/test.js
index b226c23a64b2..826443566cb9 100644
--- a/lib/node_modules/@stdlib/math/base/special/kernel-sinf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/kernel-sinf/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var v = kernelSinf( NaN );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-sinf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/kernel-sinf/test/test.native.js
index fd799b021df7..66b2d3990fa5 100644
--- a/lib/node_modules/@stdlib/math/base/special/kernel-sinf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/kernel-sinf/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var v = kernelSinf( NaN );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.js b/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.js
index 7fb8c8335bbc..fad361591f7f 100644
--- a/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns `0` if `i` does not equal `j`', function test( t ) {
+tape( 'the function returns `0` if `i` does not.strictEqual `j`', function test( t ) {
 	var x;
 	var y;
 	var v;
diff --git a/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.native.js
index 258ae8f40698..d43d5bc926b2 100644
--- a/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.native.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', opts, function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns `0` if `i` does not equal `j`', opts, function test( t ) {
+tape( 'the function returns `0` if `i` does not.strictEqual `j`', opts, function test( t ) {
 	var x;
 	var y;
 	var v;
diff --git a/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.js b/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.js
index e88d90a13725..43a196b74c1c 100644
--- a/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns `0` if `i` does not equal `j`', function test( t ) {
+tape( 'the function returns `0` if `i` does not.strictEqual `j`', function test( t ) {
 	var x;
 	var y;
 	var v;
diff --git a/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.native.js
index b81a5b5eddf0..3309f6e37d3d 100644
--- a/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.native.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', opts, function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns `0` if `i` does not equal `j`', opts, function test( t ) {
+tape( 'the function returns `0` if `i` does not.strictEqual `j`', opts, function test( t ) {
 	var x;
 	var y;
 	var v;
diff --git a/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.js b/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.js
index 75b1bb6f6804..7ace1e527f6d 100644
--- a/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.js
@@ -137,7 +137,7 @@ tape( 'if provided a fraction equal to `-infinity`, the function returns `-infin
 	t.end();
 });
 
-tape( 'if provided an exponent equal to `0`, the function returns the provided fraction', function test( t ) {
+tape( 'if provided an exponent.strictEqual to `0`, the function returns the provided fraction', function test( t ) {
 	var v = ldexp( 3.0, 0 );
 	t.strictEqual( v, 3.0, 'returns expected value' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.native.js
index f874d501f686..e448252c7fbd 100644
--- a/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.native.js
@@ -146,7 +146,7 @@ tape( 'if provided a fraction equal to `-infinity`, the function returns `-infin
 	t.end();
 });
 
-tape( 'if provided an exponent equal to `0`, the function returns the provided fraction', opts, function test( t ) {
+tape( 'if provided an exponent.strictEqual to `0`, the function returns the provided fraction', opts, function test( t ) {
 	var v = ldexp( 3.0, 0 );
 	t.strictEqual( v, 3.0, 'returns expected value' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/base/special/ldexpf/test/test.js b/lib/node_modules/@stdlib/math/base/special/ldexpf/test/test.js
index 2888d6e41f3c..07c2559b995b 100644
--- a/lib/node_modules/@stdlib/math/base/special/ldexpf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/ldexpf/test/test.js
@@ -180,7 +180,7 @@ tape( 'if provided a fraction equal to `-infinity`, the function returns `-infin
 	t.end();
 });
 
-tape( 'if provided an exponent equal to `0`, the function returns the provided fraction', function test( t ) {
+tape( 'if provided an exponent.strictEqual to `0`, the function returns the provided fraction', function test( t ) {
 	var v = ldexpf( 3.0, 0 );
 	t.strictEqual( v, 3.0, 'returns expected value' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/base/special/ldexpf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/ldexpf/test/test.native.js
index a5472da308f5..8d051424d0cc 100644
--- a/lib/node_modules/@stdlib/math/base/special/ldexpf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/ldexpf/test/test.native.js
@@ -189,7 +189,7 @@ tape( 'if provided a fraction equal to `-infinity`, the function returns `-infin
 	t.end();
 });
 
-tape( 'if provided an exponent equal to `0`, the function returns the provided fraction', opts, function test( t ) {
+tape( 'if provided an exponent.strictEqual to `0`, the function returns the provided fraction', opts, function test( t ) {
 	var v = ldexpf( 3.0, 0 );
 	t.strictEqual( v, 3.0, 'returns expected value' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/base/special/log/test/test.js b/lib/node_modules/@stdlib/math/base/special/log/test/test.js
index 8c19818000ad..11a03eee78e9 100644
--- a/lib/node_modules/@stdlib/math/base/special/log/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/log/test/test.js
@@ -71,19 +71,19 @@ tape( 'the function returns `1.0` if provided `x` and `b` such that `x = b` (exc
 });
 
 tape( 'the function returns `+infinity` if provided `x = +infinity` and a valid `b`', function test( t ) {
-	t.equal( log( PINF, 1.0 ), PINF, 'returns expected value' );
-	t.equal( log( PINF, 2.0 ), PINF, 'returns expected value' );
-	t.equal( log( PINF, 10.0 ), PINF, 'returns expected value' );
+	t.strictEqual( log( PINF, 1.0 ), PINF, 'returns expected value' );
+	t.strictEqual( log( PINF, 2.0 ), PINF, 'returns expected value' );
+	t.strictEqual( log( PINF, 10.0 ), PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `x = +-0` and a valid `b`', function test( t ) {
-	t.equal( log( 0.0, 1.0 ), NINF, 'returns expected value' );
-	t.equal( log( 0.0, 2.0 ), NINF, 'returns expected value' );
-	t.equal( log( 0.0, 10.0 ), NINF, 'returns expected value' );
-	t.equal( log( -0.0, 1.0 ), NINF, 'returns expected value' );
-	t.equal( log( -0.0, 2.0 ), NINF, 'returns expected value' );
-	t.equal( log( -0.0, 10.0 ), NINF, 'returns expected value' );
+	t.strictEqual( log( 0.0, 1.0 ), NINF, 'returns expected value' );
+	t.strictEqual( log( 0.0, 2.0 ), NINF, 'returns expected value' );
+	t.strictEqual( log( 0.0, 10.0 ), NINF, 'returns expected value' );
+	t.strictEqual( log( -0.0, 1.0 ), NINF, 'returns expected value' );
+	t.strictEqual( log( -0.0, 2.0 ), NINF, 'returns expected value' );
+	t.strictEqual( log( -0.0, 10.0 ), NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -91,10 +91,10 @@ tape( 'the function returns positive zero if provided `x = 1.0` and a valid `b`'
 	var v;
 
 	v = log( 1.0, 2.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = log( 1.0, 10.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/log/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/log/test/test.native.js
index 74ce830830c8..0f01dceb5fc3 100644
--- a/lib/node_modules/@stdlib/math/base/special/log/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/log/test/test.native.js
@@ -80,19 +80,19 @@ tape( 'the function returns `1.0` if provided `x` and `b` such that `x = b` (exc
 });
 
 tape( 'the function returns `+infinity` if provided `x = +infinity` and a valid `b`', opts, function test( t ) {
-	t.equal( log( PINF, 1.0 ), PINF, 'returns expected value' );
-	t.equal( log( PINF, 2.0 ), PINF, 'returns expected value' );
-	t.equal( log( PINF, 10.0 ), PINF, 'returns expected value' );
+	t.strictEqual( log( PINF, 1.0 ), PINF, 'returns expected value' );
+	t.strictEqual( log( PINF, 2.0 ), PINF, 'returns expected value' );
+	t.strictEqual( log( PINF, 10.0 ), PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `x = +-0` and a valid `b`', opts, function test( t ) {
-	t.equal( log( 0.0, 1.0 ), NINF, 'returns expected value' );
-	t.equal( log( 0.0, 2.0 ), NINF, 'returns expected value' );
-	t.equal( log( 0.0, 10.0 ), NINF, 'returns expected value' );
-	t.equal( log( -0.0, 1.0 ), NINF, 'returns expected value' );
-	t.equal( log( -0.0, 2.0 ), NINF, 'returns expected value' );
-	t.equal( log( -0.0, 10.0 ), NINF, 'returns expected value' );
+	t.strictEqual( log( 0.0, 1.0 ), NINF, 'returns expected value' );
+	t.strictEqual( log( 0.0, 2.0 ), NINF, 'returns expected value' );
+	t.strictEqual( log( 0.0, 10.0 ), NINF, 'returns expected value' );
+	t.strictEqual( log( -0.0, 1.0 ), NINF, 'returns expected value' );
+	t.strictEqual( log( -0.0, 2.0 ), NINF, 'returns expected value' );
+	t.strictEqual( log( -0.0, 10.0 ), NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -100,10 +100,10 @@ tape( 'the function returns positive zero if provided `x = 1.0` and a valid `b`'
 	var v;
 
 	v = log( 1.0, 2.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = log( 1.0, 10.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/modf/test/test.assign.js b/lib/node_modules/@stdlib/math/base/special/modf/test/test.assign.js
index c78790c9b7cc..d5d9f368507a 100644
--- a/lib/node_modules/@stdlib/math/base/special/modf/test/test.assign.js
+++ b/lib/node_modules/@stdlib/math/base/special/modf/test/test.assign.js
@@ -61,7 +61,7 @@ tape( 'the function decomposes a number into integral and fractional parts (smal
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		parts = modf( x[ i ], out, 1, 0 );
-		t.equal( parts, out, 'returns output array' );
+		t.strictEqual( parts, out, 'returns output array' );
 		t.strictEqual( parts[0], integral[i], 'returns integral part' );
 		t.strictEqual( parts[1], frac[i], 'returns fractional part' );
 	}
@@ -82,7 +82,7 @@ tape( 'the function decomposes a number into integral and fractional parts (medi
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		parts = modf( x[ i ], out, 1, 0 );
-		t.equal( parts, out, 'returns output array' );
+		t.strictEqual( parts, out, 'returns output array' );
 		t.strictEqual( parts[0], integral[i], 'returns integral part' );
 		t.strictEqual( parts[1], frac[i], 'returns fractional part' );
 	}
@@ -103,7 +103,7 @@ tape( 'the function decomposes a number into integral and fractional parts (larg
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		parts = modf( x[ i ], out, 1, 0 );
-		t.equal( parts, out, 'returns output array' );
+		t.strictEqual( parts, out, 'returns output array' );
 		t.strictEqual( parts[0], integral[i], 'returns integral part' );
 		t.strictEqual( parts[1], frac[i], 'returns fractional part' );
 	}
@@ -124,7 +124,7 @@ tape( 'the function decomposes a number into integral and fractional parts (huge
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		parts = modf( x[ i ], out, 1, 0 );
-		t.equal( parts, out, 'returns output array' );
+		t.strictEqual( parts, out, 'returns output array' );
 		t.strictEqual( parts[0], integral[i], 'returns integral part' );
 		t.strictEqual( parts[1], frac[i], 'returns fractional part' );
 	}
@@ -145,7 +145,7 @@ tape( 'the function decomposes a number into integral and fractional parts (subn
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		parts = modf( x[ i ], out, 1, 0 );
-		t.equal( parts, out, 'returns output array' );
+		t.strictEqual( parts, out, 'returns output array' );
 		t.strictEqual( parts[0], integral[i], 'returns integral part' );
 		t.strictEqual( parts[1], frac[i], 'returns fractional part' );
 	}
@@ -158,7 +158,7 @@ tape( 'if provided `+0`, the function returns `[+0,+0]`', function test( t ) {
 
 	out = [ 0.0, 0.0 ];
 	parts = modf( +0.0, out, 1, 0 );
-	t.equal( parts, out, 'returns output array' );
+	t.strictEqual( parts, out, 'returns output array' );
 	t.strictEqual( isPositiveZero( parts[0] ), true, 'returns expected value' );
 	t.strictEqual( isPositiveZero( parts[1] ), true, 'returns expected value' );
 	t.end();
@@ -170,7 +170,7 @@ tape( 'if provided `-0`, the function returns `[-0,-0]`', function test( t ) {
 
 	out = [ 0.0, 0.0 ];
 	parts = modf( -0.0, out, 1, 0 );
-	t.equal( parts, out, 'returns output array' );
+	t.strictEqual( parts, out, 'returns output array' );
 	t.strictEqual( isNegativeZero( parts[0] ), true, 'returns expected value' );
 	t.strictEqual( isNegativeZero( parts[1] ), true, 'returns expected value' );
 	t.end();
@@ -182,7 +182,7 @@ tape( 'if provided `+infinity`, the function returns `[+infinity,+0]`', function
 
 	out = [ 0.0, 0.0 ];
 	parts = modf( PINF, out, 1, 0 );
-	t.equal( parts, out, 'returns output array' );
+	t.strictEqual( parts, out, 'returns output array' );
 	t.strictEqual( parts[0], PINF, 'returns +infinity' );
 	t.strictEqual( isPositiveZero( parts[1] ), true, 'returns expected value' );
 	t.end();
@@ -194,7 +194,7 @@ tape( 'if provided `-infinity`, the function returns `[-infinity,-0]`', function
 
 	out = [ 0.0, 0.0 ];
 	parts = modf( NINF, out, 1, 0 );
-	t.equal( parts, out, 'returns output array' );
+	t.strictEqual( parts, out, 'returns output array' );
 	t.strictEqual( parts[0], NINF, 'returns -infinity' );
 	t.strictEqual( isNegativeZero( parts[1] ), true, 'returns expected value' );
 	t.end();
@@ -206,7 +206,7 @@ tape( 'if provided `NaN`, the function returns `[NaN,NaN]`', function test( t )
 
 	out = [ 0.0, 0.0 ];
 	parts = modf( NaN, out, 1, 0 );
-	t.equal( parts, out, 'returns output array' );
+	t.strictEqual( parts, out, 'returns output array' );
 	t.strictEqual( isnan( parts[0] ), true, 'returns expected value' );
 	t.strictEqual( isnan( parts[1] ), true, 'returns expected value' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/base/special/modff/test/test.assign.js b/lib/node_modules/@stdlib/math/base/special/modff/test/test.assign.js
index 5a6743afde3f..45c6ffbb742e 100644
--- a/lib/node_modules/@stdlib/math/base/special/modff/test/test.assign.js
+++ b/lib/node_modules/@stdlib/math/base/special/modff/test/test.assign.js
@@ -64,7 +64,7 @@ tape( 'the function decomposes a number into integral and fractional parts (smal
 		integral[ i ] = f32( integral[ i ] );
 		frac[ i ] = f32( frac[ i ] );
 		parts = modff( x[ i ], out, 1, 0 );
-		t.equal( parts, out, 'returns output array' );
+		t.strictEqual( parts, out, 'returns output array' );
 		t.strictEqual( parts[0], integral[i], 'returns expected value' );
 		t.strictEqual( parts[1], frac[i], 'returns expected value' );
 	}
@@ -87,7 +87,7 @@ tape( 'the function decomposes a number into integral and fractional parts (medi
 		integral[ i ] = f32( integral[ i ] );
 		frac[ i ] = f32( frac[ i ] );
 		parts = modff( x[ i ], out, 1, 0 );
-		t.equal( parts, out, 'returns output array' );
+		t.strictEqual( parts, out, 'returns output array' );
 		t.strictEqual( parts[0], integral[i], 'returns expected value' );
 		t.strictEqual( parts[1], frac[i], 'returns expected value' );
 	}
@@ -110,7 +110,7 @@ tape( 'the function decomposes a number into integral and fractional parts (larg
 		integral[ i ] = f32( integral[ i ] );
 		frac[ i ] = f32( frac[ i ] );
 		parts = modff( x[ i ], out, 1, 0 );
-		t.equal( parts, out, 'returns output array' );
+		t.strictEqual( parts, out, 'returns output array' );
 		t.strictEqual( parts[0], integral[i], 'returns expected value' );
 		t.strictEqual( parts[1], frac[i], 'returns expected value' );
 	}
@@ -133,7 +133,7 @@ tape( 'the function decomposes a number into integral and fractional parts (huge
 		integral[ i ] = f32( integral[ i ] );
 		frac[ i ] = f32( frac[ i ] );
 		parts = modff( x[ i ], out, 1, 0 );
-		t.equal( parts, out, 'returns output array' );
+		t.strictEqual( parts, out, 'returns output array' );
 		t.strictEqual( parts[0], integral[i], 'returns expected value' );
 		t.strictEqual( parts[1], frac[i], 'returns expected value' );
 	}
@@ -156,7 +156,7 @@ tape( 'the function decomposes a number into integral and fractional parts (subn
 		integral[ i ] = f32( integral[ i ] );
 		frac[ i ] = f32( frac[ i ] );
 		parts = modff( x[ i ], out, 1, 0 );
-		t.equal( parts, out, 'returns output array' );
+		t.strictEqual( parts, out, 'returns output array' );
 		t.strictEqual( parts[0], integral[i], 'returns expected value' );
 		t.strictEqual( parts[1], frac[i], 'returns expected value' );
 	}
@@ -169,7 +169,7 @@ tape( 'if provided `+0`, the function returns `[+0,+0]`', function test( t ) {
 
 	out = [ 0.0, 0.0 ];
 	parts = modff( +0.0, out, 1, 0 );
-	t.equal( parts, out, 'returns output array' );
+	t.strictEqual( parts, out, 'returns output array' );
 	t.strictEqual( isPositiveZerof( parts[0] ), true, 'returns expected value' );
 	t.strictEqual( isPositiveZerof( parts[1] ), true, 'returns expected value' );
 	t.end();
@@ -181,7 +181,7 @@ tape( 'if provided `-0`, the function returns `[-0,-0]`', function test( t ) {
 
 	out = [ 0.0, 0.0 ];
 	parts = modff( -0.0, out, 1, 0 );
-	t.equal( parts, out, 'returns output array' );
+	t.strictEqual( parts, out, 'returns output array' );
 	t.strictEqual( isNegativeZerof( parts[0] ), true, 'returns expected value' );
 	t.strictEqual( isNegativeZerof( parts[1] ), true, 'returns expected value' );
 	t.end();
@@ -193,7 +193,7 @@ tape( 'if provided `+infinity`, the function returns `[+infinity,+0]`', function
 
 	out = [ 0.0, 0.0 ];
 	parts = modff( PINF, out, 1, 0 );
-	t.equal( parts, out, 'returns output array' );
+	t.strictEqual( parts, out, 'returns output array' );
 	t.strictEqual( parts[0], PINF, 'returns expected value' );
 	t.strictEqual( isPositiveZerof( parts[1] ), true, 'returns expected value' );
 	t.end();
@@ -205,7 +205,7 @@ tape( 'if provided `-infinity`, the function returns `[-infinity,-0]`', function
 
 	out = [ 0.0, 0.0 ];
 	parts = modff( NINF, out, 1, 0 );
-	t.equal( parts, out, 'returns output array' );
+	t.strictEqual( parts, out, 'returns output array' );
 	t.strictEqual( parts[0], NINF, 'returns expected value' );
 	t.strictEqual( isNegativeZerof( parts[1] ), true, 'returns expected value' );
 	t.end();
@@ -217,7 +217,7 @@ tape( 'if provided `NaN`, the function returns `[NaN,NaN]`', function test( t )
 
 	out = [ 0.0, 0.0 ];
 	parts = modff( NaN, out, 1, 0 );
-	t.equal( parts, out, 'returns output array' );
+	t.strictEqual( parts, out, 'returns output array' );
 	t.strictEqual( isnanf( parts[0] ), true, 'returns expected value' );
 	t.strictEqual( isnanf( parts[1] ), true, 'returns expected value' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/base/special/pow/test/test.x_is_zero.js b/lib/node_modules/@stdlib/math/base/special/pow/test/test.x_is_zero.js
index f2c646479945..ebd5dbe9a9c1 100644
--- a/lib/node_modules/@stdlib/math/base/special/pow/test/test.x_is_zero.js
+++ b/lib/node_modules/@stdlib/math/base/special/pow/test/test.x_is_zero.js
@@ -40,10 +40,10 @@ tape( 'the function returns `+infinity` if `y = -infinity`', function test( t )
 	var v;
 
 	v = pow( 0.0, NINF );
-	t.equal( v, PINF, 'returns expected value' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = pow( -0.0, NINF );
-	t.equal( v, PINF, 'returns expected value' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -52,10 +52,10 @@ tape( 'the function returns `+0` if `y = +infinity`', function test( t ) {
 	var v;
 
 	v = pow( 0.0, PINF );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = pow( -0.0, PINF );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -64,10 +64,10 @@ tape( 'the function returns `x` if `y` is an odd positive integer', function tes
 	var v;
 
 	v = pow( 0.0, 5 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = pow( -0.0, 5 );
-	t.equal( isNegativeZero( v ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,10 +76,10 @@ tape( 'the function returns `+0` if `y` is positive but not an odd integer', fun
 	var v;
 
 	v = pow( 0.0, 4 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = pow( -0.0, 3.14 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,10 +88,10 @@ tape( 'the function returns `+-infinity` if `y` is a negative odd integer', func
 	var v;
 
 	v = pow( 0.0, -5 );
-	t.equal( v, PINF, 'returns expected value' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = pow( -0.0, -5 );
-	t.equal( v, NINF, 'returns expected value' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -100,10 +100,10 @@ tape( 'the function returns `+infinity` if `y` is negative but not an odd intege
 	var v;
 
 	v = pow( 0.0, -4 );
-	t.equal( v, PINF, 'returns expected value' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = pow( -0.0, -3.14 );
-	t.equal( v, PINF, 'returns expected value' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/powm1/test/test.js b/lib/node_modules/@stdlib/math/base/special/powm1/test/test.js
index 37a126ff9ce6..57957534f041 100644
--- a/lib/node_modules/@stdlib/math/base/special/powm1/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/powm1/test/test.js
@@ -48,7 +48,7 @@ tape( 'the function accepts two parameters: a base and an exponent', function te
 	t.end();
 });
 
-tape( 'if provided an exponent equal to `0`, the function returns `0`', function test( t ) {
+tape( 'if provided an exponent.strictEqual to `0`, the function returns `0`', function test( t ) {
 	var i;
 	for ( i = -100; i < 100; i++ ) {
 		t.strictEqual( powm1( i, 0.0 ), 0.0, 'returns -1' );
diff --git a/lib/node_modules/@stdlib/math/base/special/powm1/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/powm1/test/test.native.js
index 688d8286c364..5060862bce2f 100644
--- a/lib/node_modules/@stdlib/math/base/special/powm1/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/powm1/test/test.native.js
@@ -57,7 +57,7 @@ tape( 'the function accepts two parameters: a base and an exponent', opts, funct
 	t.end();
 });
 
-tape( 'if provided an exponent equal to `0`, the function returns `0`', opts, function test( t ) {
+tape( 'if provided an exponent.strictEqual to `0`, the function returns `0`', opts, function test( t ) {
 	var i;
 	for ( i = -100; i < 100; i++ ) {
 		t.strictEqual( powm1( i, 0.0 ), 0.0, 'returns -1' );
diff --git a/lib/node_modules/@stdlib/math/base/special/riemann-zeta/test/test.js b/lib/node_modules/@stdlib/math/base/special/riemann-zeta/test/test.js
index bc6a09d21dd6..70bb4119f428 100644
--- a/lib/node_modules/@stdlib/math/base/special/riemann-zeta/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/riemann-zeta/test/test.js
@@ -73,7 +73,7 @@ tape( 'the function evaluates the Riemann zeta function for very small values',
 	var v = zeta( 1.0e-10 );
 
 	// Checked against Julia:
-	t.equal( v, -0.5000000000918938 );
+	t.strictEqual( v, -0.5000000000918938 );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/riemann-zeta/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/riemann-zeta/test/test.native.js
index fb30e5f20272..f01c46904b5c 100644
--- a/lib/node_modules/@stdlib/math/base/special/riemann-zeta/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/riemann-zeta/test/test.native.js
@@ -82,7 +82,7 @@ tape( 'the function evaluates the Riemann zeta function for very small values',
 	var v = zeta( 1.0e-10 );
 
 	// Checked against Julia:
-	t.equal( v, -0.5000000000918938 );
+	t.strictEqual( v, -0.5000000000918938 );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/sici/test/test.assign.js b/lib/node_modules/@stdlib/math/base/special/sici/test/test.assign.js
index 139206e8abad..16f3d4e06f58 100644
--- a/lib/node_modules/@stdlib/math/base/special/sici/test/test.assign.js
+++ b/lib/node_modules/@stdlib/math/base/special/sici/test/test.assign.js
@@ -67,7 +67,7 @@ tape( 'the function computes the sine and cosine integrals for small positive nu
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		v = sici( x[ i ], out, 1, 0 );
-		t.equal( v, out, 'returns output array' );
+		t.strictEqual( v, out, 'returns output array' );
 
 		delta = abs( v[ 0 ] - si[ i ] );
 		tol = 2.0 * EPS * abs( si[ i ] );
@@ -97,7 +97,7 @@ tape( 'the function computes the sine and cosine integrals for medium positive n
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		v = sici( x[ i ], out, 1, 0 );
-		t.equal( v, out, 'returns output array' );
+		t.strictEqual( v, out, 'returns output array' );
 
 		delta = abs( v[ 0 ] - si[ i ] );
 		tol = 60.0 * EPS * abs( si[ i ] );
@@ -127,7 +127,7 @@ tape( 'the function computes the sine and cosine integrals for large positive nu
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		v = sici( x[ i ], out, 1, 0 );
-		t.equal( v, out, 'returns output array' );
+		t.strictEqual( v, out, 'returns output array' );
 
 		delta = abs( v[ 0 ] - si[ i ] );
 		tol = 2.0 * EPS * abs( si[ i ] );
@@ -157,7 +157,7 @@ tape( 'the function computes the sine and cosine integrals for small negative nu
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		v = sici( x[ i ], out, 1, 0 );
-		t.equal( v, out, 'returns output array' );
+		t.strictEqual( v, out, 'returns output array' );
 
 		delta = abs( v[ 0 ] - si[ i ] );
 		tol = 2.0 * EPS * abs( si[ i ] );
@@ -187,7 +187,7 @@ tape( 'the function computes the sine and cosine integrals for medium negative n
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		v = sici( x[ i ], out, 1, 0 );
-		t.equal( v, out, 'returns output array' );
+		t.strictEqual( v, out, 'returns output array' );
 
 		delta = abs( v[ 0 ] - si[ i ] );
 		tol = 60.0 * EPS * abs( si[ i ] );
@@ -217,7 +217,7 @@ tape( 'the function computes the sine and cosine integrals for large negative nu
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		v = sici( x[ i ], out, 1, 0 );
-		t.equal( v, out, 'returns output array' );
+		t.strictEqual( v, out, 'returns output array' );
 
 		delta = abs( v[ 0 ] - si[ i ] );
 		tol = 2.0 * EPS * abs( si[ i ] );
@@ -247,7 +247,7 @@ tape( 'the function computes the sine and cosine integrals for very large positi
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		v = sici( x[ i ], out, 1, 0 );
-		t.equal( v, out, 'returns output array' );
+		t.strictEqual( v, out, 'returns output array' );
 
 		delta = abs( v[ 0 ] - si[ i ] );
 		tol = 2.0 * EPS * abs( si[ i ] );
@@ -266,7 +266,7 @@ tape( 'the function returns `[0,-Infinity]` if provided `0`', function test( t )
 
 	out = [ 0.0, 0.0 ];
 	val = sici( 0.0, out, 1, 0 );
-	t.equal( val, out, 'returns output array' );
+	t.strictEqual( val, out, 'returns output array' );
 	t.strictEqual( val[ 0 ], 0.0, 'returns expected value' );
 	t.strictEqual( val[ 1 ], NINF, 'returns expected value' );
 	t.end();
@@ -278,7 +278,7 @@ tape( 'the function returns `[-PI/2,NaN]` if provided `-Infinity`', function tes
 
 	out = [ 0.0, 0.0 ];
 	val = sici( NINF, out, 1, 0 );
-	t.equal( val, out, 'returns output array' );
+	t.strictEqual( val, out, 'returns output array' );
 	t.strictEqual( val[ 0 ], -HALF_PI, 'returns expected value' );
 	t.strictEqual( isnan( val[ 1 ] ), true, 'returns expected value' );
 	t.end();
@@ -290,7 +290,7 @@ tape( 'the function returns `[PI/2,0]` if provided `+Infinity`', function test(
 
 	out = [ 0.0, 0.0 ];
 	val = sici( PINF, out, 1, 0 );
-	t.equal( val, out, 'returns output array' );
+	t.strictEqual( val, out, 'returns output array' );
 	t.strictEqual( val[ 0 ], HALF_PI, 'returns expected value' );
 	t.strictEqual( val[ 1 ], 0, 'returns expected value' );
 	t.end();
@@ -302,7 +302,7 @@ tape( 'the function returns `[NaN,NaN]` if provided `NaN`', function test( t ) {
 
 	out = [ 0.0, 0.0 ];
 	val = sici( NaN, out, 1, 0 );
-	t.equal( val, out, 'returns output array' );
+	t.strictEqual( val, out, 'returns output array' );
 	t.strictEqual( isnan( val[ 0 ] ), true, 'returns expected value' );
 	t.strictEqual( isnan( val[ 1 ] ), true, 'returns expected value' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/base/special/sincos/test/test.assign.js b/lib/node_modules/@stdlib/math/base/special/sincos/test/test.assign.js
index 2e93303749e9..d4e2b9063444 100644
--- a/lib/node_modules/@stdlib/math/base/special/sincos/test/test.assign.js
+++ b/lib/node_modules/@stdlib/math/base/special/sincos/test/test.assign.js
@@ -65,16 +65,16 @@ tape( 'the function computes the sine and cosine (for -256*pi < x < 0)', functio
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincos( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
+		t.strictEqual( y, z, 'returns output array' );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -101,16 +101,16 @@ tape( 'the function computes the sine and cosine (for 0 < x < 256*pi)', function
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincos( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
+		t.strictEqual( y, z, 'returns output array' );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -137,16 +137,16 @@ tape( 'the function computes the sine and cosine (for -2**60 (pi/2) < x < -2**20
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincos( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
+		t.strictEqual( y, z, 'returns output array' );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -173,16 +173,16 @@ tape( 'the function computes the sine and cosine (for 2**20 (pi/2) < x < 2**60 (
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincos( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
+		t.strictEqual( y, z, 'returns output array' );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -209,16 +209,16 @@ tape( 'the function computes the sine and cosine (for x <= -2**60 (PI/2))', func
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincos( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
+		t.strictEqual( y, z, 'returns output array' );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -245,16 +245,16 @@ tape( 'the function computes the sine and cosine (for x >= 2**60 (PI/2))', funct
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincos( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
+		t.strictEqual( y, z, 'returns output array' );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -270,9 +270,9 @@ tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 
 	z = [ 0.0, 0.0 ];
 	v = sincos( NaN, z, 1, 0 );
-	t.equal( v, z, 'returns output array' );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( v, z, 'returns output array' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -282,9 +282,9 @@ tape( 'the function returns `NaN` if provided `+infinity`', function test( t ) {
 
 	z = [ 0.0, 0.0 ];
 	v = sincos( PINF, z, 1, 0 );
-	t.equal( v, z, 'returns output array' );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( v, z, 'returns output array' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -294,9 +294,9 @@ tape( 'the function returns `NaN` if provided `-infinity`', function test( t ) {
 
 	z = [ 0.0, 0.0 ];
 	v = sincos( NINF, z, 1, 0 );
-	t.equal( v, z, 'returns output array' );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( v, z, 'returns output array' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -308,8 +308,8 @@ tape( 'the function supports providing an output typed array', function test( t
 	parts = sincos( 1.0, out, 1, 0 );
 
 	t.strictEqual( parts, out, 'returns output array' );
-	t.equal( parts[ 0 ], 0.8414709848078965, 'has expected first element' );
-	t.equal( parts[ 1 ], 0.5403023058681398, 'has expected second element' );
+	t.strictEqual( parts[ 0 ], 0.8414709848078965, 'has expected first element' );
+	t.strictEqual( parts[ 1 ], 0.5403023058681398, 'has expected second element' );
 
 	t.end();
 });
@@ -322,10 +322,10 @@ tape( 'the function supports specifying a stride', function test( t ) {
 	val = sincos( 1.0, out, 2, 0 );
 
 	t.strictEqual( val, out, 'returns output array' );
-	t.equal( val[ 0 ], 0.8414709848078965, 'returns expected value' );
-	t.equal( val[ 1 ], 0, 'returns expected value' );
-	t.equal( val[ 2 ], 0.5403023058681398, 'returns expected value' );
-	t.equal( val[ 3 ], 0, 'returns expected value' );
+	t.strictEqual( val[ 0 ], 0.8414709848078965, 'returns expected value' );
+	t.strictEqual( val[ 1 ], 0, 'returns expected value' );
+	t.strictEqual( val[ 2 ], 0.5403023058681398, 'returns expected value' );
+	t.strictEqual( val[ 3 ], 0, 'returns expected value' );
 
 	t.end();
 });
@@ -338,10 +338,10 @@ tape( 'the function supports specifying an offset', function test( t ) {
 	val = sincos( 1.0, out, 2, 1 );
 
 	t.strictEqual( val, out, 'returns output array' );
-	t.equal( val[ 0 ], 0, 'returns expected value' );
-	t.equal( val[ 1 ], 0.8414709848078965, 'returns expected value' );
-	t.equal( val[ 2 ], 0, 'returns expected value' );
-	t.equal( val[ 3 ], 0.5403023058681398, 'returns expected value' );
+	t.strictEqual( val[ 0 ], 0, 'returns expected value' );
+	t.strictEqual( val[ 1 ], 0.8414709848078965, 'returns expected value' );
+	t.strictEqual( val[ 2 ], 0, 'returns expected value' );
+	t.strictEqual( val[ 3 ], 0.5403023058681398, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/sincos/test/test.main.js b/lib/node_modules/@stdlib/math/base/special/sincos/test/test.main.js
index 87aa8619a837..9c77f2040e6c 100644
--- a/lib/node_modules/@stdlib/math/base/special/sincos/test/test.main.js
+++ b/lib/node_modules/@stdlib/math/base/special/sincos/test/test.main.js
@@ -63,14 +63,14 @@ tape( 'the function computes the sine and cosine (for -256*pi < x < 0)', functio
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincos( x[i] );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -96,14 +96,14 @@ tape( 'the function computes the sine and cosine (for 0 < x < 256*pi)', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincos( x[i] );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -129,14 +129,14 @@ tape( 'the function computes the sine and cosine (for -2**60 (pi/2) < x < -2**20
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincos( x[i] );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -162,14 +162,14 @@ tape( 'the function computes the sine and cosine (for 2**20 (pi/2) < x < 2**60 (
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincos( x[i] );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -195,14 +195,14 @@ tape( 'the function computes the sine and cosine (for x <= -2**60 (PI/2))', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincos( x[i] );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -228,14 +228,14 @@ tape( 'the function computes the sine and cosine (for x >= 2**60 (PI/2))', funct
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincos( x[i] );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -247,21 +247,21 @@ tape( 'the function computes the sine and cosine (for x >= 2**60 (PI/2))', funct
 
 tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 	var v = sincos( NaN );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `+infinity`', function test( t ) {
 	var v = sincos( PINF );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `-infinity`', function test( t ) {
 	var v = sincos( NINF );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/sincosd/test/test.assign.js b/lib/node_modules/@stdlib/math/base/special/sincosd/test/test.assign.js
index e88f9d98ad46..82eca30e4675 100644
--- a/lib/node_modules/@stdlib/math/base/special/sincosd/test/test.assign.js
+++ b/lib/node_modules/@stdlib/math/base/special/sincosd/test/test.assign.js
@@ -65,16 +65,16 @@ tape( 'the function computes the sine and cosine (for -256*180.0 < x < 0)', func
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincosd( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
+		t.strictEqual( y, z, 'returns output array' );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = 1.01 * EPS * abs( cosine[i] );
@@ -101,16 +101,16 @@ tape( 'the function computes the sine and cosine (for -256*180.0 < x < 0)', func
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincosd( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
+		t.strictEqual( y, z, 'returns output array' );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = 1.01 * EPS * abs( cosine[i] );
@@ -137,16 +137,16 @@ tape( 'the function computes the sine and cosine (for 0 < x < 256*180.0)', funct
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincosd( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
+		t.strictEqual( y, z, 'returns output array' );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = 1.01 * EPS * abs( cosine[i] );
@@ -173,16 +173,16 @@ tape( 'the function computes the sine and cosine (for -2**60 (180.0/2) < x < -2*
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincosd( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
+		t.strictEqual( y, z, 'returns output array' );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -209,16 +209,16 @@ tape( 'the function computes the sine and cosine (for 2**20 (180.0/2) < x < 2**6
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincosd( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
+		t.strictEqual( y, z, 'returns output array' );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -245,16 +245,16 @@ tape( 'the function computes the sine and cosine (for x <= -2**60 (180.0/2))', f
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincosd( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
+		t.strictEqual( y, z, 'returns output array' );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -281,16 +281,16 @@ tape( 'the function computes the sine and cosine (for x >= 2**60 (180.0/2))', fu
 
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincosd( x[i], z, 1, 0 );
-		t.equal( y, z, 'returns output array' );
+		t.strictEqual( y, z, 'returns output array' );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -306,9 +306,9 @@ tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 
 	z = [ 0.0, 0.0 ];
 	v = sincosd( NaN, z, 1, 0 );
-	t.equal( v, z, 'returns output array' );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( v, z, 'returns output array' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -318,9 +318,9 @@ tape( 'the function returns `NaN` if provided `+infinity`', function test( t ) {
 
 	z = [ 0.0, 0.0 ];
 	v = sincosd( PINF, z, 1, 0 );
-	t.equal( v, z, 'returns output array' );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( v, z, 'returns output array' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -330,9 +330,9 @@ tape( 'the function returns `NaN` if provided `-infinity`', function test( t ) {
 
 	z = [ 0.0, 0.0 ];
 	v = sincosd( NINF, z, 1, 0 );
-	t.equal( v, z, 'returns output array' );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( v, z, 'returns output array' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -344,8 +344,8 @@ tape( 'the function supports providing an output typed array', function test( t
 	parts = sincosd( 1.0, out, 1, 0 );
 
 	t.strictEqual( parts, out, 'returns output array' );
-	t.equal( parts[ 0 ], 0.01745240643728351, 'has expected first element' );
-	t.equal( parts[ 1 ], 0.9998476951563913, 'has expected second element' );
+	t.strictEqual( parts[ 0 ], 0.01745240643728351, 'has expected first element' );
+	t.strictEqual( parts[ 1 ], 0.9998476951563913, 'has expected second element' );
 
 	t.end();
 });
@@ -358,10 +358,10 @@ tape( 'the function supports specifying a stride', function test( t ) {
 	val = sincosd( 1.0, out, 2, 0 );
 
 	t.strictEqual( val, out, 'returns output array' );
-	t.equal( val[ 0 ], 0.01745240643728351, 'returns expected value' );
-	t.equal( val[ 1 ], 0, 'returns expected value' );
-	t.equal( val[ 2 ], 0.9998476951563913, 'returns expected value' );
-	t.equal( val[ 3 ], 0, 'returns expected value' );
+	t.strictEqual( val[ 0 ], 0.01745240643728351, 'returns expected value' );
+	t.strictEqual( val[ 1 ], 0, 'returns expected value' );
+	t.strictEqual( val[ 2 ], 0.9998476951563913, 'returns expected value' );
+	t.strictEqual( val[ 3 ], 0, 'returns expected value' );
 
 	t.end();
 });
@@ -374,10 +374,10 @@ tape( 'the function supports specifying an offset', function test( t ) {
 	val = sincosd( 1.0, out, 2, 1 );
 
 	t.strictEqual( val, out, 'returns output array' );
-	t.equal( val[ 0 ], 0, 'returns expected value' );
-	t.equal( val[ 1 ], 0.01745240643728351, 'returns expected value' );
-	t.equal( val[ 2 ], 0, 'returns expected value' );
-	t.equal( val[ 3 ], 0.9998476951563913, 'returns expected value' );
+	t.strictEqual( val[ 0 ], 0, 'returns expected value' );
+	t.strictEqual( val[ 1 ], 0.01745240643728351, 'returns expected value' );
+	t.strictEqual( val[ 2 ], 0, 'returns expected value' );
+	t.strictEqual( val[ 3 ], 0.9998476951563913, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/sincosd/test/test.main.js b/lib/node_modules/@stdlib/math/base/special/sincosd/test/test.main.js
index e054b24f8e19..b7c34d0e1aa5 100644
--- a/lib/node_modules/@stdlib/math/base/special/sincosd/test/test.main.js
+++ b/lib/node_modules/@stdlib/math/base/special/sincosd/test/test.main.js
@@ -63,14 +63,14 @@ tape( 'the function computes the sine and cosine (for -256*180.0 < x < 0)', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincosd( x[i] );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = 1.01 * EPS * abs( cosine[i] );
@@ -96,14 +96,14 @@ tape( 'the function computes the sine and cosine (for 0 < x < 256*180.0)', funct
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincosd( x[i] );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = 1.01 * EPS * abs( cosine[i] );
@@ -129,14 +129,14 @@ tape( 'the function computes the sine and cosine (for -2**60 (180.0/2) < x < -2*
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincosd( x[i] );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -162,14 +162,14 @@ tape( 'the function computes the sine and cosine (for 2**20 (180.0/2) < x < 2**6
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincosd( x[i] );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -195,14 +195,14 @@ tape( 'the function computes the sine and cosine (for x <= -2**60 (180.0/2))', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincosd( x[i] );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -228,14 +228,14 @@ tape( 'the function computes the sine and cosine (for x >= 2**60 (180.0/2))', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincosd( x[i] );
 		if ( y[0] === sine[ i ] ) {
-			t.equal( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
+			t.strictEqual( y[0], sine[ i ], 'x: '+x[i]+'. Expected: '+sine[i] );
 		} else {
 			delta = abs( y[0] - sine[i] );
 			tol = EPS * abs( sine[i] );
 			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y[0]+'. Expected: '+sine[i]+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 		if ( y[1] === cosine[ i ] ) {
-			t.equal( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
+			t.strictEqual( y[1], cosine[ i ], 'x: '+x[i]+'. Expected: '+cosine[i] );
 		} else {
 			delta = abs( y[1] - cosine[i] );
 			tol = EPS * abs( cosine[i] );
@@ -247,21 +247,21 @@ tape( 'the function computes the sine and cosine (for x >= 2**60 (180.0/2))', fu
 
 tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 	var v = sincosd( NaN );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `+infinity`', function test( t ) {
 	var v = sincosd( PINF );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `-infinity`', function test( t ) {
 	var v = sincosd( NINF );
-	t.equal( isnan( v[0] ), true, 'returns expected value' );
-	t.equal( isnan( v[1] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/sincospi/test/test.assign.js b/lib/node_modules/@stdlib/math/base/special/sincospi/test/test.assign.js
index 5f9c23e8ae5b..c6712bb47e8f 100644
--- a/lib/node_modules/@stdlib/math/base/special/sincospi/test/test.assign.js
+++ b/lib/node_modules/@stdlib/math/base/special/sincospi/test/test.assign.js
@@ -51,9 +51,9 @@ tape( 'if provided negative infinity, the function returns `[NaN,NaN]`', functio
 
 	out = [ 0.0, 0.0 ];
 	y = sincospi( NINF, out, 1, 0 );
-	t.equal( y, out, 'returns output array' );
-	t.equal( isnan( y[ 0 ] ), true, 'returns expected value' );
-	t.equal( isnan( y[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( y, out, 'returns output array' );
+	t.strictEqual( isnan( y[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( y[ 1 ] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,9 +63,9 @@ tape( 'if provided positive infinity, the function returns `[NaN,NaN]`', functio
 
 	out = [ 0.0, 0.0 ];
 	y = sincospi( PINF, out, 1, 0 );
-	t.equal( y, out, 'returns output array' );
-	t.equal( isnan( y[ 0 ] ), true, 'returns expected value' );
-	t.equal( isnan( y[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( y, out, 'returns output array' );
+	t.strictEqual( isnan( y[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( y[ 1 ] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -75,9 +75,9 @@ tape( 'if provided `NaN`, the function returns `[NaN,NaN]`', function test( t )
 
 	out = [ 0.0, 0.0 ];
 	y = sincospi( NaN, out, 1, 0 );
-	t.equal( y, out, 'returns output array' );
-	t.equal( isnan( y[ 0 ] ), true, 'returns expected value' );
-	t.equal( isnan( y[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( y, out, 'returns output array' );
+	t.strictEqual( isnan( y[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( y[ 1 ] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -95,9 +95,9 @@ tape( 'the function computes sin(πx) and cos(πx) for integer input', function
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		y = sincospi( x[ i ], out, 1, 0 );
-		t.equal( y, out, 'returns output array' );
-		t.equal( y[ 0 ], s[ i ], 'returns '+s[ i ] );
-		t.equal( y[ 1 ], c[ i ], 'returns '+c[ i ] );
+		t.strictEqual( y, out, 'returns output array' );
+		t.strictEqual( y[ 0 ], s[ i ], 'returns '+s[ i ] );
+		t.strictEqual( y[ 1 ], c[ i ], 'returns '+c[ i ] );
 	}
 	t.end();
 });
@@ -112,14 +112,14 @@ tape( 'if provided a value exceeding `2**53` (max (unsafe) float64 integer), the
 	for ( i = 0; i < 100; i++ ) {
 		out = [ 0.0, 0.0 ];
 		y = sincospi( x + i, out, 1, 0 );
-		t.equal( y, out, 'returns output array' );
-		t.equal( y[ 0 ], 0.0, 'returns expected value' );
-		t.equal( y[ 1 ], 1.0, 'returns expected value' );
+		t.strictEqual( y, out, 'returns output array' );
+		t.strictEqual( y[ 0 ], 0.0, 'returns expected value' );
+		t.strictEqual( y[ 1 ], 1.0, 'returns expected value' );
 	}
 	t.end();
 });
 
-tape( 'the function computes the sin(πx) and cos(πx) for fractional part equal to 1/2', function test( t ) {
+tape( 'the function computes the sin(πx) and cos(πx) for fractional part.strictEqual to 1/2', function test( t ) {
 	var out;
 	var x;
 	var y;
@@ -129,9 +129,9 @@ tape( 'the function computes the sin(πx) and cos(πx) for fractional part equal
 		x = 0.5 + ( 1.0 * i );
 		out = [ 0.0, 0.0 ];
 		y = sincospi( x, out, 1, 0 );
-		t.equal( y, out, 'returns output array' );
-		t.equal( y[ 0 ], ( (i%2 === 0) ? 1.0 : -1.0 ), 'x: '+x+'. Expected: 0' );
-		t.equal( y[ 1 ], 0.0, 'x: '+x+'. Expected: 0' );
+		t.strictEqual( y, out, 'returns output array' );
+		t.strictEqual( y[ 0 ], ( (i%2 === 0) ? 1.0 : -1.0 ), 'x: '+x+'. Expected: 0' );
+		t.strictEqual( y[ 1 ], 0.0, 'x: '+x+'. Expected: 0' );
 	}
 	t.end();
 });
@@ -151,16 +151,16 @@ tape( 'the function computes the sin(πx) and cos(πx) for decimal input', funct
 	for ( i = 0; i < x.length; i++ ) {
 		out = [ 0.0, 0.0 ];
 		y = sincospi( x[ i ], out, 1, 0 );
-		t.equal( y, out, 'returns output array' );
+		t.strictEqual( y, out, 'returns output array' );
 
 		if ( y[ 0 ] === s[ i ] ) {
-			t.equal( y[ 0 ], s[ i ], 'x: '+x[ i ]+'. Expected: '+s[ i ] );
+			t.strictEqual( y[ 0 ], s[ i ], 'x: '+x[ i ]+'. Expected: '+s[ i ] );
 		} else {
 			delta = abs( y[ 0 ] - s[ i ] );
 			t.ok( delta <= EPS, 'within tolerance. x: '+x[ i ]+'. Value: '+y[ 0 ]+'. Expected: '+s[ i ]+'. Tolerance: '+EPS+'.' );
 		}
 		if ( y[ 1 ] === c[ i ] ) {
-			t.equal( y[ 1 ], c[ i ], 'x: '+x[ i ]+'. Expected: '+c[ i ] );
+			t.strictEqual( y[ 1 ], c[ i ], 'x: '+x[ i ]+'. Expected: '+c[ i ] );
 		} else {
 			delta = abs( y[ 1 ] - c[ i ] );
 			t.ok( delta <= EPS, 'within tolerance. x: '+x[ i ]+'. Value: '+y[ 1 ]+'. Expected: '+c[ i ]+'. Tolerance: '+EPS+'.' );
@@ -177,8 +177,8 @@ tape( 'the function supports providing an output typed array', function test( t
 	parts = sincospi( NaN, out, 1, 0 );
 
 	t.strictEqual( parts, out, 'returns output array' );
-	t.equal( isnan( parts[ 0 ] ), true, 'returns expected value' );
-	t.equal( isnan( parts[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( parts[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( parts[ 1 ] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -190,9 +190,9 @@ tape( 'the function supports specifying a stride', function test( t ) {
 	val = sincospi( NaN, out, 2, 0 );
 
 	t.strictEqual( val, out, 'returns output array' );
-	t.equal( isnan(val[ 0 ]), true, 'returns expected value' );
+	t.strictEqual( isnan(val[ 0 ]), true, 'returns expected value' );
 	t.strictEqual( val[ 1 ], 0, 'returns expected value' );
-	t.equal( isnan( val[ 2 ]), true, 'returns expected value' );
+	t.strictEqual( isnan( val[ 2 ]), true, 'returns expected value' );
 	t.strictEqual( val[ 3 ], 0, 'returns expected value' );
 
 	t.end();
@@ -207,9 +207,9 @@ tape( 'the function supports specifying an offset', function test( t ) {
 
 	t.strictEqual( val, out, 'returns output array' );
 	t.strictEqual( val[ 0 ], 0, 'returns expected value' );
-	t.equal( isnan(val[ 1 ]), true, 'returns expected value' );
+	t.strictEqual( isnan(val[ 1 ]), true, 'returns expected value' );
 	t.strictEqual( val[ 2 ], 0, 'returns expected value' );
-	t.equal( isnan( val[ 3 ]), true, 'returns expected value' );
+	t.strictEqual( isnan( val[ 3 ]), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/sincospi/test/test.main.js b/lib/node_modules/@stdlib/math/base/special/sincospi/test/test.main.js
index eaf6d86a620c..5f0aa3fcc943 100644
--- a/lib/node_modules/@stdlib/math/base/special/sincospi/test/test.main.js
+++ b/lib/node_modules/@stdlib/math/base/special/sincospi/test/test.main.js
@@ -46,22 +46,22 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided negative infinity, the function returns `[NaN,NaN]`', function test( t ) {
 	var y = sincospi( NINF );
-	t.equal( isnan( y[ 0 ] ), true, 'returns expected value' );
-	t.equal( isnan( y[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( y[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( y[ 1 ] ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided positive infinity, the function returns `[NaN,NaN]`', function test( t ) {
 	var y = sincospi( PINF );
-	t.equal( isnan( y[ 0 ] ), true, 'returns expected value' );
-	t.equal( isnan( y[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( y[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( y[ 1 ] ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `[NaN,NaN]`', function test( t ) {
 	var y = sincospi( NaN );
-	t.equal( isnan( y[ 0 ] ), true, 'returns expected value' );
-	t.equal( isnan( y[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( y[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( y[ 1 ] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -77,8 +77,8 @@ tape( 'the function computes sin(πx) and cos(πx) for integer input', function
 	c = integers.cos;
 	for ( i = 0; i < x.length; i++ ) {
 		y = sincospi( x[ i ] );
-		t.equal( y[ 0 ], s[ i ], 'returns '+s[ i ] );
-		t.equal( y[ 1 ], c[ i ], 'returns '+c[ i ] );
+		t.strictEqual( y[ 0 ], s[ i ], 'returns '+s[ i ] );
+		t.strictEqual( y[ 1 ], c[ i ], 'returns '+c[ i ] );
 	}
 	t.end();
 });
@@ -91,13 +91,13 @@ tape( 'if provided a value exceeding `2**53` (max (unsafe) float64 integer), the
 	x = pow( 2.0, 53 ) + 1.0;
 	for ( i = 0; i < 100; i++ ) {
 		y = sincospi( x+i );
-		t.equal( y[ 0 ], 0.0, 'returns expected value' );
-		t.equal( y[ 1 ], 1.0, 'returns expected value' );
+		t.strictEqual( y[ 0 ], 0.0, 'returns expected value' );
+		t.strictEqual( y[ 1 ], 1.0, 'returns expected value' );
 	}
 	t.end();
 });
 
-tape( 'the function computes the sin(πx) and cos(πx) for fractional part equal to 1/2', function test( t ) {
+tape( 'the function computes the sin(πx) and cos(πx) for fractional part.strictEqual to 1/2', function test( t ) {
 	var x;
 	var y;
 	var i;
@@ -105,8 +105,8 @@ tape( 'the function computes the sin(πx) and cos(πx) for fractional part equal
 	for ( i = -100; i <= 100; i++ ) {
 		x = 0.5 + ( 1.0 * i );
 		y = sincospi( x );
-		t.equal( y[ 0 ], ( (i%2 === 0) ? 1.0 : -1.0 ), 'x: '+x+'. Expected: 0' );
-		t.equal( y[ 1 ], 0.0, 'x: '+x+'. Expected: 0' );
+		t.strictEqual( y[ 0 ], ( (i%2 === 0) ? 1.0 : -1.0 ), 'x: '+x+'. Expected: 0' );
+		t.strictEqual( y[ 1 ], 0.0, 'x: '+x+'. Expected: 0' );
 	}
 	t.end();
 });
@@ -126,13 +126,13 @@ tape( 'the function computes the sin(πx) and cos(πx) for decimal input', funct
 		y = sincospi( x[ i ] );
 
 		if ( y[ 0 ] === s[ i ] ) {
-			t.equal( y[ 0 ], s[ i ], 'x: '+x[ i ]+'. Expected: '+s[ i ] );
+			t.strictEqual( y[ 0 ], s[ i ], 'x: '+x[ i ]+'. Expected: '+s[ i ] );
 		} else {
 			delta = abs( y[ 0 ] - s[ i ] );
 			t.ok( delta <= EPS, 'within tolerance. x: '+x[ i ]+'. Value: '+y[ 0 ]+'. Expected: '+s[ i ]+'. Tolerance: '+EPS+'.' );
 		}
 		if ( y[ 1 ] === c[ i ] ) {
-			t.equal( y[ 1 ], c[ i ], 'x: '+x[ i ]+'. Expected: '+c[ i ] );
+			t.strictEqual( y[ 1 ], c[ i ], 'x: '+x[ i ]+'. Expected: '+c[ i ] );
 		} else {
 			delta = abs( y[ 1 ] - c[ i ] );
 			t.ok( delta <= EPS, 'within tolerance. x: '+x[ i ]+'. Value: '+y[ 1 ]+'. Expected: '+c[ i ]+'. Tolerance: '+EPS+'.' );
diff --git a/lib/node_modules/@stdlib/math/base/special/sincospi/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/sincospi/test/test.native.js
index 97978a06ddea..9c0dc922db68 100644
--- a/lib/node_modules/@stdlib/math/base/special/sincospi/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/sincospi/test/test.native.js
@@ -106,7 +106,7 @@ tape( 'if provided a value exceeding `2**53` (max (unsafe) float64 integer), the
 	t.end();
 });
 
-tape( 'the function computes the sin(πx) and cos(πx) for fractional part equal to 1/2', opts, function test( t ) {
+tape( 'the function computes the sin(πx) and cos(πx) for fractional part.strictEqual to 1/2', opts, function test( t ) {
 	var x;
 	var y;
 	var i;
diff --git a/lib/node_modules/@stdlib/math/base/special/tan/test/test.js b/lib/node_modules/@stdlib/math/base/special/tan/test/test.js
index 12d09d70601d..6ce801824c43 100644
--- a/lib/node_modules/@stdlib/math/base/special/tan/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/tan/test/test.js
@@ -287,7 +287,7 @@ tape( 'if provided a multiple of `-pi/2`, the function does not return `-infinit
 	var x;
 	var v;
 
-	// NOTE: does not equal -inf due to approx errors. Comparing to Julia: -1.633123935319537e16
+	// NOTE: does not.strictEqual -inf due to approx errors. Comparing to Julia: -1.633123935319537e16
 	x = -PI / 2.0;
 	v = tan( x );
 	expected = -1.633123935319537e16;
@@ -301,7 +301,7 @@ tape( 'if provided a multiple of `pi/2`, the function does not return `+infinity
 	var x;
 	var v;
 
-	// NOTE: does not equal +inf due to approx errors. Comparing to Julia: +1.633123935319537e16
+	// NOTE: does not.strictEqual +inf due to approx errors. Comparing to Julia: +1.633123935319537e16
 	x = PI / 2.0;
 	v = tan( x );
 	expected = 1.633123935319537e16;
diff --git a/lib/node_modules/@stdlib/math/base/special/tan/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/tan/test/test.native.js
index 35adbf37b8fe..9c42a4cfd958 100644
--- a/lib/node_modules/@stdlib/math/base/special/tan/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/tan/test/test.native.js
@@ -310,7 +310,7 @@ tape( 'if provided a multiple of `-pi/2`, the function does not return `-infinit
 	var x;
 	var v;
 
-	// NOTE: does not equal -inf due to approx errors. Comparing to Julia: -1.633123935319537e16
+	// NOTE: does not.strictEqual -inf due to approx errors. Comparing to Julia: -1.633123935319537e16
 	x = -PI / 2.0;
 	v = tan( x );
 	expected = -1.633123935319537e16;
@@ -324,7 +324,7 @@ tape( 'if provided a multiple of `pi/2`, the function does not return `+infinity
 	var x;
 	var v;
 
-	// NOTE: does not equal +inf due to approx errors. Comparing to Julia: +1.633123935319537e16
+	// NOTE: does not.strictEqual +inf due to approx errors. Comparing to Julia: +1.633123935319537e16
 	x = PI / 2.0;
 	v = tan( x );
 	expected = 1.633123935319537e16;
diff --git a/lib/node_modules/@stdlib/math/base/special/tanf/test/test.js b/lib/node_modules/@stdlib/math/base/special/tanf/test/test.js
index 96c48d0efbbd..c1c462761d0f 100644
--- a/lib/node_modules/@stdlib/math/base/special/tanf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/tanf/test/test.js
@@ -316,7 +316,7 @@ tape( 'if provided a multiple of `-pi/2`, the function does not return `-infinit
 	var x;
 	var v;
 
-	// NOTE: does not equal -inf due to rounding errors. Comparing to Julia: 2.2877332e7
+	// NOTE: does not.strictEqual -inf due to rounding errors. Comparing to Julia: 2.2877332e7
 	x = f32( -PI / f32( 2.0 ) );
 	v = tanf( x );
 	expected = f32( 2.2877332e7 );
@@ -329,7 +329,7 @@ tape( 'if provided a multiple of `pi/2`, the function does not return `+infinity
 	var x;
 	var v;
 
-	// NOTE: does not equal +inf due to rounding errors. Comparing to Julia: -2.2877332e7
+	// NOTE: does not.strictEqual +inf due to rounding errors. Comparing to Julia: -2.2877332e7
 	x = f32( PI / f32( 2.0 ) );
 	v = tanf( x );
 	expected = f32( -2.2877332e7 );
diff --git a/lib/node_modules/@stdlib/math/base/special/tanf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/tanf/test/test.native.js
index 8550342c4647..5478b5a2d588 100644
--- a/lib/node_modules/@stdlib/math/base/special/tanf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/tanf/test/test.native.js
@@ -325,7 +325,7 @@ tape( 'if provided a multiple of `-pi/2`, the function does not return `-infinit
 	var x;
 	var v;
 
-	// NOTE: does not equal -inf due to rounding errors. Comparing to Julia: 2.2877332e7
+	// NOTE: does not.strictEqual -inf due to rounding errors. Comparing to Julia: 2.2877332e7
 	x = f32( -PI / f32( 2.0 ) );
 	v = tanf( x );
 	expected = f32( 2.2877332e7 );
@@ -338,7 +338,7 @@ tape( 'if provided a multiple of `pi/2`, the function does not return `+infinity
 	var x;
 	var v;
 
-	// NOTE: does not equal +inf due to rounding errors. Comparing to Julia: -2.2877332e7
+	// NOTE: does not.strictEqual +inf due to rounding errors. Comparing to Julia: -2.2877332e7
 	x = f32( PI / f32( 2.0 ) );
 	v = tanf( x );
 	expected = f32( -2.2877332e7 );
diff --git a/lib/node_modules/@stdlib/math/base/special/wrapf/test/test.js b/lib/node_modules/@stdlib/math/base/special/wrapf/test/test.js
index d08c68277e02..cde1f45551d4 100644
--- a/lib/node_modules/@stdlib/math/base/special/wrapf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/wrapf/test/test.js
@@ -39,25 +39,25 @@ tape( 'if provided `NaN` for any argument, the function returns `NaN`', function
 	var v;
 
 	v = wrapf( NaN, 0.0, 5.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( 0.0, NaN, 5.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( 3.14, 0.0, NaN );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( NaN, NaN, 5.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( NaN, 0.0, NaN );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( 3.14, NaN, NaN );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( NaN, NaN, NaN );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided a value which is between a minimum value (inclusive) and a ma
 	var v;
 
 	v = wrapf( 3.14, 0.0, 5.0 );
-	t.equal( v, f32( 3.14 ), 'returns expected value' );
+	t.strictEqual( v, f32( 3.14 ), 'returns expected value' );
 
 	v = wrapf( -3.14, -10.0, 15.0 );
-	t.equal( v, f32( -3.14 ), 'returns expected value' );
+	t.strictEqual( v, f32( -3.14 ), 'returns expected value' );
 
 	v = wrapf( 3.14, 3.14, 5.0 );
-	t.equal( v, f32( 3.14 ), 'returns expected value' );
+	t.strictEqual( v, f32( 3.14 ), 'returns expected value' );
 
 	v = wrapf( 3.13, 0.0, 3.14 );
-	t.equal( v, f32( 3.13 ), 'returns expected value' );
+	t.strictEqual( v, f32( 3.13 ), 'returns expected value' );
 
 	t.end();
 });
@@ -84,46 +84,46 @@ tape( 'if provided a value which less than a minimum value or greater than or eq
 	var v;
 
 	v = wrapf( 13.00, 0.0, 5.0 );
-	t.equal( v, f32( 3.00 ), 'returns expected value' );
+	t.strictEqual( v, f32( 3.00 ), 'returns expected value' );
 
 	v = wrapf( -13.1, -10.0, 15.0 );
-	t.equal( v, f32( 11.90 ), 'returns expected value' );
+	t.strictEqual( v, f32( 11.90 ), 'returns expected value' );
 
 	v = wrapf( 10.0, 0.0, 5.0 );
-	t.equal( v, f32( 0.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( 0.0 ), 'returns expected value' );
 
 	v = wrapf( -10.0, 0.0, 5.0 );
-	t.equal( v, f32( 0.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( 0.0 ), 'returns expected value' );
 
 	v = wrapf( -30.0, 0.0, 5.0 );
-	t.equal( v, f32( 0.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( 0.0 ), 'returns expected value' );
 
 	v = wrapf( -30.0, -5.0, 0.0 );
-	t.equal( v, f32( -5.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( -5.0 ), 'returns expected value' );
 
 	v = wrapf( 30.0, 0.0, 5.0 );
-	t.equal( v, f32( 0.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( 0.0 ), 'returns expected value' );
 
 	v = wrapf( 31.0, 0.0, 5.0 );
-	t.equal( v, f32( 1.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( 1.0 ), 'returns expected value' );
 
 	v = wrapf( -31.0, -5.0, 0.0 );
-	t.equal( v, f32( -1.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( -1.0 ), 'returns expected value' );
 
 	v = wrapf( 0.0, -3.14, 0.0 );
-	t.equal( v, f32( -3.14 ), 'returns expected value' );
+	t.strictEqual( v, f32( -3.14 ), 'returns expected value' );
 
 	v = wrapf( 0.0, -10.0, -0.0 );
-	t.equal( v, f32( -10.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( -10.0 ), 'returns expected value' );
 
 	v = wrapf( -0.0, -10.0, 0.0 );
-	t.equal( v, f32( -10.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( -10.0 ), 'returns expected value' );
 
 	v = wrapf( 0.0, -10.0, 0.0 );
-	t.equal( v, f32( -10.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( -10.0 ), 'returns expected value' );
 
 	v = wrapf( -0.0, -10.0, -0.0 );
-	t.equal( v, f32( -10.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( -10.0 ), 'returns expected value' );
 
 	t.end();
 });
@@ -132,16 +132,16 @@ tape( 'the function does not distinguish between positive and negative zero', fu
 	var v;
 
 	v = wrapf( -0.0, 0.0, 5.0 );
-	t.equal( isPositiveZerof( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' );
 
 	v = wrapf( 0.0, -0.0, 5.0 );
-	t.equal( isPositiveZerof( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' );
 
 	v = wrapf( -0.0, -0.0, 5.0 );
-	t.equal( isPositiveZerof( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' );
 
 	v = wrapf( 0.0, 0.0, 5.0 );
-	t.equal( isPositiveZerof( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -150,16 +150,16 @@ tape( 'the function returns `NaN` if provided a maximum value which is less than
 	var v;
 
 	v = wrapf( 3.14, 10.0, 0.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( 3.14, 10.0, 10.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( 3.14, 3.0, 1.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( 3.14, 1.0, 1.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/wrapf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/wrapf/test/test.native.js
index 3e30405f384a..a238bc0a71e2 100644
--- a/lib/node_modules/@stdlib/math/base/special/wrapf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/wrapf/test/test.native.js
@@ -48,25 +48,25 @@ tape( 'if provided `NaN` for any argument, the function returns `NaN`', opts, fu
 	var v;
 
 	v = wrapf( NaN, 0.0, 5.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( 0.0, NaN, 5.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( 3.14, 0.0, NaN );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( NaN, NaN, 5.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( NaN, 0.0, NaN );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( 3.14, NaN, NaN );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( NaN, NaN, NaN );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,16 +75,16 @@ tape( 'if provided a value which is between a minimum value (inclusive) and a ma
 	var v;
 
 	v = wrapf( 3.14, 0.0, 5.0 );
-	t.equal( v, f32( 3.14 ), 'returns expected value' );
+	t.strictEqual( v, f32( 3.14 ), 'returns expected value' );
 
 	v = wrapf( -3.14, -10.0, 15.0 );
-	t.equal( v, f32( -3.14 ), 'returns expected value' );
+	t.strictEqual( v, f32( -3.14 ), 'returns expected value' );
 
 	v = wrapf( 3.14, 3.14, 5.0 );
-	t.equal( v, f32( 3.14 ), 'returns expected value' );
+	t.strictEqual( v, f32( 3.14 ), 'returns expected value' );
 
 	v = wrapf( 3.13, 0.0, 3.14 );
-	t.equal( v, f32( 3.13 ), 'returns expected value' );
+	t.strictEqual( v, f32( 3.13 ), 'returns expected value' );
 
 	t.end();
 });
@@ -93,46 +93,46 @@ tape( 'if provided a value which less than a minimum value or greater than or eq
 	var v;
 
 	v = wrapf( 13.00, 0.0, 5.0 );
-	t.equal( v, f32( 3.00 ), 'returns expected value' );
+	t.strictEqual( v, f32( 3.00 ), 'returns expected value' );
 
 	v = wrapf( -13.1, -10.0, 15.0 );
-	t.equal( v, f32( 11.90 ), 'returns expected value' );
+	t.strictEqual( v, f32( 11.90 ), 'returns expected value' );
 
 	v = wrapf( 10.0, 0.0, 5.0 );
-	t.equal( v, f32( 0.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( 0.0 ), 'returns expected value' );
 
 	v = wrapf( -10.0, 0.0, 5.0 );
-	t.equal( v, f32( 0.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( 0.0 ), 'returns expected value' );
 
 	v = wrapf( -30.0, 0.0, 5.0 );
-	t.equal( v, f32( 0.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( 0.0 ), 'returns expected value' );
 
 	v = wrapf( -30.0, -5.0, 0.0 );
-	t.equal( v, f32( -5.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( -5.0 ), 'returns expected value' );
 
 	v = wrapf( 30.0, 0.0, 5.0 );
-	t.equal( v, f32( 0.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( 0.0 ), 'returns expected value' );
 
 	v = wrapf( 31.0, 0.0, 5.0 );
-	t.equal( v, f32( 1.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( 1.0 ), 'returns expected value' );
 
 	v = wrapf( -31.0, -5.0, 0.0 );
-	t.equal( v, f32( -1.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( -1.0 ), 'returns expected value' );
 
 	v = wrapf( 0.0, -3.14, 0.0 );
-	t.equal( v, f32( -3.14 ), 'returns expected value' );
+	t.strictEqual( v, f32( -3.14 ), 'returns expected value' );
 
 	v = wrapf( 0.0, -10.0, -0.0 );
-	t.equal( v, f32( -10.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( -10.0 ), 'returns expected value' );
 
 	v = wrapf( -0.0, -10.0, 0.0 );
-	t.equal( v, f32( -10.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( -10.0 ), 'returns expected value' );
 
 	v = wrapf( 0.0, -10.0, 0.0 );
-	t.equal( v, f32( -10.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( -10.0 ), 'returns expected value' );
 
 	v = wrapf( -0.0, -10.0, -0.0 );
-	t.equal( v, f32( -10.0 ), 'returns expected value' );
+	t.strictEqual( v, f32( -10.0 ), 'returns expected value' );
 
 	t.end();
 });
@@ -141,16 +141,16 @@ tape( 'the function does not distinguish between positive and negative zero', op
 	var v;
 
 	v = wrapf( -0.0, 0.0, 5.0 );
-	t.equal( isPositiveZerof( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' );
 
 	v = wrapf( 0.0, -0.0, 5.0 );
-	t.equal( isPositiveZerof( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' );
 
 	v = wrapf( -0.0, -0.0, 5.0 );
-	t.equal( isPositiveZerof( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' );
 
 	v = wrapf( 0.0, 0.0, 5.0 );
-	t.equal( isPositiveZerof( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -159,16 +159,16 @@ tape( 'the function returns `NaN` if provided a maximum value which is less than
 	var v;
 
 	v = wrapf( 3.14, 10.0, 0.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( 3.14, 10.0, 10.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( 3.14, 3.0, 1.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = wrapf( 3.14, 1.0, 1.0 );
-	t.equal( isnanf( v ), true, 'returns expected value' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/test/test.js b/lib/node_modules/@stdlib/math/base/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/math/base/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/continued-fraction/test/test.js b/lib/node_modules/@stdlib/math/base/tools/continued-fraction/test/test.js
index f7dab433485b..839b43d8dafb 100644
--- a/lib/node_modules/@stdlib/math/base/tools/continued-fraction/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/continued-fraction/test/test.js
@@ -39,7 +39,8 @@ var hasGeneratorsSupport = detectGeneratorSupport();
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
-	t.equal( typeof continuedFraction, 'function', 'main export is a function' );
+	t.ok( true, __filename );
+	t.strictEqual( typeof continuedFraction, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile-c/test/test.js b/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile-c/test/test.js
index 36a3b864d970..90320fb5e543 100644
--- a/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile-c/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile-c/test/test.js
@@ -49,16 +49,16 @@ tape( 'the function returns a string (default)', opts, function test( t ) {
 	var str;
 
 	str = compile( [] );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0 ] );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ] );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( new Float64Array( 501 ) );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -72,16 +72,16 @@ tape( 'the function returns a string (custom name)', opts, function test( t ) {
 	};
 
 	str = compile( [], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( new Float64Array( 501 ), options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'the function returns a string (custom dtype)', opts, function test( t ) {
 	};
 
 	str = compile( [], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( new Float64Array( 501 ), options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'if provided an empty coefficient array, the function returns a function s
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'if provided an empty coefficient array, the function returns a function s
 		'dtype': 'double'
 	};
 	actual = compile( [], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -166,7 +166,7 @@ tape( 'if provided an empty coefficient array, the function returns a function s
 		'dtype': 'float'
 	};
 	actual = compile( [], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -188,7 +188,7 @@ tape( 'if provided an empty coefficient array, the function returns a function s
 		'name': 'polyval123'
 	};
 	actual = compile( [], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -206,7 +206,7 @@ tape( 'if provided only 1 coefficient, the function returns a function string wh
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ 3.14 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -228,7 +228,7 @@ tape( 'if provided only 1 coefficient, the function returns a function string wh
 		'dtype': 'double'
 	};
 	actual = compile( [ 3.14 ], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -251,7 +251,7 @@ tape( 'if provided only 1 coefficient, the function returns a function string wh
 		'name': 'polyval123'
 	};
 	actual = compile( [ 3.14 ], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -269,7 +269,7 @@ tape( 'if provided only 1 coefficient, the function returns a function string wh
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ -3.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -291,7 +291,7 @@ tape( 'if provided only 1 coefficient, the function returns a function string wh
 		'dtype': 'double'
 	};
 	actual = compile( [ -3.0 ], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -314,7 +314,7 @@ tape( 'if provided only 1 coefficient, the function returns a function string wh
 		'name': 'polyval123'
 	};
 	actual = compile( [ -3.0 ], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -332,7 +332,7 @@ tape( 'the function returns a function string which evaluates a polynomial (defa
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ 1.0, 2.5, 3.14, -1.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -350,7 +350,7 @@ tape( 'the function returns a function string which evaluates a polynomial (defa
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ -3.14, 0.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -368,7 +368,7 @@ tape( 'the function returns a function string which evaluates a polynomial (defa
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ 1.0, 2.5, 3.14, -1.0, 5.0, 2.0, 3.5, 8.0, 4.2, 1.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -391,7 +391,7 @@ tape( 'the function returns a function string which evaluates a polynomial (cust
 		'name': 'polyval123'
 	};
 	actual = compile( [ 1.0, 2.5, 3.14, -1.0 ], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -415,7 +415,7 @@ tape( 'the function returns a function string which evaluates a polynomial (larg
 		c[ i ] = i;
 	}
 	actual = compile( c );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -439,7 +439,7 @@ tape( 'the function returns a function string which evaluates a polynomial (larg
 		c[ i ] = i + 0.1;
 	}
 	actual = compile( c );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -469,7 +469,7 @@ tape( 'the function returns a function string which evaluates a polynomial (larg
 		'name': 'polyval123'
 	};
 	actual = compile( c, options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile/test/test.js b/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile/test/test.js
index 8077c407bc43..d2d8073377b6 100644
--- a/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile/test/test.js
@@ -50,16 +50,16 @@ tape( 'the function returns a string', opts, function test( t ) {
 	var str;
 
 	str = compile( [] );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0 ] );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ] );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( new Float64Array( 501 ) );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -73,16 +73,16 @@ tape( 'the function returns a string (dtype=float64)', opts, function test( t )
 	};
 
 	str = compile( [], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( new Float64Array( 501 ) );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -96,16 +96,16 @@ tape( 'the function returns a string (dtype=float32)', opts, function test( t )
 	};
 
 	str = compile( [], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( new Float64Array( 501 ) );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'if provided an empty coefficient array, the function returns a module str
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'if provided an empty coefficient array, the function returns a module str
 	actual = compile( [], {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -163,7 +163,7 @@ tape( 'if provided an empty coefficient array, the function returns a module str
 	actual = compile( [], {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -181,7 +181,7 @@ tape( 'if provided only 1 coefficient, the function returns a module string cont
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ 3.14 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -201,7 +201,7 @@ tape( 'if provided only 1 coefficient, the function returns a module string cont
 	actual = compile( [ 3.14 ], {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -221,7 +221,7 @@ tape( 'if provided only 1 coefficient, the function returns a module string cont
 	actual = compile( new Float32Array( [ 3.14 ] ), {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -239,7 +239,7 @@ tape( 'if provided only 1 coefficient, the function returns a module string cont
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ -3.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -259,7 +259,7 @@ tape( 'if provided only 1 coefficient, the function returns a module string cont
 	actual = compile( [ -3.0 ], {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -279,7 +279,7 @@ tape( 'if provided only 1 coefficient, the function returns a module string cont
 	actual = compile( new Float32Array( [ -3.0 ] ), {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -297,7 +297,7 @@ tape( 'the function returns a module string containing an exported function whic
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ 1.0, 2.5, 3.14, -1.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -317,7 +317,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( [ 1.0, 2.5, 3.14, -1.0 ], {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -337,7 +337,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( new Float32Array( [ 1.0, 2.5, 3.14, -1.0 ] ), {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -355,7 +355,7 @@ tape( 'the function returns a module string containing an exported function whic
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ -3.14, 0.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -375,7 +375,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( [ -3.14, 0.0 ], {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -395,7 +395,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( new Float32Array( [ -3.14, 0.0 ] ), {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -413,7 +413,7 @@ tape( 'the function returns a module string containing an exported function whic
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ 1.0, 2.5, 3.14, -1.0, 5.0, 2.0, 3.5, 8.0, 4.2, 1.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -433,7 +433,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( [ 1.0, 2.5, 3.14, -1.0, 5.0, 2.0, 3.5, 8.0, 4.2, 1.0 ], {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -453,7 +453,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( new Float32Array( [ 1.0, 2.5, 3.14, -1.0, 5.0, 2.0, 3.5, 8.0, 4.2, 1.0 ] ), { // eslint-disable-line max-len
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -477,7 +477,7 @@ tape( 'the function returns a module string containing an exported function whic
 		c.push( i );
 	}
 	actual = compile( c );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -503,7 +503,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( c, {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -529,7 +529,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( new Float32Array( c ), {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -553,7 +553,7 @@ tape( 'the function returns a module string containing an exported function whic
 		c.push( i + 0.1 );
 	}
 	actual = compile( c );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -579,7 +579,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( c, {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -605,7 +605,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( new Float32Array( c ), {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/evalrational-compile-c/test/test.js b/lib/node_modules/@stdlib/math/base/tools/evalrational-compile-c/test/test.js
index 97edbf2a33fa..6b981de315bb 100644
--- a/lib/node_modules/@stdlib/math/base/tools/evalrational-compile-c/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/evalrational-compile-c/test/test.js
@@ -49,16 +49,16 @@ tape( 'the function returns a string (default)', opts, function test( t ) {
 	var str;
 
 	str = compile( [], [] );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0 ], [ 2.0 ] );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], [ 3.0, 2.0, 1.0 ] );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( new Float64Array( 501 ), new Float64Array( 501 ) );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -72,16 +72,16 @@ tape( 'the function returns a string (custom name)', opts, function test( t ) {
 	};
 
 	str = compile( [], [], options );
-	t.equal( typeof str, 'string', 'returns a string', options );
+	t.strictEqual( typeof str, 'string', 'returns a string', options );
 
 	str = compile( [ 1.0 ], [ 2.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string', options );
+	t.strictEqual( typeof str, 'string', 'returns a string', options );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], [ 3.0, 2.0, 1.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string', options );
+	t.strictEqual( typeof str, 'string', 'returns a string', options );
 
 	str = compile( new Float64Array( 501 ), new Float64Array( 501 ), options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'the function returns a string (custom dtype)', opts, function test( t ) {
 	};
 
 	str = compile( [], [], options );
-	t.equal( typeof str, 'string', 'returns a string', options );
+	t.strictEqual( typeof str, 'string', 'returns a string', options );
 
 	str = compile( [ 1.0 ], [ 2.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string', options );
+	t.strictEqual( typeof str, 'string', 'returns a string', options );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], [ 3.0, 2.0, 1.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string', options );
+	t.strictEqual( typeof str, 'string', 'returns a string', options );
 
 	str = compile( new Float64Array( 501 ), new Float64Array( 501 ), options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'if provided empty coefficient arrays, the function returns a function str
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [], [] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'if provided empty coefficient arrays, the function returns a function str
 		'dtype': 'double'
 	};
 	actual = compile( [], [], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -167,7 +167,7 @@ tape( 'if provided empty coefficient arrays, the function returns a function str
 		'name': 'rational123'
 	};
 	actual = compile( [], [], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -185,7 +185,7 @@ tape( 'if provided coefficient arrays having different lengths, the function ret
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ 1.0, 2.0 ], [ 1.0, 2.0, 3.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -203,7 +203,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ 3.14 ], [ -0.5 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -226,7 +226,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 		'name': 'rational123'
 	};
 	actual = compile( [ 3.14 ], [ -0.5 ], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -244,7 +244,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ -3.0 ], [ 1.5 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -267,7 +267,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 		'name': 'rational123'
 	};
 	actual = compile( [ -3.0 ], [ 1.5 ], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -285,7 +285,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ 1.0 ], [ 0.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -308,7 +308,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 		'name': 'rational123'
 	};
 	actual = compile( [ 1.0 ], [ 0.0 ], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -326,7 +326,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ -1.0 ], [ 0.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -349,7 +349,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 		'name': 'rational123'
 	};
 	actual = compile( [ -1.0 ], [ 0.0 ], options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -367,7 +367,7 @@ tape( 'the function returns a function string which evaluates a rational functio
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ 1.0, 2.5, 3.14, -1.0 ], [ 4.0, -3.5, 2.2, 1.25 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -385,7 +385,7 @@ tape( 'the function returns a function string which evaluates a rational functio
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ -3.14, 0.0 ], [ 6.0, 0.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -407,7 +407,7 @@ tape( 'the function returns a function string which evaluates a rational functio
 	P = [ -3.14, 0.0, 4.0, 2.0, 3.0, 9.0, 5.4 ];
 	Q = [ 6.0, 0.0, 2.0, 1.0, 2.0, 4.8, 2.2 ];
 	actual = compile( P, Q );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -425,7 +425,7 @@ tape( 'the function returns a function string which evaluates a rational functio
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ -1.0, 2.5, 3.14, -1.0 ], [ 0.0, -3.5, 2.2, 1.25 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -448,7 +448,7 @@ tape( 'the function returns a function string which evaluates a rational functio
 		'name': 'rational123'
 	};
 	actual = compile( [ 1.0, 2.5, 3.14, -1.0 ], [ 4.0, -3.5, 2.2, 1.25 ], options ); // eslint-disable-line max-len
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -475,7 +475,7 @@ tape( 'the function returns a function string which evaluates a rational functio
 		Q[ i ] = i + 1;
 	}
 	actual = compile( P, Q );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -502,7 +502,7 @@ tape( 'the function returns a function string which evaluates a rational functio
 		Q[ i ] = i + 1.1;
 	}
 	actual = compile( P, Q );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -535,7 +535,7 @@ tape( 'the function returns a function string which evaluates a rational functio
 		'name': 'rational123'
 	};
 	actual = compile( P, Q, options );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -564,7 +564,7 @@ tape( 'the function returns a function string which evaluates a rational functio
 	P[ 0 ] = 1.0;
 	Q[ 0 ] = 0.0;
 	actual = compile( P, Q );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/evalrational-compile/test/test.js b/lib/node_modules/@stdlib/math/base/tools/evalrational-compile/test/test.js
index 4d24707c667d..b7c5fa4e70a4 100644
--- a/lib/node_modules/@stdlib/math/base/tools/evalrational-compile/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/evalrational-compile/test/test.js
@@ -52,16 +52,16 @@ tape( 'the function returns a string', opts, function test( t ) {
 	var str;
 
 	str = compile( [], [] );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0 ], [ 2.0 ] );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], [ 3.0, 2.0, 1.0 ] );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( new Float64Array( 501 ), new Float64Array( 501 ) );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -75,16 +75,16 @@ tape( 'the function returns a string (dtype=float64)', opts, function test( t )
 	};
 
 	str = compile( [], [], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0 ], [ 2.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], [ 3.0, 2.0, 1.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( new Float64Array( 501 ), new Float64Array( 501 ), options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -98,16 +98,16 @@ tape( 'the function returns a string (dtype=float32)', opts, function test( t )
 	};
 
 	str = compile( [], [], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0 ], [ 2.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], [ 3.0, 2.0, 1.0 ], options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	str = compile( new Float32Array( 501 ), new Float32Array( 501 ), options );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'if provided empty coefficient arrays, the function returns a module strin
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [], [] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -145,7 +145,7 @@ tape( 'if provided empty coefficient arrays, the function returns a module strin
 	actual = compile( [], [], {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -165,7 +165,7 @@ tape( 'if provided empty coefficient arrays, the function returns a module strin
 	actual = compile( [], [], {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'if provided coefficient arrays having different lengths, the function ret
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ 1.0, 2.0 ], [ 1.0, 2.0, 3.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -203,7 +203,7 @@ tape( 'if provided coefficient arrays having different lengths, the function ret
 	actual = compile( [ 1.0, 2.0 ], [ 1.0, 2.0, 3.0 ], {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -223,7 +223,7 @@ tape( 'if provided coefficient arrays having different lengths, the function ret
 	actual = compile( [ 1.0, 2.0 ], [ 1.0, 2.0, 3.0 ], {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -241,7 +241,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ 3.14 ], [ -0.5 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -261,7 +261,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 	actual = compile( [ 3.14 ], [ -0.5 ], {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -281,7 +281,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 	actual = compile( new Float32Array( [ 3.14 ] ), new Float32Array( [ -0.5 ] ), {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -299,7 +299,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ -3.0 ], [ 2.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -319,7 +319,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 	actual = compile( [ -3.0 ], [ 2.0 ], {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -339,7 +339,7 @@ tape( 'if provided coefficient arrays each containing 1 coefficient, the functio
 	actual = compile( new Float32Array( [ -3.0 ] ), new Float32Array( [ 2.0 ] ), {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -357,7 +357,7 @@ tape( 'the function returns a module string containing an exported function whic
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ 1.0, 2.5, 3.14, -1.0 ], [ 4.0, -3.5, 2.2, 1.25 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -377,7 +377,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( [ 1.0, 2.5, 3.14, -1.0 ], [ 4.0, -3.5, 2.2, 1.25 ], {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -397,7 +397,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( new Float32Array( [ 1.0, 2.5, 3.14, -1.0 ] ), new Float32Array( [ 4.0, -3.5, 2.2, 1.25 ] ), {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -415,7 +415,7 @@ tape( 'the function returns a module string containing an exported function whic
 	expected = readFile( fpath, fopts );
 
 	actual = compile( [ -3.14, 0.0 ], [ 6.0, 0.0 ] );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -435,7 +435,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( [ -3.14, 0.0 ], [ 6.0, 0.0 ], {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -455,7 +455,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( new Float32Array( [ -3.14, 0.0 ] ), new Float32Array( [ 6.0, 0.0 ] ), {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -477,7 +477,7 @@ tape( 'the function returns a module string containing an exported function whic
 	P = [ -3.14, 0.0, 4.0, 2.0, 3.0, 9.0, 5.4 ];
 	Q = [ 6.0, 0.0, 2.0, 1.0, 2.0, 4.8, 2.2 ];
 	actual = compile( P, Q );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -501,7 +501,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( P, Q, {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -525,7 +525,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( P, Q, {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -552,7 +552,7 @@ tape( 'the function returns a module string containing an exported function whic
 		Q.push( i+1 );
 	}
 	actual = compile( P, Q );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -581,7 +581,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( P, Q, {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -610,7 +610,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( new Float32Array( P ), new Float32Array( Q ), {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -637,7 +637,7 @@ tape( 'the function returns a module string containing an exported function whic
 		Q.push( i+1.1 );
 	}
 	actual = compile( P, Q );
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -666,7 +666,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( P, Q, {
 		'dtype': 'float64'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
@@ -695,7 +695,7 @@ tape( 'the function returns a module string containing an exported function whic
 	actual = compile( new Float32Array( P ), new Float32Array( Q ), {
 		'dtype': 'float32'
 	});
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/evalrational/test/test.js b/lib/node_modules/@stdlib/math/base/tools/evalrational/test/test.js
index 20b7232fa759..a1922ecaa1da 100644
--- a/lib/node_modules/@stdlib/math/base/tools/evalrational/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/evalrational/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a `factory` method', function test( t ) {
-	t.equal( typeof evalrational.factory, 'function', 'has method' );
+	t.strictEqual( typeof evalrational.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/evalrationalf/test/test.js b/lib/node_modules/@stdlib/math/base/tools/evalrationalf/test/test.js
index 2947af7b7642..e83b7f0b633c 100644
--- a/lib/node_modules/@stdlib/math/base/tools/evalrationalf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/evalrationalf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a `factory` method', function test( t ) {
-	t.equal( typeof evalrationalf.factory, 'function', 'has method' );
+	t.strictEqual( typeof evalrationalf.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.factory.js b/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.factory.js
index 3960928c9160..7d66f162ddba 100644
--- a/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.factory.js
+++ b/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.factory.js
@@ -471,13 +471,13 @@ tape( 'the function returns a function which returns `1.0` whenever `n` is `0`',
 	hermitepoly = factory( 0 );
 
 	y = hermitepoly( -1.0 );
-	t.equal( y, 1.0, 'equals 1.0' );
+	t.strictEqual( y, 1.0, 'equals 1.0' );
 
 	y = hermitepoly( 0.0 );
-	t.equal( y, 1.0, 'equals 1.0' );
+	t.strictEqual( y, 1.0, 'equals 1.0' );
 
 	y = hermitepoly( 1.0 );
-	t.equal( y, 1.0, 'equals 1.0' );
+	t.strictEqual( y, 1.0, 'equals 1.0' );
 
 	t.end();
 });
@@ -489,7 +489,7 @@ tape( 'the function returns a function which returns `NaN` whenever `n` is `NaN`
 	hermitepoly = factory( NaN );
 
 	y = hermitepoly( 0.0 );
-	t.equal( isnan( y ), true, 'equals NaN' );
+	t.strictEqual( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
@@ -501,7 +501,7 @@ tape( 'the function returns a function which returns `NaN` when `x` is `NaN`', f
 	hermitepoly = factory( 1 );
 
 	y = hermitepoly( NaN );
-	t.equal( isnan( y ), true, 'equals NaN' );
+	t.strictEqual( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
@@ -513,7 +513,7 @@ tape( 'the function returns a function which returns `NaN` when `n` is a negativ
 	hermitepoly = factory( -1 );
 
 	y = hermitepoly( 0.0 );
-	t.equal( isnan( y ), true, 'equals NaN' );
+	t.strictEqual( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
@@ -525,7 +525,7 @@ tape( 'the function returns a function which returns `NaN` when `n` is not an in
 	hermitepoly = factory( 1.01 );
 
 	y = hermitepoly( 0.0 );
-	t.equal( isnan( y ), true, 'equals NaN' );
+	t.strictEqual( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.js b/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.js
index 1d8c66570a13..b0efa4264e67 100644
--- a/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.js
@@ -421,13 +421,13 @@ tape( 'the function returns `1.0` whenever `n` is `0`', function test( t ) {
 	var y;
 
 	y = hermitepoly( 0, -1.0 );
-	t.equal( y, 1.0, 'equals 1.0' );
+	t.strictEqual( y, 1.0, 'equals 1.0' );
 
 	y = hermitepoly( 0, 0.0 );
-	t.equal( y, 1.0, 'equals 1.0' );
+	t.strictEqual( y, 1.0, 'equals 1.0' );
 
 	y = hermitepoly( 0, 1.0 );
-	t.equal( y, 1.0, 'equals 1.0' );
+	t.strictEqual( y, 1.0, 'equals 1.0' );
 
 	t.end();
 });
@@ -436,7 +436,7 @@ tape( 'the function returns `NaN` whenever `n` is `NaN`', function test( t ) {
 	var y;
 
 	y = hermitepoly( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'equals NaN' );
+	t.strictEqual( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
@@ -445,7 +445,7 @@ tape( 'the function returns `NaN` when `x` is `NaN`', function test( t ) {
 	var y;
 
 	y = hermitepoly( 0, NaN );
-	t.equal( isnan( y ), true, 'equals NaN' );
+	t.strictEqual( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
@@ -454,7 +454,7 @@ tape( 'the function returns `NaN` when `n` is a negative integer`', function tes
 	var y;
 
 	y = hermitepoly( -1, 0.0 );
-	t.equal( isnan( y ), true, 'equals NaN' );
+	t.strictEqual( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
@@ -463,7 +463,7 @@ tape( 'the function returns `NaN` when `n` is not an integer`', function test( t
 	var y;
 
 	y = hermitepoly( 1.01, 0.0 );
-	t.equal( isnan( y ), true, 'equals NaN' );
+	t.strictEqual( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/sum-series/test/test.js b/lib/node_modules/@stdlib/math/base/tools/sum-series/test/test.js
index a7e8dfcbe403..18032d420625 100644
--- a/lib/node_modules/@stdlib/math/base/tools/sum-series/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/sum-series/test/test.js
@@ -140,7 +140,7 @@ tape( 'the function calculates the sum of a user-defined number of terms of the
 		'maxTerms': 3
 	});
 
-	t.equal( actual, expected, 'returned result is equal to expected value. actual: ' + actual + '; expected: ' + expected + '.' );
+	t.strictEqual( actual, expected, 'returned result is equal to expected value. actual: ' + actual + '; expected: ' + expected + '.' );
 	t.end();
 
 	function closure() {
@@ -158,7 +158,7 @@ tape( 'the function calculates the sum of a user-defined number of terms of the
 		'maxTerms': 3
 	});
 
-	t.equal( actual, expected, 'returned result is equal to expected value. actual: ' + actual + '; expected: ' + expected + '.' );
+	t.strictEqual( actual, expected, 'returned result is equal to expected value. actual: ' + actual + '; expected: ' + expected + '.' );
 	t.end();
 
 	function closure() {
diff --git a/lib/node_modules/@stdlib/math/base/tools/test/test.js b/lib/node_modules/@stdlib/math/base/tools/test/test.js
index cc5f14d7e9a5..9edbdb277c0d 100644
--- a/lib/node_modules/@stdlib/math/base/tools/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains base math tools', function test( t ) {
 	var keys = objectKeys( tools );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/utils/absolute-difference/test/test.js b/lib/node_modules/@stdlib/math/base/utils/absolute-difference/test/test.js
index c2cc78b5411c..266609c5e534 100644
--- a/lib/node_modules/@stdlib/math/base/utils/absolute-difference/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/utils/absolute-difference/test/test.js
@@ -40,13 +40,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if both `x` and `y` equal `+infinity`, the function returns `NaN`', function test( t ) {
 	var d = diff( PINF, PINF );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if both `x` and `y` equal `-infinity`, the function returns `NaN`', function test( t ) {
 	var d = diff( NINF, NINF );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -65,10 +65,10 @@ tape( 'if `x` or `y` equals `+infinity` and the other value equals any other num
 
 	for ( i = 0; i < values.length; i++ ) {
 		d = diff( PINF, values[i] );
-		t.equal( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns +infinity' );
 
 		d = diff( values[i], PINF );
-		t.equal( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns +infinity' );
 	}
 	t.end();
 });
@@ -88,10 +88,10 @@ tape( 'if `x` or `y` equals `-infinity` and the other value equals any other num
 
 	for ( i = 0; i < values.length; i++ ) {
 		d = diff( NINF, values[i] );
-		t.equal( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns +infinity' );
 
 		d = diff( values[i], NINF );
-		t.equal( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns +infinity' );
 	}
 	t.end();
 });
@@ -100,13 +100,13 @@ tape( 'if `x` and/or `y` is `NaN`, the function returns `NaN`', function test( t
 	var d;
 
 	d = diff( NaN, 5.0 );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( 3.0, NaN );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( NaN, NaN );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -117,7 +117,7 @@ tape( 'the function computes the absolute difference', function test( t ) {
 	var d;
 
 	d = diff( 2.0, 5.0 );
-	t.equal( d, 3.0, 'returns 3' );
+	t.strictEqual( d, 3.0, 'returns 3' );
 
 	d = diff( -1.0, 3.14 );
 	delta = abs( d - 4.14 );
@@ -130,10 +130,10 @@ tape( 'the function computes the absolute difference', function test( t ) {
 	t.ok( delta <= tol, 'returns ~12.05' );
 
 	d = diff( -0.0, 0.0 );
-	t.equal( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
 
 	d = diff( 0.0, -0.0 );
-	t.equal( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/utils/float64-epsilon-difference/test/test.js b/lib/node_modules/@stdlib/math/base/utils/float64-epsilon-difference/test/test.js
index 40582f0e86ff..e7635c19030b 100644
--- a/lib/node_modules/@stdlib/math/base/utils/float64-epsilon-difference/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/utils/float64-epsilon-difference/test/test.js
@@ -49,13 +49,13 @@ tape( 'the function throws an error if provided an unrecognized/unsupported `sca
 
 tape( 'if both `x` and `y` equal `+infinity`, the function returns `NaN`', function test( t ) {
 	var d = diff( PINF, PINF );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if both `x` and `y` equal `-infinity`, the function returns `NaN`', function test( t ) {
 	var d = diff( NINF, NINF );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -74,10 +74,10 @@ tape( 'if `x` or `y` equals `+infinity` and the other value equals any other num
 
 	for ( i = 0; i < values.length; i++ ) {
 		d = diff( PINF, values[i] );
-		t.equal( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns +infinity' );
 
 		d = diff( values[i], PINF );
-		t.equal( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns +infinity' );
 	}
 	t.end();
 });
@@ -97,10 +97,10 @@ tape( 'if `x` or `y` equals `-infinity` and the other value equals any other num
 
 	for ( i = 0; i < values.length; i++ ) {
 		d = diff( NINF, values[i] );
-		t.equal( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns +infinity' );
 
 		d = diff( values[i], NINF );
-		t.equal( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns +infinity' );
 	}
 	t.end();
 });
@@ -109,10 +109,10 @@ tape( 'if `x` and/or `y` is `NaN`, the function returns `NaN`', function test( t
 	var d;
 
 	d = diff( NaN, 5.0 );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( 3.0, NaN );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'if `x = y` and `x` and `y` are both finite, the function always returns `
 	for ( i = 0; i < values.length; i++ ) {
 		v = values[ i ];
 		d = diff( v, v );
-		t.equal( d, 0.0, 'returns 0' );
+		t.strictEqual( d, 0.0, 'returns 0' );
 	}
 	t.end();
 });
@@ -146,16 +146,16 @@ tape( 'if `x` and `y` both equal `+-0`, the function returns `0`', function test
 	var d;
 
 	d = diff( -0.0, 0.0 );
-	t.equal( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
 
 	d = diff( -0.0, -0.0 );
-	t.equal( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
 
 	d = diff( 0.0, 0.0 );
-	t.equal( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
 
 	d = diff( 0.0, -0.0 );
-	t.equal( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
 
 	t.end();
 });
@@ -164,25 +164,25 @@ tape( 'if a scale function returns `0`, the function returns `NaN`', function te
 	var d;
 
 	d = diff( -1.0, 1.0, 'mean' );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( -1.0, 0.0, 'max' );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( 0.0, 1.0, 'min' );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( 0.0, -1.0, 'min-abs' );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( 0.0, 5.0, 'x' );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( 5.0, 0.0, 'y' );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( 2.0, 5.0, scale );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	t.end();
 
@@ -198,7 +198,7 @@ tape( 'the function computes the relative difference (default)', function test(
 	d = diff( -2.0, 5.0 );
 	expected = (7.0/5.0) / EPS;
 
-	t.equal( d, expected, 'returns '+expected );
+	t.strictEqual( d, expected, 'returns '+expected );
 	t.end();
 });
 
@@ -209,7 +209,7 @@ tape( 'the function computes the relative difference (max-abs)', function test(
 	d = diff( 5.0, -2.0, 'max-abs' );
 	expected = ((5.0+2.0)/5.0) / EPS;
 
-	t.equal( d, expected, 'returns '+expected );
+	t.strictEqual( d, expected, 'returns '+expected );
 	t.end();
 });
 
@@ -220,7 +220,7 @@ tape( 'the function computes the relative difference (max)', function test( t )
 	d = diff( 1.0, 10.0, 'max' );
 	expected = (9.0/10.0) / EPS;
 
-	t.equal( d, expected, 'returns '+expected );
+	t.strictEqual( d, expected, 'returns '+expected );
 	t.end();
 });
 
@@ -231,7 +231,7 @@ tape( 'the function computes the relative difference (min-abs)', function test(
 	d = diff( -1.0, 10.0, 'min-abs' );
 	expected = 11.0 / EPS;
 
-	t.equal( d, expected, 'returns '+expected );
+	t.strictEqual( d, expected, 'returns '+expected );
 	t.end();
 });
 
@@ -242,7 +242,7 @@ tape( 'the function computes the relative difference (min)', function test( t )
 	d = diff( 1.0, 10.0, 'min' );
 	expected = 9.0 / EPS;
 
-	t.equal( d, expected, 'returns '+expected );
+	t.strictEqual( d, expected, 'returns '+expected );
 	t.end();
 });
 
@@ -253,7 +253,7 @@ tape( 'the function computes the relative difference (x)', function test( t ) {
 	d = diff( 10.0, -1.0, 'x' );
 	expected = (11.0/10.0) / EPS;
 
-	t.equal( d, expected, 'returns '+expected );
+	t.strictEqual( d, expected, 'returns '+expected );
 	t.end();
 });
 
@@ -264,7 +264,7 @@ tape( 'the function computes the relative difference (y)', function test( t ) {
 	d = diff( 10.0, -1.0, 'y' );
 	expected = 11.0 / EPS;
 
-	t.equal( d, expected, 'returns '+expected );
+	t.strictEqual( d, expected, 'returns '+expected );
 	t.end();
 });
 
@@ -275,7 +275,7 @@ tape( 'the function computes the relative difference (mean)', function test( t )
 	d = diff( -1.0, 10.0, 'mean' );
 	expected = (11.0/4.5) / EPS;
 
-	t.equal( d, expected, 'returns '+expected );
+	t.strictEqual( d, expected, 'returns '+expected );
 	t.end();
 });
 
@@ -286,7 +286,7 @@ tape( 'the function computes the relative difference (mean-abs)', function test(
 	d = diff( 10.0, -1.0, 'mean-abs' );
 	expected = (11.0/5.5) / EPS;
 
-	t.equal( d, expected, 'returns '+expected );
+	t.strictEqual( d, expected, 'returns '+expected );
 	t.end();
 });
 
@@ -297,7 +297,7 @@ tape( 'the function supports custom scale functions', function test( t ) {
 	d = diff( 12.15, 12.149999999999999, scale );
 	expected = ((12.15-12.149999999999999)/12.15) / EPS;
 
-	t.equal( d, expected, 'returns '+expected );
+	t.strictEqual( d, expected, 'returns '+expected );
 	t.end();
 
 	function scale( x, y ) {
@@ -307,7 +307,7 @@ tape( 'the function supports custom scale functions', function test( t ) {
 
 tape( 'if computing the relative difference will result in overflow, the function returns the maximum double-precision floating-point number', function test( t ) {
 	var d = diff( 1.0e304, 1.0, 'min' );
-	t.equal( 1.0e304/EPS, PINF, 'conversion will result in overflow' );
-	t.equal( d, MAX_FLOAT64, 'returns '+MAX_FLOAT64 );
+	t.strictEqual( 1.0e304/EPS, PINF, 'conversion will result in overflow' );
+	t.strictEqual( d, MAX_FLOAT64, 'returns '+MAX_FLOAT64 );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/utils/relative-difference/test/test.js b/lib/node_modules/@stdlib/math/base/utils/relative-difference/test/test.js
index 41971e83de1c..b68e1295bcc9 100644
--- a/lib/node_modules/@stdlib/math/base/utils/relative-difference/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/utils/relative-difference/test/test.js
@@ -49,13 +49,13 @@ tape( 'the function throws an error if provided an unrecognized/unsupported `sca
 
 tape( 'if both `x` and `y` equal `+infinity`, the function returns `NaN`', function test( t ) {
 	var d = diff( PINF, PINF );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if both `x` and `y` equal `-infinity`, the function returns `NaN`', function test( t ) {
 	var d = diff( NINF, NINF );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -74,10 +74,10 @@ tape( 'if `x` or `y` equals `+infinity` and the other value equals any other num
 
 	for ( i = 0; i < values.length; i++ ) {
 		d = diff( PINF, values[i] );
-		t.equal( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns +infinity' );
 
 		d = diff( values[i], PINF );
-		t.equal( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns +infinity' );
 	}
 	t.end();
 });
@@ -97,10 +97,10 @@ tape( 'if `x` or `y` equals `-infinity` and the other value equals any other num
 
 	for ( i = 0; i < values.length; i++ ) {
 		d = diff( NINF, values[i] );
-		t.equal( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns +infinity' );
 
 		d = diff( values[i], NINF );
-		t.equal( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns +infinity' );
 	}
 	t.end();
 });
@@ -109,10 +109,10 @@ tape( 'if `x` and/or `y` is `NaN`, the function returns `NaN`', function test( t
 	var d;
 
 	d = diff( NaN, 5.0 );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( 3.0, NaN );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'if `x = y` and `x` and `y` are both finite, the function always returns `
 	for ( i = 0; i < values.length; i++ ) {
 		v = values[ i ];
 		d = diff( v, v );
-		t.equal( d, 0.0, 'returns 0' );
+		t.strictEqual( d, 0.0, 'returns 0' );
 	}
 	t.end();
 });
@@ -146,16 +146,16 @@ tape( 'if `x` and `y` both equal `+-0`, the function returns `0`', function test
 	var d;
 
 	d = diff( -0.0, 0.0 );
-	t.equal( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
 
 	d = diff( -0.0, -0.0 );
-	t.equal( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
 
 	d = diff( 0.0, 0.0 );
-	t.equal( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
 
 	d = diff( 0.0, -0.0 );
-	t.equal( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
 
 	t.end();
 });
@@ -164,25 +164,25 @@ tape( 'if a scale function returns `0`, the function returns `NaN`', function te
 	var d;
 
 	d = diff( -1.0, 1.0, 'mean' );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( -1.0, 0.0, 'max' );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( 0.0, 1.0, 'min' );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( 0.0, -1.0, 'min-abs' );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( 0.0, 5.0, 'x' );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( 5.0, 0.0, 'y' );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	d = diff( 2.0, 5.0, scale );
-	t.equal( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns NaN' );
 
 	t.end();
 
@@ -195,10 +195,10 @@ tape( 'the function computes the relative difference (default)', function test(
 	var d;
 
 	d = diff( -2.0, 5.0 );
-	t.equal( d, 1.4, 'returns 1.4' );
+	t.strictEqual( d, 1.4, 'returns 1.4' );
 
 	d = diff( 5.0, -2.0 );
-	t.equal( d, 1.4, 'returns 1.4' );
+	t.strictEqual( d, 1.4, 'returns 1.4' );
 
 	t.end();
 });
@@ -207,10 +207,10 @@ tape( 'the function computes the relative difference (max-abs)', function test(
 	var d;
 
 	d = diff( -2.0, 5.0, 'max-abs' );
-	t.equal( d, 1.4, 'returns 1.4' );
+	t.strictEqual( d, 1.4, 'returns 1.4' );
 
 	d = diff( 5.0, -2.0, 'max-abs' );
-	t.equal( d, 1.4, 'returns 1.4' );
+	t.strictEqual( d, 1.4, 'returns 1.4' );
 
 	t.end();
 });
@@ -219,16 +219,16 @@ tape( 'the function computes the relative difference (max)', function test( t )
 	var d;
 
 	d = diff( 1.0, 10.0, 'max' );
-	t.equal( d, 0.9, 'returns 0.9' );
+	t.strictEqual( d, 0.9, 'returns 0.9' );
 
 	d = diff( 10.0, 1.0, 'max' );
-	t.equal( d, 0.9, 'returns 0.9' );
+	t.strictEqual( d, 0.9, 'returns 0.9' );
 
 	d = diff( -1.0, -10.0, 'max' );
-	t.equal( d, 9.0, 'returns 9' );
+	t.strictEqual( d, 9.0, 'returns 9' );
 
 	d = diff( -10.0, -1.0, 'max' );
-	t.equal( d, 9.0, 'returns 9' );
+	t.strictEqual( d, 9.0, 'returns 9' );
 
 	t.end();
 });
@@ -237,16 +237,16 @@ tape( 'the function computes the relative difference (min-abs)', function test(
 	var d;
 
 	d = diff( 1.0, 10.0, 'min-abs' );
-	t.equal( d, 9.0, 'returns 9' );
+	t.strictEqual( d, 9.0, 'returns 9' );
 
 	d = diff( 10.0, 1.0, 'min-abs' );
-	t.equal( d, 9.0, 'returns 9' );
+	t.strictEqual( d, 9.0, 'returns 9' );
 
 	d = diff( -1.0, 10.0, 'min-abs' );
-	t.equal( d, 11.0, 'returns 11' );
+	t.strictEqual( d, 11.0, 'returns 11' );
 
 	d = diff( 10.0, -1.0, 'min-abs' );
-	t.equal( d, 11.0, 'returns 11' );
+	t.strictEqual( d, 11.0, 'returns 11' );
 
 	t.end();
 });
@@ -255,16 +255,16 @@ tape( 'the function computes the relative difference (min)', function test( t )
 	var d;
 
 	d = diff( 1.0, 10.0, 'min' );
-	t.equal( d, 9.0, 'returns 9' );
+	t.strictEqual( d, 9.0, 'returns 9' );
 
 	d = diff( 10.0, 1.0, 'min' );
-	t.equal( d, 9.0, 'returns 9' );
+	t.strictEqual( d, 9.0, 'returns 9' );
 
 	d = diff( -1.0, 10.0, 'min' );
-	t.equal( d, 11.0, 'returns 11' );
+	t.strictEqual( d, 11.0, 'returns 11' );
 
 	d = diff( 10.0, -1.0, 'min' );
-	t.equal( d, 11.0, 'returns 11' );
+	t.strictEqual( d, 11.0, 'returns 11' );
 
 	t.end();
 });
@@ -273,16 +273,16 @@ tape( 'the function computes the relative difference (x)', function test( t ) {
 	var d;
 
 	d = diff( 1.0, 10.0, 'x' );
-	t.equal( d, 9.0, 'returns 9' );
+	t.strictEqual( d, 9.0, 'returns 9' );
 
 	d = diff( 10.0, 1.0, 'x' );
-	t.equal( d, 0.9, 'returns 0.9' );
+	t.strictEqual( d, 0.9, 'returns 0.9' );
 
 	d = diff( -1.0, 10.0, 'x' );
-	t.equal( d, 11, 'returns 11' );
+	t.strictEqual( d, 11, 'returns 11' );
 
 	d = diff( 10.0, -1.0, 'x' );
-	t.equal( d, 1.1, 'returns 1.1' );
+	t.strictEqual( d, 1.1, 'returns 1.1' );
 
 	t.end();
 });
@@ -291,16 +291,16 @@ tape( 'the function computes the relative difference (y)', function test( t ) {
 	var d;
 
 	d = diff( 1.0, 10.0, 'y' );
-	t.equal( d, 0.9, 'returns 0.9' );
+	t.strictEqual( d, 0.9, 'returns 0.9' );
 
 	d = diff( 10.0, 1.0, 'y' );
-	t.equal( d, 9.0, 'returns 9' );
+	t.strictEqual( d, 9.0, 'returns 9' );
 
 	d = diff( -1.0, 10.0, 'y' );
-	t.equal( d, 1.1, 'returns 1.1' );
+	t.strictEqual( d, 1.1, 'returns 1.1' );
 
 	d = diff( 10.0, -1.0, 'y' );
-	t.equal( d, 11.0, 'returns 11' );
+	t.strictEqual( d, 11.0, 'returns 11' );
 
 	t.end();
 });
@@ -309,16 +309,16 @@ tape( 'the function computes the relative difference (mean)', function test( t )
 	var d;
 
 	d = diff( 1.0, 10.0, 'mean' );
-	t.equal( d, 9.0/5.5, 'returns 9/5.5' );
+	t.strictEqual( d, 9.0/5.5, 'returns 9/5.5' );
 
 	d = diff( 10.0, 1.0, 'mean' );
-	t.equal( d, 9.0/5.5, 'returns 9/5.5' );
+	t.strictEqual( d, 9.0/5.5, 'returns 9/5.5' );
 
 	d = diff( -1.0, 10.0, 'mean' );
-	t.equal( d, 11.0/4.5, 'returns 11/4.5' );
+	t.strictEqual( d, 11.0/4.5, 'returns 11/4.5' );
 
 	d = diff( 10.0, -1.0, 'mean' );
-	t.equal( d, 11.0/4.5, 'returns 11/4.5' );
+	t.strictEqual( d, 11.0/4.5, 'returns 11/4.5' );
 
 	t.end();
 });
@@ -327,16 +327,16 @@ tape( 'the function computes the relative difference (mean-abs)', function test(
 	var d;
 
 	d = diff( 1.0, 10.0, 'mean-abs' );
-	t.equal( d, 9.0/5.5, 'returns 9/5.5' );
+	t.strictEqual( d, 9.0/5.5, 'returns 9/5.5' );
 
 	d = diff( 10.0, 1.0, 'mean-abs' );
-	t.equal( d, 9.0/5.5, 'returns 9/5.5' );
+	t.strictEqual( d, 9.0/5.5, 'returns 9/5.5' );
 
 	d = diff( -1.0, 10.0, 'mean-abs' );
-	t.equal( d, 11.0/5.5, 'returns 11/5.5' );
+	t.strictEqual( d, 11.0/5.5, 'returns 11/5.5' );
 
 	d = diff( 10.0, -1.0, 'mean-abs' );
-	t.equal( d, 11.0/5.5, 'returns 11/5.5' );
+	t.strictEqual( d, 11.0/5.5, 'returns 11/5.5' );
 
 	t.end();
 });
@@ -349,7 +349,7 @@ tape( 'the function supports custom scale functions', function test( t ) {
 
 	expected = ((12.15-12.149999999999999)/12.15) / EPS;
 
-	t.equal( d, expected, 'returns '+expected );
+	t.strictEqual( d, expected, 'returns '+expected );
 	t.end();
 
 	function scale( x, y ) {
diff --git a/lib/node_modules/@stdlib/math/base/utils/test/test.js b/lib/node_modules/@stdlib/math/base/utils/test/test.js
index d33d207dd833..61ccace6bee3 100644
--- a/lib/node_modules/@stdlib/math/base/utils/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/utils/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains base math utilities', function test( t ) {
 	var keys = objectKeys( utils );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/ops/add/test/test.js b/lib/node_modules/@stdlib/math/iter/ops/add/test/test.js
index 1240017dabcd..853f218e7822 100644
--- a/lib/node_modules/@stdlib/math/iter/ops/add/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/ops/add/test/test.js
@@ -162,12 +162,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterAdd( randu(), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -178,12 +178,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalars)', fu
 	var i;
 
 	it = iterAdd( 4.0, 4.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -213,7 +213,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -248,7 +248,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( array2iterator( values1 ), scalar );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -283,7 +283,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( scalar, array2iterator( values1 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -318,7 +318,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -353,7 +353,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -390,7 +390,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -427,7 +427,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( array2iterator( values1 ), scalar1, scalar2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -464,7 +464,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( scalar1, array2iterator( values1 ), scalar2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -501,7 +501,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( scalar1, scalar2, array2iterator( values1 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -538,7 +538,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -575,7 +575,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -612,7 +612,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -640,7 +640,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -661,7 +661,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterAdd( iterEmpty(), iterEmpty(), iterEmpty(), iterEmpty() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -695,16 +695,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAdd( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -734,16 +734,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAdd( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -755,20 +755,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAdd( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -780,20 +780,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAdd( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -822,16 +822,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	rand2[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterAdd( rand1, rand2 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -851,16 +851,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	});
 
 	it1 = iterAdd( 4.0, 3.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -874,7 +874,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterAdd( randu(), randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -892,7 +892,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterAdd( rand, rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/ops/divide/test/test.js b/lib/node_modules/@stdlib/math/iter/ops/divide/test/test.js
index 7c096eba6fb1..5e8c9fc1a73d 100644
--- a/lib/node_modules/@stdlib/math/iter/ops/divide/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/ops/divide/test/test.js
@@ -162,12 +162,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterDivide( randu(), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -178,12 +178,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalars)', fu
 	var i;
 
 	it = iterDivide( 4.0, 4.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -213,7 +213,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -248,7 +248,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( array2iterator( values1 ), scalar );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -283,7 +283,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( scalar, array2iterator( values1 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -318,7 +318,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -353,7 +353,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -390,7 +390,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -427,7 +427,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( array2iterator( values1 ), scalar1, scalar2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -464,7 +464,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( scalar1, array2iterator( values1 ), scalar2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -501,7 +501,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( scalar1, scalar2, array2iterator( values1 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -538,7 +538,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -575,7 +575,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -612,7 +612,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -640,7 +640,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -661,7 +661,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterDivide( iterEmpty(), iterEmpty(), iterEmpty(), iterEmpty() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -695,16 +695,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterDivide( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -734,16 +734,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterDivide( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -769,16 +769,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterDivide( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -804,16 +804,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterDivide( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -825,20 +825,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDivide( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -850,20 +850,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDivide( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -892,16 +892,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	rand2[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterDivide( rand1, rand2 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -921,16 +921,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	});
 
 	it1 = iterDivide( 4.0, 3.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -944,7 +944,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterDivide( randu(), randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -962,7 +962,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterDivide( rand, rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/ops/mod/test/test.js b/lib/node_modules/@stdlib/math/iter/ops/mod/test/test.js
index f3a21b11b1a9..4a0934ef124d 100644
--- a/lib/node_modules/@stdlib/math/iter/ops/mod/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/ops/mod/test/test.js
@@ -162,12 +162,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterMod( randu(), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -178,12 +178,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalars)', fu
 	var i;
 
 	it = iterMod( 4.0, 3.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -213,7 +213,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -248,7 +248,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( array2iterator( values1 ), scalar );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -283,7 +283,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( scalar, array2iterator( values1 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -318,7 +318,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -353,7 +353,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -390,7 +390,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -427,7 +427,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( array2iterator( values1 ), scalar1, scalar2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -464,7 +464,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( scalar1, array2iterator( values1 ), scalar2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -501,7 +501,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( scalar1, scalar2, array2iterator( values1 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -538,7 +538,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -575,7 +575,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -612,7 +612,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -640,7 +640,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -661,7 +661,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMod( iterEmpty(), iterEmpty(), iterEmpty(), iterEmpty() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -695,16 +695,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterMod( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -734,16 +734,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterMod( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -769,16 +769,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterMod( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -804,16 +804,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterMod( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -825,20 +825,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMod( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -850,20 +850,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMod( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -892,16 +892,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	rand2[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterMod( rand1, rand2 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -921,16 +921,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	});
 
 	it1 = iterMod( 4.0, 3.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -944,7 +944,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterMod( randu(), randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -962,7 +962,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterMod( rand, rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/ops/multiply/test/test.js b/lib/node_modules/@stdlib/math/iter/ops/multiply/test/test.js
index a2af5edb4293..80cc9866525c 100644
--- a/lib/node_modules/@stdlib/math/iter/ops/multiply/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/ops/multiply/test/test.js
@@ -162,12 +162,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterMultiply( randu(), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -178,12 +178,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalars)', fu
 	var i;
 
 	it = iterMultiply( 4.0, 4.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -213,7 +213,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -248,7 +248,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( array2iterator( values1 ), scalar );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -283,7 +283,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( scalar, array2iterator( values1 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -318,7 +318,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -353,7 +353,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -390,7 +390,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -427,7 +427,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( array2iterator( values1 ), scalar1, scalar2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -464,7 +464,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( scalar1, array2iterator( values1 ), scalar2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -501,7 +501,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( scalar1, scalar2, array2iterator( values1 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -538,7 +538,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -575,7 +575,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -612,7 +612,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -640,7 +640,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -661,7 +661,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterMultiply( iterEmpty(), iterEmpty(), iterEmpty(), iterEmpty() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -695,16 +695,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterMultiply( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -734,16 +734,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterMultiply( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -755,20 +755,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMultiply( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -780,20 +780,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMultiply( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -822,16 +822,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	rand2[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterMultiply( rand1, rand2 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -851,16 +851,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	});
 
 	it1 = iterMultiply( 4.0, 3.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -874,7 +874,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterMultiply( randu(), randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -892,7 +892,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterMultiply( rand, rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/ops/subtract/test/test.js b/lib/node_modules/@stdlib/math/iter/ops/subtract/test/test.js
index 5bb0e7d3db4f..cdd3efd9d88d 100644
--- a/lib/node_modules/@stdlib/math/iter/ops/subtract/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/ops/subtract/test/test.js
@@ -162,12 +162,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterSubtract( randu(), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -178,12 +178,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalars)', fu
 	var i;
 
 	it = iterSubtract( 4.0, 4.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -213,7 +213,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -248,7 +248,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( array2iterator( values1 ), scalar );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -283,7 +283,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( scalar, array2iterator( values1 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -318,7 +318,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -353,7 +353,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -390,7 +390,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -427,7 +427,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( array2iterator( values1 ), scalar1, scalar2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -464,7 +464,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( scalar1, array2iterator( values1 ), scalar2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -501,7 +501,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( scalar1, scalar2, array2iterator( values1 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -538,7 +538,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -575,7 +575,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -612,7 +612,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -640,7 +640,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -661,7 +661,7 @@ tape( 'the function returns an iterator protocol-compliant object which performs
 	];
 
 	it = iterSubtract( iterEmpty(), iterEmpty(), iterEmpty(), iterEmpty() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -695,16 +695,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSubtract( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -734,16 +734,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSubtract( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -769,16 +769,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSubtract( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -804,16 +804,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSubtract( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -825,20 +825,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSubtract( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -850,20 +850,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSubtract( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -892,16 +892,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	rand2[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterSubtract( rand1, rand2 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -921,16 +921,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	});
 
 	it1 = iterSubtract( 4.0, 3.0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -944,7 +944,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterSubtract( randu(), randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -962,7 +962,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterSubtract( rand, rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/ops/test/test.js b/lib/node_modules/@stdlib/math/iter/ops/test/test.js
index 630b5b5a6ff7..76eceb93c544 100644
--- a/lib/node_modules/@stdlib/math/iter/ops/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/ops/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/composites/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/composites/test/test.js
index 532ee2246c8a..fae487de1b9a 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/composites/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/composites/test/test.js
@@ -101,12 +101,12 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterCompositesSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1e4; i++ ) {
 		actual = it.next();
-		t.equal( isComposite( actual.value ), true, 'returns a composite number' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( isComposite( actual.value ), true, 'returns a composite number' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -148,7 +148,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterCompositesSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -167,20 +167,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCompositesSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -192,20 +192,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCompositesSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,16 +221,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterCompositesSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -244,7 +244,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterCompositesSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/continued-fraction/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/continued-fraction/test/test.js
index 658f32ed8751..4340d5b61e56 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/continued-fraction/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/continued-fraction/test/test.js
@@ -183,7 +183,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( PI );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	// Reference: https://oeis.org/A001203
 	expected = [ 3, 7, 15, 1, 292, 1, 1, 1, 2, 1, 3, 1, 14, 3 ]; // canonical form
@@ -191,11 +191,11 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -210,7 +210,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	it = iterContinuedFractionSeq( PI, {
 		'returns': 'terms'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	// Reference: https://oeis.org/A001203
 	expected = [ 3, 7, 15, 1, 292, 1, 1, 1, 2, 1, 3, 1, 14, 3 ]; // canonical form
@@ -218,11 +218,11 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -241,7 +241,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	it = iterContinuedFractionSeq( PI, {
 		'returns': 'convergents'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	// Reference: https://oeis.org/A001203
 	terms = [ 3, 7, 15, 1, 292, 1, 1, 1, 2, 1, 3, 1, 14, 3 ]; // canonical form
@@ -252,16 +252,16 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 			v = actual.value;
 			expected = evaluate( terms.slice( 0, i+1 ) );
 			if ( v === expected || i === terms.length-1 ) {
-				t.equal( v, expected, 'returns expected value' );
+				t.strictEqual( v, expected, 'returns expected value' );
 			} else {
 				delta = abs( v - expected );
 				tol = 1.3 * EPS * abs( expected );
-				t.equal( delta <= tol, true, 'i: '+i+'. actual: '+v+'. expected: '+expected+'. delta: '+delta+'. tol: '+tol+'.' );
+				t.strictEqual( delta <= tol, true, 'i: '+i+'. actual: '+v+'. expected: '+expected+'. delta: '+delta+'. tol: '+tol+'.' );
 			}
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -280,7 +280,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	it = iterContinuedFractionSeq( -PI, {
 		'returns': 'convergents'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	terms = [ -3, -7, -15, -1, -292, -1, -1, -1, -2, -1, -3, -1, -14, -3 ]; // canonical form
 
@@ -290,16 +290,16 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 			v = actual.value;
 			expected = evaluate( terms.slice( 0, i+1 ) );
 			if ( v === expected || i === terms.length-1 ) {
-				t.equal( v, expected, 'returns expected value' );
+				t.strictEqual( v, expected, 'returns expected value' );
 			} else {
 				delta = abs( v - expected );
 				tol = 1.3 * EPS * abs( expected );
-				t.equal( delta <= tol, true, 'i: '+i+'. actual: '+v+'. expected: '+expected+'. delta: '+delta+'. tol: '+tol+'.' );
+				t.strictEqual( delta <= tol, true, 'i: '+i+'. actual: '+v+'. expected: '+expected+'. delta: '+delta+'. tol: '+tol+'.' );
 			}
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -318,7 +318,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	it = iterContinuedFractionSeq( PI, {
 		'returns': '*'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	// Reference: https://oeis.org/A001203
 	terms = [ 3, 7, 15, 1, 292, 1, 1, 1, 2, 1, 3, 1, 14, 3 ]; // canonical form
@@ -328,22 +328,22 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 		if ( i < terms.length ) {
 			v = actual.value;
 
-			t.equal( isArray( v ), true, 'returns expected value' );
-			t.equal( v.length, 2, 'returns expected value' );
-			t.equal( v[ 0 ], terms[ i ], 'returns expected value' );
+			t.strictEqual( isArray( v ), true, 'returns expected value' );
+			t.strictEqual( v.length, 2, 'returns expected value' );
+			t.strictEqual( v[ 0 ], terms[ i ], 'returns expected value' );
 
 			expected = evaluate( terms.slice( 0, i+1 ) );
 			if ( v[ 1 ] === expected || i === terms.length-1 ) {
-				t.equal( v[ 1 ], expected, 'returns expected value' );
+				t.strictEqual( v[ 1 ], expected, 'returns expected value' );
 			} else {
 				delta = abs( v[ 1 ] - expected );
 				tol = 1.3 * EPS * abs( expected );
-				t.equal( delta <= tol, true, 'i: '+i+'. actual: '+v[ 1 ]+'. expected: '+expected+'. delta: '+delta+'. tol: '+tol+'.' );
+				t.strictEqual( delta <= tol, true, 'i: '+i+'. actual: '+v[ 1 ]+'. expected: '+expected+'. delta: '+delta+'. tol: '+tol+'.' );
 			}
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -362,7 +362,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	it = iterContinuedFractionSeq( -PI, {
 		'returns': '*'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	// Reference: https://oeis.org/A001203
 	terms = [ -3, -7, -15, -1, -292, -1, -1, -1, -2, -1, -3, -1, -14, -3 ]; // canonical form
@@ -372,22 +372,22 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 		if ( i < terms.length ) {
 			v = actual.value;
 
-			t.equal( isArray( v ), true, 'returns expected value' );
-			t.equal( v.length, 2, 'returns expected value' );
-			t.equal( v[ 0 ], terms[ i ], 'returns expected value' );
+			t.strictEqual( isArray( v ), true, 'returns expected value' );
+			t.strictEqual( v.length, 2, 'returns expected value' );
+			t.strictEqual( v[ 0 ], terms[ i ], 'returns expected value' );
 
 			expected = evaluate( terms.slice( 0, i+1 ) );
 			if ( v[ 1 ] === expected || i === terms.length-1 ) {
-				t.equal( v[ 1 ], expected, 'returns expected value' );
+				t.strictEqual( v[ 1 ], expected, 'returns expected value' );
 			} else {
 				delta = abs( v[ 1 ] - expected );
 				tol = 1.3 * EPS * abs( expected );
-				t.equal( delta <= tol, true, 'i: '+i+'. actual: '+v[ 1 ]+'. expected: '+expected+'. delta: '+delta+'. tol: '+tol+'.' );
+				t.strictEqual( delta <= tol, true, 'i: '+i+'. actual: '+v[ 1 ]+'. expected: '+expected+'. delta: '+delta+'. tol: '+tol+'.' );
 			}
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -400,18 +400,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ 3 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -424,18 +424,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( -3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ -3 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -448,18 +448,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( 0.1 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ 0, 10 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -472,18 +472,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( 0.85 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ 0, 1, 5, 1, 2 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -496,18 +496,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( 0.15 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ 0, 6, 1, 2 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -520,18 +520,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( -0.1 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ 0, -10 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -544,18 +544,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( -0.85 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ 0, -1, -5, -1, -2 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -568,18 +568,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( -0.15 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ 0, -6, -1, -2 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -592,18 +592,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( 1.0e-308 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ 0, 1.0e308 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -616,18 +616,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( -1.0e-308 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ 0, -1.0e308 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -640,18 +640,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( 1.0e308 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ 1.0e308 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -664,18 +664,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( -1.0e308 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ -1.0e308 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -688,18 +688,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( 12.3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ 12, 3, 3 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -712,18 +712,18 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( -12.3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ -12, -3, -3 ];
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
 		if ( i < expected.length ) {
-			t.equal( actual.value, expected[ i ], 'returns expected value' );
-			t.equal( actual.done, false, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual.done, false, 'returns expected value' );
 		} else {
-			t.equal( actual.value, void 0, 'returns expected value' );
-			t.equal( actual.done, true, 'returns expected value' );
+			t.strictEqual( actual.value, void 0, 'returns expected value' );
+			t.strictEqual( actual.done, true, 'returns expected value' );
 		}
 	}
 	t.end();
@@ -736,7 +736,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterContinuedFractionSeq( 3.245 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [
 		{
@@ -779,7 +779,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 		'iter': 20
 	};
 	it = iterContinuedFractionSeq( 3.245, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [
 		{
@@ -832,7 +832,7 @@ tape( 'the function supports limiting the number of iterations (1)', function te
 		'iter': 1
 	};
 	it = iterContinuedFractionSeq( PI, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -869,7 +869,7 @@ tape( 'the function supports limiting the number of iterations (2)', function te
 		'iter': 2
 	};
 	it = iterContinuedFractionSeq( PI, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -910,7 +910,7 @@ tape( 'the function supports limiting the number of iterations (3)', function te
 		'iter': 3
 	};
 	it = iterContinuedFractionSeq( PI, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -951,7 +951,7 @@ tape( 'the function supports limiting the number of iterations (3; negative)', f
 		'iter': 3
 	};
 	it = iterContinuedFractionSeq( -PI, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -996,7 +996,7 @@ tape( 'the function supports limiting the number of iterations (4)', function te
 		'iter': 4
 	};
 	it = iterContinuedFractionSeq( PI, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -1045,7 +1045,7 @@ tape( 'the function supports limiting the number of iterations (5)', function te
 		'iter': 5
 	};
 	it = iterContinuedFractionSeq( PI, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -1098,7 +1098,7 @@ tape( 'the function supports limiting the number of iterations (6)', function te
 		'iter': 6
 	};
 	it = iterContinuedFractionSeq( PI, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -1155,7 +1155,7 @@ tape( 'the function supports limiting the number of iterations (7)', function te
 		'iter': 7
 	};
 	it = iterContinuedFractionSeq( PI, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -1216,7 +1216,7 @@ tape( 'the function supports limiting the number of iterations (8)', function te
 		'iter': 8
 	};
 	it = iterContinuedFractionSeq( PI, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -1281,7 +1281,7 @@ tape( 'the function supports limiting the number of iterations (9)', function te
 		'iter': 9
 	};
 	it = iterContinuedFractionSeq( PI, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -1350,7 +1350,7 @@ tape( 'the function supports limiting the number of iterations (10)', function t
 		'iter': 10
 	};
 	it = iterContinuedFractionSeq( PI, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -1392,7 +1392,7 @@ tape( 'the function supports specifying a tolerance', function test( t ) {
 		'tol': 1.0e-7
 	};
 	it = iterContinuedFractionSeq( PI, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < 100; i++ ) {
@@ -1413,20 +1413,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterContinuedFractionSeq( PI );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -1438,20 +1438,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterContinuedFractionSeq( PI );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -1467,16 +1467,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterContinuedFractionSeq( PI );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -1490,7 +1490,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterContinuedFractionSeq( PI );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/cubes/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/cubes/test/test.js
index e02b66054b8b..16f4e44fca3c 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/cubes/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/cubes/test/test.js
@@ -102,14 +102,14 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterCubesSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = i * i * i;
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isCubeNumber( actual.value ), true, 'returns a cube number' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isCubeNumber( actual.value ), true, 'returns a cube number' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -151,7 +151,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterCubesSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -170,20 +170,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCubesSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -195,20 +195,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCubesSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -224,16 +224,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterCubesSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterCubesSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.js
index 92b258ed635c..1ede6e8fecec 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.js
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var j;
 
 	it = iterEvenIntegersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	j = 0;
 	for ( i = 0; i < 1000; i++ ) {
@@ -117,10 +117,10 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 			j += 2;
 			expected = j;
 		}
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isInteger( actual.value ), true, 'returns an integer' );
-		t.equal( isEven( actual.value ), true, 'returns an even integer' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isInteger( actual.value ), true, 'returns an integer' );
+		t.strictEqual( isEven( actual.value ), true, 'returns an even integer' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -162,7 +162,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterEvenIntegersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -181,20 +181,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterEvenIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -206,20 +206,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterEvenIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -235,16 +235,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterEvenIntegersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -258,7 +258,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterEvenIntegersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/factorials/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/factorials/test/test.js
index 09ef9f49a26c..35dfa6f2a362 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/factorials/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/factorials/test/test.js
@@ -102,13 +102,13 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterFactorialsSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = factorial( i );
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -150,7 +150,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterFactorialsSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFactorialsSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFactorialsSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -223,16 +223,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterFactorialsSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterFactorialsSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/fibonacci/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/fibonacci/test/test.js
index 9766cd779d68..8df7da99e449 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/fibonacci/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/fibonacci/test/test.js
@@ -102,17 +102,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterFibonacciSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 79; i++ ) {
 		actual = it.next();
 		expected = fibonacci( i );
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 	t.end();
 });
 
@@ -149,7 +149,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterFibonacciSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -168,20 +168,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFibonacciSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,20 +193,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFibonacciSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -222,16 +222,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterFibonacciSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterFibonacciSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/fifth-powers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/fifth-powers/test/test.js
index a0f0e85acef0..c396c3770a25 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/fifth-powers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/fifth-powers/test/test.js
@@ -101,13 +101,13 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterFifthPowersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = i * i * i * i * i;
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterFifthPowersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -168,20 +168,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFifthPowersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,20 +193,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFifthPowersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -222,16 +222,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterFifthPowersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterFifthPowersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/fourth-powers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/fourth-powers/test/test.js
index 0599c20b0bd9..d5c01c16fbdd 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/fourth-powers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/fourth-powers/test/test.js
@@ -101,13 +101,13 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterFourthPowersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = i * i * i * i;
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterFourthPowersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -168,20 +168,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFourthPowersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,20 +193,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFourthPowersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -222,16 +222,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterFourthPowersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterFourthPowersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.js
index 9890ef23316b..80704872f16b 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.js
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var j;
 
 	it = iterIntegersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	j = 0;
 	for ( i = 0; i < 1000; i++ ) {
@@ -117,9 +117,9 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 			j += 1;
 			expected = j;
 		}
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isInteger( actual.value ), true, 'returns an integer' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isInteger( actual.value ), true, 'returns an integer' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -161,7 +161,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterIntegersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -180,20 +180,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -205,20 +205,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -234,16 +234,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterIntegersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -257,7 +257,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterIntegersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/lucas/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/lucas/test/test.js
index 09169230f056..8531829c1677 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/lucas/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/lucas/test/test.js
@@ -102,17 +102,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterLucasSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 77; i++ ) {
 		actual = it.next();
 		expected = lucas( i );
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 	t.end();
 });
 
@@ -149,7 +149,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterLucasSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -168,20 +168,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLucasSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,20 +193,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLucasSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -222,16 +222,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterLucasSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterLucasSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negafibonacci/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/negafibonacci/test/test.js
index 1548d0418eda..3dbad38c1864 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negafibonacci/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negafibonacci/test/test.js
@@ -102,17 +102,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterNegaFibonacciSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 79; i++ ) {
 		actual = it.next();
 		expected = negafibonacci( -i );
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 	t.end();
 });
 
@@ -149,7 +149,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterNegaFibonacciSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -168,20 +168,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNegaFibonacciSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,20 +193,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNegaFibonacciSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -222,16 +222,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterNegaFibonacciSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterNegaFibonacciSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negalucas/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/negalucas/test/test.js
index f433ffa3b511..2cab5db12ca2 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negalucas/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negalucas/test/test.js
@@ -102,17 +102,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterNegaLucasSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 77; i++ ) {
 		actual = it.next();
 		expected = negalucas( -i );
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 	t.end();
 });
 
@@ -149,7 +149,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterNegaLucasSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -168,20 +168,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNegaLucasSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,20 +193,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNegaLucasSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -222,16 +222,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterNegaLucasSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterNegaLucasSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negative-even-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/negative-even-integers/test/test.js
index 80dca0d265b5..c30b303f7006 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negative-even-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negative-even-integers/test/test.js
@@ -103,15 +103,15 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterNegativeEvenIntegersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = -((i*2) + 2);
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isPositiveInteger( actual.value ), true, 'returns a negative integer' );
-		t.equal( isEven( actual.value ), true, 'returns an even integer' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isPositiveInteger( actual.value ), true, 'returns a negative integer' );
+		t.strictEqual( isEven( actual.value ), true, 'returns an even integer' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterNegativeEvenIntegersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -168,20 +168,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNegativeEvenIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,20 +193,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNegativeEvenIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -222,16 +222,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterNegativeEvenIntegersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterNegativeEvenIntegersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negative-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/negative-integers/test/test.js
index fae81fdf02a7..4f8521bf0f70 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negative-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negative-integers/test/test.js
@@ -102,14 +102,14 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterNegativeIntegersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = -( i+1 );
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isNegativeInteger( actual.value ), true, 'returns a negative integer' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isNegativeInteger( actual.value ), true, 'returns a negative integer' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterNegativeIntegersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -166,20 +166,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNegativeIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -191,20 +191,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNegativeIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -220,16 +220,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterNegativeIntegersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -243,7 +243,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterNegativeIntegersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negative-odd-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/negative-odd-integers/test/test.js
index ad7a4f985df9..5acaf1247abb 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negative-odd-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negative-odd-integers/test/test.js
@@ -103,15 +103,15 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterNegativeOddIntegersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = -((i*2) + 1);
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isPositiveInteger( actual.value ), true, 'returns a negative integer' );
-		t.equal( isEven( actual.value ), true, 'returns an odd integer' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isPositiveInteger( actual.value ), true, 'returns a negative integer' );
+		t.strictEqual( isEven( actual.value ), true, 'returns an odd integer' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterNegativeOddIntegersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -168,20 +168,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNegativeOddIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,20 +193,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNegativeOddIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -222,16 +222,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterNegativeOddIntegersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterNegativeOddIntegersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonfibonacci/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/nonfibonacci/test/test.js
index db0bf4990ce1..717e98f8833c 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonfibonacci/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonfibonacci/test/test.js
@@ -102,13 +102,13 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterNonFibonacciSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = nonfibonacci( i+1 );
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -146,7 +146,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterNonFibonacciSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -165,20 +165,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNonFibonacciSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -190,20 +190,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNonFibonacciSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -219,16 +219,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterNonFibonacciSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -242,7 +242,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterNonFibonacciSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-even-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-even-integers/test/test.js
index 60bfcd067557..927d8ba64a44 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-even-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-even-integers/test/test.js
@@ -103,15 +103,15 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterNonNegativeEvenIntegersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = i * 2;
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isNonNegativeInteger( actual.value ), true, 'returns a nonnegative integer' );
-		t.equal( isEven( actual.value ), true, 'returns an even integer' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isNonNegativeInteger( actual.value ), true, 'returns a nonnegative integer' );
+		t.strictEqual( isEven( actual.value ), true, 'returns an even integer' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterNonNegativeEvenIntegersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -168,20 +168,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNonNegativeEvenIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,20 +193,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNonNegativeEvenIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -222,16 +222,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterNonNegativeEvenIntegersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterNonNegativeEvenIntegersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-integers/test/test.js
index 0d0ff3fb47da..e564e660e063 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-integers/test/test.js
@@ -102,14 +102,14 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterNonNegativeIntegersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = i;
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isNonNegativeInteger( actual.value ), true, 'returns a nonnegative integer' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isNonNegativeInteger( actual.value ), true, 'returns a nonnegative integer' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterNonNegativeIntegersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -166,20 +166,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNonNegativeIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -191,20 +191,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNonNegativeIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -220,16 +220,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterNonNegativeIntegersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -243,7 +243,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterNonNegativeIntegersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-even-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-even-integers/test/test.js
index 4c27c5ae051c..7cc47f267764 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-even-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-even-integers/test/test.js
@@ -103,15 +103,15 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterNonPositiveEvenIntegersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = -(i * 2);
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isNonPositiveInteger( actual.value ), true, 'returns a nonpositive integer' );
-		t.equal( isEven( actual.value ), true, 'returns an even integer' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isNonPositiveInteger( actual.value ), true, 'returns a nonpositive integer' );
+		t.strictEqual( isEven( actual.value ), true, 'returns an even integer' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterNonPositiveEvenIntegersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -168,20 +168,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNonPositiveEvenIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,20 +193,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNonPositiveEvenIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -222,16 +222,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterNonPositiveEvenIntegersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterNonPositiveEvenIntegersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-integers/test/test.js
index 7c89abd9c856..b4ba782706e8 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-integers/test/test.js
@@ -102,14 +102,14 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterNonPositiveIntegersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = ( i === 0 ) ? i : -i;
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isNonPositiveInteger( actual.value ), true, 'returns a nonpositive integer' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isNonPositiveInteger( actual.value ), true, 'returns a nonpositive integer' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterNonPositiveIntegersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -166,20 +166,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNonPositiveIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -191,20 +191,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNonPositiveIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -220,16 +220,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterNonPositiveIntegersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -243,7 +243,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterNonPositiveIntegersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonsquares/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/nonsquares/test/test.js
index 494854c1b268..c717eb08bf32 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonsquares/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonsquares/test/test.js
@@ -104,14 +104,14 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterNonSquaresSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = (i+1) + floor( 0.5+sqrt(i+1) );
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isSquareNumber( actual.value ), false, 'does not return a square number' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isSquareNumber( actual.value ), false, 'does not return a square number' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -153,7 +153,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterNonSquaresSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -172,20 +172,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNonSquaresSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -197,20 +197,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNonSquaresSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -226,16 +226,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterNonSquaresSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -249,7 +249,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterNonSquaresSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.js
index 2a4f8542e585..4e9bd633917c 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.js
@@ -105,7 +105,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var j;
 
 	it = iterOddIntegersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	j = -1;
 	for ( i = 0; i < 1000; i++ ) {
@@ -116,10 +116,10 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 		} else {
 			expected = -j;
 		}
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isInteger( actual.value ), true, 'returns an integer' );
-		t.equal( isOdd( actual.value ), true, 'returns an odd integer' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isInteger( actual.value ), true, 'returns an integer' );
+		t.strictEqual( isOdd( actual.value ), true, 'returns an odd integer' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -161,7 +161,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterOddIntegersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -180,20 +180,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterOddIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -205,20 +205,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterOddIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -234,16 +234,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterOddIntegersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -257,7 +257,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterOddIntegersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/positive-even-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/positive-even-integers/test/test.js
index 110e8dd2e52c..8f2cb6d10b8e 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/positive-even-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/positive-even-integers/test/test.js
@@ -103,15 +103,15 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterPositiveEvenIntegersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = (i*2) + 2;
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isPositiveInteger( actual.value ), true, 'returns a positive integer' );
-		t.equal( isEven( actual.value ), true, 'returns an even integer' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isPositiveInteger( actual.value ), true, 'returns a positive integer' );
+		t.strictEqual( isEven( actual.value ), true, 'returns an even integer' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterPositiveEvenIntegersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -168,20 +168,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPositiveEvenIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,20 +193,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPositiveEvenIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -222,16 +222,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterPositiveEvenIntegersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterPositiveEvenIntegersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/positive-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/positive-integers/test/test.js
index c0e6c991fc9e..86ada2b35d86 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/positive-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/positive-integers/test/test.js
@@ -102,14 +102,14 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterPositiveIntegersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = i + 1;
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isPositiveInteger( actual.value ), true, 'returns a positive integer' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isPositiveInteger( actual.value ), true, 'returns a positive integer' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterPositiveIntegersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -166,20 +166,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPositiveIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -191,20 +191,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPositiveIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -220,16 +220,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterPositiveIntegersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -243,7 +243,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterPositiveIntegersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/positive-odd-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/positive-odd-integers/test/test.js
index e144cde5c846..2340b3a40bf1 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/positive-odd-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/positive-odd-integers/test/test.js
@@ -103,15 +103,15 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterPositiveOddIntegersSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = (i*2) + 1;
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isPositiveInteger( actual.value ), true, 'returns a positive integer' );
-		t.equal( isEven( actual.value ), true, 'returns an odd integer' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isPositiveInteger( actual.value ), true, 'returns a positive integer' );
+		t.strictEqual( isEven( actual.value ), true, 'returns an odd integer' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterPositiveOddIntegersSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -168,20 +168,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPositiveOddIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,20 +193,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPositiveOddIntegersSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -222,16 +222,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterPositiveOddIntegersSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterPositiveOddIntegersSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/primes/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/primes/test/test.js
index 2c8382b35512..abb6fb600723 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/primes/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/primes/test/test.js
@@ -101,12 +101,12 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterPrimesSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1e4; i++ ) {
 		actual = it.next();
-		t.equal( isPrime( actual.value ), true, 'returns a prime number' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( isPrime( actual.value ), true, 'returns a prime number' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -148,7 +148,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterPrimesSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -167,20 +167,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPrimesSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -192,20 +192,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPrimesSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,16 +221,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterPrimesSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -244,7 +244,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterPrimesSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/squared-triangular/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/squared-triangular/test/test.js
index f17f8cf66caf..34ff52f4762a 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/squared-triangular/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/squared-triangular/test/test.js
@@ -104,16 +104,16 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterSquaredTriangularSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = (i/2) * (i+1);
 		expected *= expected;
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isSquareNumber( actual.value ), true, 'returns a square number' );
-		t.equal( isTriangularNumber( sqrt( actual.value ) ), true, 'returns a squared triangular number' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isSquareNumber( actual.value ), true, 'returns a square number' );
+		t.strictEqual( isTriangularNumber( sqrt( actual.value ) ), true, 'returns a squared triangular number' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterSquaredTriangularSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -174,20 +174,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSquaredTriangularSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -199,20 +199,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSquaredTriangularSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -228,16 +228,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterSquaredTriangularSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -251,7 +251,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterSquaredTriangularSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/squares/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/squares/test/test.js
index a08d1b0cf585..0614f03a0935 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/squares/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/squares/test/test.js
@@ -102,14 +102,14 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterSquaresSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = i * i;
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( isSquareNumber( actual.value ), true, 'returns a square number' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( isSquareNumber( actual.value ), true, 'returns a square number' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -151,7 +151,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterSquaresSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -170,20 +170,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSquaresSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -195,20 +195,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSquaresSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -224,16 +224,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterSquaresSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -247,7 +247,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterSquaresSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/test/test.js
index 630b5b5a6ff7..76eceb93c544 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/triangular/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/triangular/test/test.js
index 6118e66bf1f4..0b843bd127ff 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/triangular/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/triangular/test/test.js
@@ -101,13 +101,13 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterTriangularSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		actual = it.next();
 		expected = (i/2) * (i+1);
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterTriangularSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -168,20 +168,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTriangularSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,20 +193,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTriangularSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -222,16 +222,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterTriangularSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterTriangularSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/test/test.js
index f1a53dc7d971..bf1280390aa6 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/test/test.js
@@ -102,17 +102,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	var i;
 
 	it = iterTribonacciSeq();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 64; i++ ) {
 		actual = it.next();
 		expected = tribonacci( i );
-		t.equal( actual.value, expected, 'returns expected value' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( actual.value, expected, 'returns expected value' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 	t.end();
 });
 
@@ -153,7 +153,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 5
 	};
 	it = iterTribonacciSeq( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -172,20 +172,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTribonacciSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -197,20 +197,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTribonacciSeq();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -226,16 +226,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterTribonacciSeq();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -249,7 +249,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterTribonacciSeq();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/abs/test/test.js b/lib/node_modules/@stdlib/math/iter/special/abs/test/test.js
index 7fdac002baee..aa9a378a28a2 100644
--- a/lib/node_modules/@stdlib/math/iter/special/abs/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/abs/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAbs( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAbs( linspace( -10.0, 10.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -10.0, 10.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = abs( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAbs( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAbs( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAbs( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/abs2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/abs2/test/test.js
index 98692c186694..02e3cbc3f414 100644
--- a/lib/node_modules/@stdlib/math/iter/special/abs2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/abs2/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAbs2( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAbs2( linspace( -10.0, 10.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -10.0, 10.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = abs2( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAbs2( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAbs2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAbs2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/acos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/acos/test/test.js
index e27d4c70d32e..d0e7f176c920 100644
--- a/lib/node_modules/@stdlib/math/iter/special/acos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/acos/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAcos( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAcos( linspace( -1.0, 1.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -1.0, 1.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = acos( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAcos( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAcos( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAcos( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/acosh/test/test.js b/lib/node_modules/@stdlib/math/iter/special/acosh/test/test.js
index 8e4197a94b1d..781f3a6bfad0 100644
--- a/lib/node_modules/@stdlib/math/iter/special/acosh/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/acosh/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAcosh( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAcosh( linspace( 1.0, 10.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 1.0, 10.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = acosh( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAcosh( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAcosh( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAcosh( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/acot/test/test.js b/lib/node_modules/@stdlib/math/iter/special/acot/test/test.js
index 13fccddce86f..491daebb1ad7 100644
--- a/lib/node_modules/@stdlib/math/iter/special/acot/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/acot/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAcot( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAcot( linspace( -5.0, 5.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -5.0, 5.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = acot( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAcot( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAcot( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAcot( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/acoth/test/test.js b/lib/node_modules/@stdlib/math/iter/special/acoth/test/test.js
index 882c248ed53e..29fa4cdea627 100644
--- a/lib/node_modules/@stdlib/math/iter/special/acoth/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/acoth/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAcoth( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAcoth( linspace( 1.0, 10.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 1.0, 10.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = acoth( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAcoth( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAcoth( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAcoth( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/acovercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/acovercos/test/test.js
index a95961d93be1..c3895c92b4e0 100644
--- a/lib/node_modules/@stdlib/math/iter/special/acovercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/acovercos/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAcovercos( uniform( 0.0, 2.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAcovercos( linspace( 0.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = acovercos( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAcovercos( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAcovercos( uniform( 0.0, 2.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAcovercos( uniform( 0.0, 2.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/acoversin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/acoversin/test/test.js
index e21a0fe41eba..80edd0918166 100644
--- a/lib/node_modules/@stdlib/math/iter/special/acoversin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/acoversin/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAcoversin( uniform( 0.0, 2.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAcoversin( linspace( 0.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = acoversin( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAcoversin( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAcoversin( uniform( 0.0, 2.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAcoversin( uniform( 0.0, 2.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/ahavercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ahavercos/test/test.js
index 55087da8edbd..c82b168f0b30 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ahavercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ahavercos/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAhavercos( uniform( 0.0, 1.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAhavercos( linspace( 0.0, 1.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 1.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = ahavercos( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAhavercos( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAhavercos( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAhavercos( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/ahaversin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ahaversin/test/test.js
index bcf616584688..afef681c2391 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ahaversin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ahaversin/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAhaversin( uniform( 0.0, 1.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAhaversin( linspace( 0.0, 1.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 1.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = ahaversin( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAhaversin( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAhaversin( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAhaversin( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/asin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/asin/test/test.js
index a2a6bd61df6c..d33b0393f1bc 100644
--- a/lib/node_modules/@stdlib/math/iter/special/asin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/asin/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAsin( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAsin( linspace( -1.0, 1.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -1.0, 1.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = asin( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAsin( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAsin( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAsin( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/asinh/test/test.js b/lib/node_modules/@stdlib/math/iter/special/asinh/test/test.js
index 774b4787e41d..081acc5f675c 100644
--- a/lib/node_modules/@stdlib/math/iter/special/asinh/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/asinh/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAsinh( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAsinh( linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = asinh( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAsinh( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAsinh( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAsinh( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/atan/test/test.js b/lib/node_modules/@stdlib/math/iter/special/atan/test/test.js
index c10c33f3a9ce..5bfba7821d14 100644
--- a/lib/node_modules/@stdlib/math/iter/special/atan/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/atan/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAtan( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAtan( linspace( -3.14, 3.14, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -3.14, 3.14, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = atan( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAtan( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAtan( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAtan( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/atan2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/atan2/test/test.js
index 27e4111eb295..83ee40f17d3b 100644
--- a/lib/node_modules/@stdlib/math/iter/special/atan2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/atan2/test/test.js
@@ -96,12 +96,12 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, ite
 	var i;
 
 	it = iterAtan2( randu(), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -112,12 +112,12 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, sca
 	var i;
 
 	it = iterAtan2( randu(), 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -128,12 +128,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, itera
 	var i;
 
 	it = iterAtan2( 2.0, randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -144,12 +144,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, scala
 	var i;
 
 	it = iterAtan2( 2.0, 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -165,19 +165,19 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAtan2( linspace( -3.14, 3.14, N ), linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	y = linspace( -3.14, 3.14, N );
 	x = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = atan2( y.next().value, x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -192,18 +192,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAtan2( linspace( -3.14, 3.14, N ), 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	y = linspace( -3.14, 3.14, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = atan2( y.next().value, 2.0 );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -218,18 +218,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAtan2( 2.0, linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = atan2( 2.0, x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -241,7 +241,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	var i;
 
 	it = iterAtan2( 2.0, 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = {
 		'value': atan2( 2.0, 2.0 ),
@@ -294,17 +294,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAtan2( array2iterator( values ), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -316,20 +316,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAtan2( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -341,20 +341,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAtan2( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/atanh/test/test.js b/lib/node_modules/@stdlib/math/iter/special/atanh/test/test.js
index cfe9fb2d5011..1bfbbbf93a83 100644
--- a/lib/node_modules/@stdlib/math/iter/special/atanh/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/atanh/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAtanh( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAtanh( linspace( -1.0, 1.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -1.0, 1.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = atanh( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAtanh( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAtanh( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAtanh( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/avercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/avercos/test/test.js
index 425f2f8ea0d0..ee096ae10598 100644
--- a/lib/node_modules/@stdlib/math/iter/special/avercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/avercos/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAvercos( uniform( -2.0, 0.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAvercos( linspace( -2.0, 0.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -2.0, 0.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = avercos( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAvercos( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAvercos( uniform( -2.0, 0.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAvercos( uniform( -2.0, 0.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/aversin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/aversin/test/test.js
index 94ab00a4a834..f7c02997d371 100644
--- a/lib/node_modules/@stdlib/math/iter/special/aversin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/aversin/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterAversin( uniform( 0.0, 2.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterAversin( linspace( 0.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = aversin( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterAversin( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAversin( uniform( 0.0, 2.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAversin( uniform( 0.0, 2.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/besselj0/test/test.js b/lib/node_modules/@stdlib/math/iter/special/besselj0/test/test.js
index 464998d530a4..2486f429277b 100644
--- a/lib/node_modules/@stdlib/math/iter/special/besselj0/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/besselj0/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterBesselj0( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterBesselj0( linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = besselj0( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterBesselj0( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBesselj0( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBesselj0( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/besselj1/test/test.js b/lib/node_modules/@stdlib/math/iter/special/besselj1/test/test.js
index c6de6a358ae0..37743f9c2e9a 100644
--- a/lib/node_modules/@stdlib/math/iter/special/besselj1/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/besselj1/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterBesselj1( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterBesselj1( linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = besselj1( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterBesselj1( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBesselj1( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBesselj1( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/bessely0/test/test.js b/lib/node_modules/@stdlib/math/iter/special/bessely0/test/test.js
index 3eee2fec0d0f..ce65ac3a2370 100644
--- a/lib/node_modules/@stdlib/math/iter/special/bessely0/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/bessely0/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterBessely0( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterBessely0( linspace( 0.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = bessely0( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterBessely0( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBessely0( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBessely0( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/bessely1/test/test.js b/lib/node_modules/@stdlib/math/iter/special/bessely1/test/test.js
index 70589b23f6d1..eae1b675e5c7 100644
--- a/lib/node_modules/@stdlib/math/iter/special/bessely1/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/bessely1/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterBessely1( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterBessely1( linspace( 0.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = bessely1( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterBessely1( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBessely1( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBessely1( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/beta/test/test.js b/lib/node_modules/@stdlib/math/iter/special/beta/test/test.js
index fe0242f31c25..80d71b82e960 100644
--- a/lib/node_modules/@stdlib/math/iter/special/beta/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/beta/test/test.js
@@ -96,12 +96,12 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, ite
 	var i;
 
 	it = iterBeta( randu(), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -112,12 +112,12 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, sca
 	var i;
 
 	it = iterBeta( randu(), 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -128,12 +128,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, itera
 	var i;
 
 	it = iterBeta( 2.0, randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -144,12 +144,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, scala
 	var i;
 
 	it = iterBeta( 2.0, 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -165,19 +165,19 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterBeta( linspace( 0.1, 2.0, N ), linspace( 0.1, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	y = linspace( 0.1, 2.0, N );
 	x = linspace( 0.1, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = beta( x.next().value, y.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -192,18 +192,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterBeta( linspace( 0.1, 2.0, N ), 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.1, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = beta( x.next().value, 2.0 );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -218,18 +218,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterBeta( 2.0, linspace( 0.1, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	y = linspace( 0.1, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = beta( 2.0, y.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -241,7 +241,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	var i;
 
 	it = iterBeta( 2.0, 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = {
 		'value': beta( 2.0, 2.0 ),
@@ -294,17 +294,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterBeta( array2iterator( values ), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -316,20 +316,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBeta( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -341,20 +341,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBeta( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/betaln/test/test.js b/lib/node_modules/@stdlib/math/iter/special/betaln/test/test.js
index 6048a7f30140..ec5411d7d97e 100644
--- a/lib/node_modules/@stdlib/math/iter/special/betaln/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/betaln/test/test.js
@@ -96,12 +96,12 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, ite
 	var i;
 
 	it = iterBetaln( randu(), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -112,12 +112,12 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, sca
 	var i;
 
 	it = iterBetaln( randu(), 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -128,12 +128,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, itera
 	var i;
 
 	it = iterBetaln( 2.0, randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -144,12 +144,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, scala
 	var i;
 
 	it = iterBetaln( 2.0, 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -165,19 +165,19 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterBetaln( linspace( 0.1, 2.0, N ), linspace( 0.1, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	y = linspace( 0.1, 2.0, N );
 	x = linspace( 0.1, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = betaln( x.next().value, y.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -192,18 +192,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterBetaln( linspace( 0.1, 2.0, N ), 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.1, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = betaln( x.next().value, 2.0 );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -218,18 +218,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterBetaln( 2.0, linspace( 0.1, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	y = linspace( 0.1, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = betaln( 2.0, y.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -241,7 +241,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	var i;
 
 	it = iterBetaln( 2.0, 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = {
 		'value': betaln( 2.0, 2.0 ),
@@ -294,17 +294,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterBetaln( array2iterator( values ), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -316,20 +316,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBetaln( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -341,20 +341,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBetaln( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/binet/test/test.js b/lib/node_modules/@stdlib/math/iter/special/binet/test/test.js
index cdc5ff0a72ea..89561a66f416 100644
--- a/lib/node_modules/@stdlib/math/iter/special/binet/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/binet/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterBinet( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterBinet( linspace( 0.0, 10.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 10.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = binet( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterBinet( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBinet( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBinet( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/cbrt/test/test.js b/lib/node_modules/@stdlib/math/iter/special/cbrt/test/test.js
index ece537a4963c..f47e6b3746e2 100644
--- a/lib/node_modules/@stdlib/math/iter/special/cbrt/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/cbrt/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterCbrt( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterCbrt( linspace( 0.0, 1000.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 1000.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = cbrt( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterCbrt( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCbrt( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCbrt( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/ceil/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ceil/test/test.js
index f38afe49eccd..9be4dee1cf65 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ceil/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ceil/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterCeil( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 
 	N = 101;
 	it = iterCeil( linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = ceil( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterCeil( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCeil( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCeil( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/ceil10/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ceil10/test/test.js
index 12507596623a..9cc1828cd46d 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ceil10/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ceil10/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterCeil10( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 
 	N = 101;
 	it = iterCeil10( linspace( -200.0, 200.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -200.0, 200.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = ceil10( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterCeil10( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCeil10( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCeil10( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/ceil2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ceil2/test/test.js
index dc9d05f331ba..753fb3408f7a 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ceil2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ceil2/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterCeil2( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 
 	N = 101;
 	it = iterCeil2( linspace( -200.0, 200.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -200.0, 200.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = ceil2( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterCeil2( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCeil2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCeil2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/cos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/cos/test/test.js
index c2634ff13917..e932ce3035b2 100644
--- a/lib/node_modules/@stdlib/math/iter/special/cos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/cos/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterCos( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 100;
 	it = iterCos( linspace( 0.0, 6.14, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 6.14, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = cos( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterCos( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCos( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCos( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/cosh/test/test.js b/lib/node_modules/@stdlib/math/iter/special/cosh/test/test.js
index a71ea1c7799b..7f093d3c0863 100644
--- a/lib/node_modules/@stdlib/math/iter/special/cosh/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/cosh/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterCosh( uniform( -5.0, 5.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterCosh( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( -5.0, 5.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = cosh( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterCosh( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCosh( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCosh( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/cosm1/test/test.js b/lib/node_modules/@stdlib/math/iter/special/cosm1/test/test.js
index a41977bc812b..9801e469106b 100644
--- a/lib/node_modules/@stdlib/math/iter/special/cosm1/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/cosm1/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterCosm1( uniform( 0.0, 6.28 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterCosm1( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 6.28, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = cosm1( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterCosm1( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCosm1( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCosm1( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/cospi/test/test.js b/lib/node_modules/@stdlib/math/iter/special/cospi/test/test.js
index e982d3ae7126..dd8180549506 100644
--- a/lib/node_modules/@stdlib/math/iter/special/cospi/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/cospi/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterCospi( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 100;
 	it = iterCospi( linspace( 0.0, 50.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 50.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = cospi( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterCospi( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCospi( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCospi( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/covercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/covercos/test/test.js
index 9016d21c2546..d2ef9a8cf960 100644
--- a/lib/node_modules/@stdlib/math/iter/special/covercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/covercos/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterCovercos( uniform( 0.0, 6.28 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterCovercos( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 6.28, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = covercos( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterCovercos( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCovercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCovercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/coversin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/coversin/test/test.js
index 4a8a71fc585d..39db89fcca0d 100644
--- a/lib/node_modules/@stdlib/math/iter/special/coversin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/coversin/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterCoversin( uniform( 0.0, 6.28 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterCoversin( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 6.28, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = coversin( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterCoversin( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCoversin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCoversin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/deg2rad/test/test.js b/lib/node_modules/@stdlib/math/iter/special/deg2rad/test/test.js
index ea965f27de41..d0101694e453 100644
--- a/lib/node_modules/@stdlib/math/iter/special/deg2rad/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/deg2rad/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterDeg2rad( uniform( -360.0, 360.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which converts
 		'iter': N
 	});
 	it = iterDeg2rad( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( -360.0, 360.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which converts
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = deg2rad( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterDeg2rad( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDeg2rad( uniform( -360.0, 360.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDeg2rad( uniform( -360.0, 360.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/digamma/test/test.js b/lib/node_modules/@stdlib/math/iter/special/digamma/test/test.js
index 557e1bc57ff8..159d1852acdf 100644
--- a/lib/node_modules/@stdlib/math/iter/special/digamma/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/digamma/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterDigamma( uniform( 0.01, 5.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		'iter': N
 	});
 	it = iterDigamma( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.01, 5.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = digamma( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterDigamma( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDigamma( uniform( 0.01, 5.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDigamma( uniform( 0.01, 5.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/dirac-delta/test/test.js b/lib/node_modules/@stdlib/math/iter/special/dirac-delta/test/test.js
index 75f725d5f84c..c63db4b5a01e 100644
--- a/lib/node_modules/@stdlib/math/iter/special/dirac-delta/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/dirac-delta/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterDiracDelta( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterDiracDelta( linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = diracDelta( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterDiracDelta( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDiracDelta( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDiracDelta( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/dirichlet-eta/test/test.js b/lib/node_modules/@stdlib/math/iter/special/dirichlet-eta/test/test.js
index 8014dcd20a30..fa3fa5101a7b 100644
--- a/lib/node_modules/@stdlib/math/iter/special/dirichlet-eta/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/dirichlet-eta/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterEta( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterEta( linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = eta( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterEta( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterEta( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterEta( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/ellipe/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ellipe/test/test.js
index eb8f45df6cb2..9b6c2cbdab5e 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ellipe/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ellipe/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterEllipe( uniform( -1.0, 1.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterEllipe( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( -1.0, 1.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = ellipe( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterEllipe( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterEllipe( uniform( -1.0, 1.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterEllipe( uniform( -1.0, 1.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/ellipk/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ellipk/test/test.js
index 366f45237bd4..e377183a29d3 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ellipk/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ellipk/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterEllipk( uniform( -1.0, 1.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterEllipk( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( -1.0, 1.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = ellipk( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterEllipk( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterEllipk( uniform( -1.0, 1.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterEllipk( uniform( -1.0, 1.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/erf/test/test.js b/lib/node_modules/@stdlib/math/iter/special/erf/test/test.js
index 87b5928e2183..5b664fb4ab16 100644
--- a/lib/node_modules/@stdlib/math/iter/special/erf/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/erf/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterErf( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterErf( linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = erf( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterErf( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterErf( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterErf( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/erfc/test/test.js b/lib/node_modules/@stdlib/math/iter/special/erfc/test/test.js
index ad931f48de46..cf062ea03ca0 100644
--- a/lib/node_modules/@stdlib/math/iter/special/erfc/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/erfc/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterErfc( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterErfc( linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = erfc( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterErfc( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterErfc( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterErfc( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/erfcinv/test/test.js b/lib/node_modules/@stdlib/math/iter/special/erfcinv/test/test.js
index 548d8e53f049..2995f67209b4 100644
--- a/lib/node_modules/@stdlib/math/iter/special/erfcinv/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/erfcinv/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterErfcinv( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterErfcinv( linspace( 0.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = erfcinv( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterErfcinv( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterErfcinv( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterErfcinv( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/erfinv/test/test.js b/lib/node_modules/@stdlib/math/iter/special/erfinv/test/test.js
index 30850ccd17d5..4f2a6af4f890 100644
--- a/lib/node_modules/@stdlib/math/iter/special/erfinv/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/erfinv/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterErfinv( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterErfinv( linspace( -1.0, 1.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -1.0, 1.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = erfinv( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterErfinv( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterErfinv( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterErfinv( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/exp/test/test.js b/lib/node_modules/@stdlib/math/iter/special/exp/test/test.js
index cdd3921747b3..78077c10a51c 100644
--- a/lib/node_modules/@stdlib/math/iter/special/exp/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/exp/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterExp( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterExp( linspace( 0.0, 100.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 100.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = exp( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterExp( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterExp( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterExp( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/exp10/test/test.js b/lib/node_modules/@stdlib/math/iter/special/exp10/test/test.js
index 789f1405e6c5..2bbdc5f5a9fc 100644
--- a/lib/node_modules/@stdlib/math/iter/special/exp10/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/exp10/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterExp10( uniform( -50.0, 50.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		'iter': N
 	});
 	it = iterExp10( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( -50.0, 50.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = exp10( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterExp10( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterExp10( uniform( -50.0, 50.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterExp10( uniform( -50.0, 50.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/exp2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/exp2/test/test.js
index ddd9b62ee346..f57c4f60de90 100644
--- a/lib/node_modules/@stdlib/math/iter/special/exp2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/exp2/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterExp2( uniform( -50.0, 50.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		'iter': N
 	});
 	it = iterExp2( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( -50.0, 50.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = exp2( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterExp2( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterExp2( uniform( -50.0, 50.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterExp2( uniform( -50.0, 50.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/expit/test/test.js b/lib/node_modules/@stdlib/math/iter/special/expit/test/test.js
index bc4310f8f2f1..a46dbc97a668 100644
--- a/lib/node_modules/@stdlib/math/iter/special/expit/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/expit/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterExpit( uniform( 0.0, 1.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		'iter': N
 	});
 	it = iterExpit( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 1.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = expit( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterExpit( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterExpit( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterExpit( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/expm1/test/test.js b/lib/node_modules/@stdlib/math/iter/special/expm1/test/test.js
index b07ba54f8ae9..4b8e55561f12 100644
--- a/lib/node_modules/@stdlib/math/iter/special/expm1/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/expm1/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterExpm1( uniform( -5.0, 5.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterExpm1( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( -5.0, 5.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = expm1( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterExpm1( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterExpm1( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterExpm1( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/expm1rel/test/test.js b/lib/node_modules/@stdlib/math/iter/special/expm1rel/test/test.js
index 547ac66a5c61..761f450a73d5 100644
--- a/lib/node_modules/@stdlib/math/iter/special/expm1rel/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/expm1rel/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterExpm1rel( uniform( -50.0, 50.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		'iter': N
 	});
 	it = iterExpm1rel( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( -50.0, 50.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = expm1rel( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterExpm1rel( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterExpm1rel( uniform( -50.0, 50.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterExpm1rel( uniform( -50.0, 50.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/factorial/test/test.js b/lib/node_modules/@stdlib/math/iter/special/factorial/test/test.js
index b6c23e15698e..15b3d1632736 100644
--- a/lib/node_modules/@stdlib/math/iter/special/factorial/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/factorial/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterFactorial( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterFactorial( linspace( 0.0, 10.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 10.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = factorial( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterFactorial( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFactorial( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFactorial( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/factorialln/test/test.js b/lib/node_modules/@stdlib/math/iter/special/factorialln/test/test.js
index 9bfa68d3e212..017e75390b68 100644
--- a/lib/node_modules/@stdlib/math/iter/special/factorialln/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/factorialln/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterFactorialln( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterFactorialln( linspace( 0.0, 10.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 10.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = factorialln( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterFactorialln( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFactorialln( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFactorialln( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/floor/test/test.js b/lib/node_modules/@stdlib/math/iter/special/floor/test/test.js
index 0e04ea093ba1..58c92d4a90a4 100644
--- a/lib/node_modules/@stdlib/math/iter/special/floor/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/floor/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterFloor( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 
 	N = 101;
 	it = iterFloor( linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = floor( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterFloor( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFloor( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFloor( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/floor10/test/test.js b/lib/node_modules/@stdlib/math/iter/special/floor10/test/test.js
index 8a091317a248..8bc387420860 100644
--- a/lib/node_modules/@stdlib/math/iter/special/floor10/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/floor10/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterFloor10( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 
 	N = 101;
 	it = iterFloor10( linspace( -200.0, 200.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -200.0, 200.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = floor10( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterFloor10( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFloor10( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFloor10( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/floor2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/floor2/test/test.js
index e8d7c2d252e1..47a5b4779dd2 100644
--- a/lib/node_modules/@stdlib/math/iter/special/floor2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/floor2/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterFloor2( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 
 	N = 101;
 	it = iterFloor2( linspace( -200.0, 200.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -200.0, 200.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = floor2( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterFloor2( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFloor2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFloor2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/fresnelc/test/test.js b/lib/node_modules/@stdlib/math/iter/special/fresnelc/test/test.js
index dcfaf23391d1..9ce41d8ce56d 100644
--- a/lib/node_modules/@stdlib/math/iter/special/fresnelc/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/fresnelc/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterFresnelc( uniform( 0.0, 10.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterFresnelc( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 10.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = fresnelc( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterFresnelc( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFresnelc( uniform( 0.0, 10.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFresnelc( uniform( 0.0, 10.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/fresnels/test/test.js b/lib/node_modules/@stdlib/math/iter/special/fresnels/test/test.js
index af8fba25c0ec..002051ae8446 100644
--- a/lib/node_modules/@stdlib/math/iter/special/fresnels/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/fresnels/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterFresnels( uniform( 0.0, 10.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterFresnels( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 10.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = fresnels( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterFresnels( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFresnels( uniform( 0.0, 10.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFresnels( uniform( 0.0, 10.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/gamma/test/test.js b/lib/node_modules/@stdlib/math/iter/special/gamma/test/test.js
index f33c1e6b8d74..adf86fadcd18 100644
--- a/lib/node_modules/@stdlib/math/iter/special/gamma/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/gamma/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterGamma( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterGamma( linspace( 0.0, 10.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 10.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = gamma( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterGamma( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterGamma( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterGamma( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/gamma1pm1/test/test.js b/lib/node_modules/@stdlib/math/iter/special/gamma1pm1/test/test.js
index 988b010a70c4..a92abd3420b9 100644
--- a/lib/node_modules/@stdlib/math/iter/special/gamma1pm1/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/gamma1pm1/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterGamma1pm1( uniform( -5.0, 5.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterGamma1pm1( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( -5.0, 5.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = gamma1pm1( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterGamma1pm1( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterGamma1pm1( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterGamma1pm1( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/gammaln/test/test.js b/lib/node_modules/@stdlib/math/iter/special/gammaln/test/test.js
index e5edbc4abe22..527652ec0875 100644
--- a/lib/node_modules/@stdlib/math/iter/special/gammaln/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/gammaln/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterGammaln( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterGammaln( linspace( 0.0, 10.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 10.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = gammaln( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterGammaln( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterGammaln( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterGammaln( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/hacovercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/hacovercos/test/test.js
index cbd18535fe9f..9aa9372e2e32 100644
--- a/lib/node_modules/@stdlib/math/iter/special/hacovercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/hacovercos/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterHacovercos( uniform( 0.0, 6.28 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterHacovercos( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 6.28, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = hacovercos( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterHacovercos( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterHacovercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterHacovercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/hacoversin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/hacoversin/test/test.js
index 92cd727f2f9b..ac7fb85433e7 100644
--- a/lib/node_modules/@stdlib/math/iter/special/hacoversin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/hacoversin/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterHacoversin( uniform( 0.0, 6.28 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterHacoversin( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 6.28, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = hacoversin( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterHacoversin( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterHacoversin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterHacoversin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/havercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/havercos/test/test.js
index 2596881b22c1..8fa1e7100dee 100644
--- a/lib/node_modules/@stdlib/math/iter/special/havercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/havercos/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterHavercos( uniform( 0.0, 6.28 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterHavercos( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 6.28, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = havercos( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterHavercos( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterHavercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterHavercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/haversin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/haversin/test/test.js
index 61ecfe95f239..faa9e8de2e85 100644
--- a/lib/node_modules/@stdlib/math/iter/special/haversin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/haversin/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterHaversin( uniform( 0.0, 6.28 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterHaversin( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 6.28, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = haversin( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterHaversin( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterHaversin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterHaversin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/inv/test/test.js b/lib/node_modules/@stdlib/math/iter/special/inv/test/test.js
index 439035403ac2..7d51d23f929c 100644
--- a/lib/node_modules/@stdlib/math/iter/special/inv/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/inv/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterInv( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterInv( linspace( -10.0, 10.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -10.0, 10.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = inv( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterInv( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterInv( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterInv( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/ln/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ln/test/test.js
index 854354ac8c49..eecfc1e383ca 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ln/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ln/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterLn( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterLn( linspace( 0.0, 100.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 100.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = ln( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterLn( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLn( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLn( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/log/test/test.js b/lib/node_modules/@stdlib/math/iter/special/log/test/test.js
index 1f79169f2f41..fad8ead7cbda 100644
--- a/lib/node_modules/@stdlib/math/iter/special/log/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/log/test/test.js
@@ -96,12 +96,12 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, ite
 	var i;
 
 	it = iterLog( randu(), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -112,12 +112,12 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, sca
 	var i;
 
 	it = iterLog( randu(), 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -128,12 +128,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, itera
 	var i;
 
 	it = iterLog( 2.0, randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -144,12 +144,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, scala
 	var i;
 
 	it = iterLog( 2.0, 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -165,19 +165,19 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterLog( linspace( 0.0, 2.0, N ), linspace( 0.01, 3.14, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 2.0, N );
 	y = linspace( 0.01, 3.14, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = log( x.next().value, y.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -192,18 +192,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterLog( linspace( 0.0, 3.14, N ), 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 3.14, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = log( x.next().value, 2.0 );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -218,18 +218,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterLog( 2.0, linspace( 0.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	y = linspace( 0.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = log( 2.0, y.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -241,7 +241,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	var i;
 
 	it = iterLog( 2.0, 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = {
 		'value': log( 2.0, 2.0 ),
@@ -294,17 +294,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterLog( array2iterator( values ), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -316,20 +316,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLog( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -341,20 +341,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLog( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/log10/test/test.js b/lib/node_modules/@stdlib/math/iter/special/log10/test/test.js
index a2ae40a2c7e5..962f1e7fc78f 100644
--- a/lib/node_modules/@stdlib/math/iter/special/log10/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/log10/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterLog10( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterLog10( linspace( 0.0, 1000.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 1000.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = log10( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterLog10( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLog10( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLog10( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/log1mexp/test/test.js b/lib/node_modules/@stdlib/math/iter/special/log1mexp/test/test.js
index 94a03e768d9f..005680bd8fa9 100644
--- a/lib/node_modules/@stdlib/math/iter/special/log1mexp/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/log1mexp/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterLog1mexp( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterLog1mexp( linspace( 0.0, 1.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 1.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = log1mexp( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterLog1mexp( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLog1mexp( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLog1mexp( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/log1p/test/test.js b/lib/node_modules/@stdlib/math/iter/special/log1p/test/test.js
index 1a3ada0af7e7..f5a552b1f1e3 100644
--- a/lib/node_modules/@stdlib/math/iter/special/log1p/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/log1p/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterLog1p( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterLog1p( linspace( 0.0, 1000.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 1000.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = log1p( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterLog1p( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLog1p( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLog1p( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/log1pexp/test/test.js b/lib/node_modules/@stdlib/math/iter/special/log1pexp/test/test.js
index 071c9f8c32c0..e269f72b3689 100644
--- a/lib/node_modules/@stdlib/math/iter/special/log1pexp/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/log1pexp/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterLog1pexp( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterLog1pexp( linspace( 0.0, 1.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 1.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = log1pexp( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterLog1pexp( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLog1pexp( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLog1pexp( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/log2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/log2/test/test.js
index 63e6418a5c25..b79a9eaf206a 100644
--- a/lib/node_modules/@stdlib/math/iter/special/log2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/log2/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterLog2( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterLog2( linspace( 0.0, 1000.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 1000.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = log2( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterLog2( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLog2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLog2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/logit/test/test.js b/lib/node_modules/@stdlib/math/iter/special/logit/test/test.js
index d536c2584433..7d305ee001e2 100644
--- a/lib/node_modules/@stdlib/math/iter/special/logit/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/logit/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterLogit( uniform( 0.0, 1.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		'iter': N
 	});
 	it = iterLogit( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 1.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = logit( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterLogit( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLogit( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLogit( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/pow/test/test.js b/lib/node_modules/@stdlib/math/iter/special/pow/test/test.js
index ff48228c9adf..05ec2fd0c998 100644
--- a/lib/node_modules/@stdlib/math/iter/special/pow/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/pow/test/test.js
@@ -96,12 +96,12 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, ite
 	var i;
 
 	it = iterPow( randu(), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -112,12 +112,12 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, sca
 	var i;
 
 	it = iterPow( randu(), 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -128,12 +128,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, itera
 	var i;
 
 	it = iterPow( 2.0, randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -144,12 +144,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, scala
 	var i;
 
 	it = iterPow( 2.0, 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -165,19 +165,19 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterPow( linspace( 0.0, 2.0, N ), linspace( -3.14, 3.14, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 2.0, N );
 	y = linspace( -3.14, 3.14, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = pow( x.next().value, y.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -192,18 +192,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterPow( linspace( -3.14, 3.14, N ), 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -3.14, 3.14, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = pow( x.next().value, 2.0 );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -218,18 +218,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterPow( 2.0, linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	y = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = pow( 2.0, y.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -241,7 +241,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	var i;
 
 	it = iterPow( 2.0, 2.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = {
 		'value': pow( 2.0, 2.0 ),
@@ -294,17 +294,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterPow( array2iterator( values ), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -316,20 +316,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPow( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -341,20 +341,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPow( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/rad2deg/test/test.js b/lib/node_modules/@stdlib/math/iter/special/rad2deg/test/test.js
index d2a0ab743ef9..9ade51818102 100644
--- a/lib/node_modules/@stdlib/math/iter/special/rad2deg/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/rad2deg/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterRad2deg( uniform( 0.0, 6.28 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which converts
 		'iter': N
 	});
 	it = iterRad2deg( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 6.28, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which converts
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = rad2deg( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterRad2deg( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterRad2deg( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterRad2deg( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/ramp/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ramp/test/test.js
index 9e613ffc939b..04516dc6bfbd 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ramp/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ramp/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterRamp( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterRamp( linspace( -10.0, 10.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -10.0, 10.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = ramp( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterRamp( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterRamp( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterRamp( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/riemann-zeta/test/test.js b/lib/node_modules/@stdlib/math/iter/special/riemann-zeta/test/test.js
index c5dc347e4c74..2dd58a86f02e 100644
--- a/lib/node_modules/@stdlib/math/iter/special/riemann-zeta/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/riemann-zeta/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterZeta( uniform( 1.1, 50.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		'iter': N
 	});
 	it = iterZeta( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 1.1, 50.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = zeta( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterZeta( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterZeta( uniform( 1.1, 50.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterZeta( uniform( 1.1, 50.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/round/test/test.js b/lib/node_modules/@stdlib/math/iter/special/round/test/test.js
index e641cd769a64..2ba542c87bc5 100644
--- a/lib/node_modules/@stdlib/math/iter/special/round/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/round/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterRound( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 
 	N = 101;
 	it = iterRound( linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = round( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterRound( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterRound( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterRound( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/round10/test/test.js b/lib/node_modules/@stdlib/math/iter/special/round10/test/test.js
index 955d9826de47..98491a1b7d5a 100644
--- a/lib/node_modules/@stdlib/math/iter/special/round10/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/round10/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterRound10( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 
 	N = 101;
 	it = iterRound10( linspace( -200.0, 200.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -200.0, 200.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = round10( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterRound10( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterRound10( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterRound10( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/round2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/round2/test/test.js
index 79656e933ed1..4cf3c036e2b5 100644
--- a/lib/node_modules/@stdlib/math/iter/special/round2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/round2/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterRound2( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 
 	N = 101;
 	it = iterRound2( linspace( -200.0, 200.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -200.0, 200.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = round2( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterRound2( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterRound2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterRound2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/rsqrt/test/test.js b/lib/node_modules/@stdlib/math/iter/special/rsqrt/test/test.js
index 8f78a584b8a4..c87734a87c40 100644
--- a/lib/node_modules/@stdlib/math/iter/special/rsqrt/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/rsqrt/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterRsqrt( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterRsqrt( linspace( 0.0, 1000.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 1000.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = rsqrt( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterRsqrt( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterRsqrt( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterRsqrt( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/signum/test/test.js b/lib/node_modules/@stdlib/math/iter/special/signum/test/test.js
index fe2da943ae6d..90b14aadd910 100644
--- a/lib/node_modules/@stdlib/math/iter/special/signum/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/signum/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterSignum( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 
 	N = 101;
 	it = iterSignum( linspace( -10.0, 10.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -10.0, 10.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = signum( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSignum( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSignum( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSignum( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/sin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/sin/test/test.js
index 8923c9fd383d..687db3a1dd97 100644
--- a/lib/node_modules/@stdlib/math/iter/special/sin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/sin/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterSin( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 100;
 	it = iterSin( linspace( 0.0, 6.14, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 6.14, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = sin( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSin( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSin( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSin( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/sinc/test/test.js b/lib/node_modules/@stdlib/math/iter/special/sinc/test/test.js
index f58d4618ca11..41a3d151e458 100644
--- a/lib/node_modules/@stdlib/math/iter/special/sinc/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/sinc/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterSinc( uniform( -5.0, 5.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterSinc( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( -5.0, 5.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = sinc( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSinc( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSinc( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSinc( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/sinh/test/test.js b/lib/node_modules/@stdlib/math/iter/special/sinh/test/test.js
index 1b6a4be0d5a8..6efa1609b04b 100644
--- a/lib/node_modules/@stdlib/math/iter/special/sinh/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/sinh/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterSinh( uniform( -5.0, 5.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		'iter': N
 	});
 	it = iterSinh( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( -5.0, 5.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = sinh( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSinh( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSinh( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSinh( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/sinpi/test/test.js b/lib/node_modules/@stdlib/math/iter/special/sinpi/test/test.js
index 1df3e87adbc2..b5ec26dc3c8e 100644
--- a/lib/node_modules/@stdlib/math/iter/special/sinpi/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/sinpi/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterSinpi( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 100;
 	it = iterSinpi( linspace( 0.0, 50.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 50.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = sinpi( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSinpi( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSinpi( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSinpi( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/spence/test/test.js b/lib/node_modules/@stdlib/math/iter/special/spence/test/test.js
index efc896ff2e18..9e48f30655fe 100644
--- a/lib/node_modules/@stdlib/math/iter/special/spence/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/spence/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterSpence( uniform( 0.0, 100.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		'iter': N
 	});
 	it = iterSpence( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 100.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = spence( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSpence( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSpence( uniform( 0.0, 100.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSpence( uniform( 0.0, 100.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/sqrt/test/test.js b/lib/node_modules/@stdlib/math/iter/special/sqrt/test/test.js
index 94d5a9cd8ff0..d2258bc0f04d 100644
--- a/lib/node_modules/@stdlib/math/iter/special/sqrt/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/sqrt/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterSqrt( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 
 	N = 101;
 	it = iterSqrt( linspace( 0.0, 1000.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( 0.0, 1000.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = sqrt( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSqrt( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSqrt( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSqrt( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/sqrt1pm1/test/test.js b/lib/node_modules/@stdlib/math/iter/special/sqrt1pm1/test/test.js
index 0d2eefa58b4c..da26efcf62e2 100644
--- a/lib/node_modules/@stdlib/math/iter/special/sqrt1pm1/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/sqrt1pm1/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterSqrt1pm1( uniform( 0.0, 100.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterSqrt1pm1( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 100.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = sqrt1pm1( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSqrt1pm1( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSqrt1pm1( uniform( 0.0, 100.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSqrt1pm1( uniform( 0.0, 100.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/tan/test/test.js b/lib/node_modules/@stdlib/math/iter/special/tan/test/test.js
index 2928e9482d44..de569f71fee2 100644
--- a/lib/node_modules/@stdlib/math/iter/special/tan/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/tan/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterTan( uniform( -1.57, 1.57 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		'iter': N
 	});
 	it = iterTan( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( -1.57, 1.57, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = tan( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterTan( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTan( uniform( -1.57, 1.57 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTan( uniform( -1.57, 1.57 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/tanh/test/test.js b/lib/node_modules/@stdlib/math/iter/special/tanh/test/test.js
index e54cde9e1411..45b49a5a04bc 100644
--- a/lib/node_modules/@stdlib/math/iter/special/tanh/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/tanh/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterTanh( uniform( -4.0, 4.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		'iter': N
 	});
 	it = iterTanh( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( -4.0, 4.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = tanh( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterTanh( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTanh( uniform( -4.0, 4.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTanh( uniform( -4.0, 4.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/test/test.js b/lib/node_modules/@stdlib/math/iter/special/test/test.js
index 49eb06763302..a3c40495cb3c 100644
--- a/lib/node_modules/@stdlib/math/iter/special/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/trigamma/test/test.js b/lib/node_modules/@stdlib/math/iter/special/trigamma/test/test.js
index cdef599f5532..522bd2ca1fb0 100644
--- a/lib/node_modules/@stdlib/math/iter/special/trigamma/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/trigamma/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterTrigamma( uniform( 0.01, 50.0 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		'iter': N
 	});
 	it = iterTrigamma( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.01, 50.0, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = trigamma( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterTrigamma( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTrigamma( uniform( 0.01, 50.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTrigamma( uniform( 0.01, 50.0 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/trunc/test/test.js b/lib/node_modules/@stdlib/math/iter/special/trunc/test/test.js
index 421d46db81bd..df37cfc78be2 100644
--- a/lib/node_modules/@stdlib/math/iter/special/trunc/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/trunc/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterTrunc( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 
 	N = 101;
 	it = iterTrunc( linspace( -2.0, 2.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -2.0, 2.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = trunc( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterTrunc( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTrunc( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTrunc( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/trunc10/test/test.js b/lib/node_modules/@stdlib/math/iter/special/trunc10/test/test.js
index 5eda3cd49241..a68615c9510c 100644
--- a/lib/node_modules/@stdlib/math/iter/special/trunc10/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/trunc10/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterTrunc10( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 
 	N = 101;
 	it = iterTrunc10( linspace( -200.0, 200.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -200.0, 200.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = trunc10( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterTrunc10( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTrunc10( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTrunc10( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/trunc2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/trunc2/test/test.js
index 3cdcfb330e08..dc3318e58d7d 100644
--- a/lib/node_modules/@stdlib/math/iter/special/trunc2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/trunc2/test/test.js
@@ -71,12 +71,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterTrunc2( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -91,18 +91,18 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 
 	N = 101;
 	it = iterTrunc2( linspace( -200.0, 200.0, N ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = linspace( -200.0, 200.0, N );
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = trunc2( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,17 +147,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterTrunc2( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -169,20 +169,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTrunc2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTrunc2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/vercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/vercos/test/test.js
index 13b9c937fb5f..7395a483b8a1 100644
--- a/lib/node_modules/@stdlib/math/iter/special/vercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/vercos/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterVercos( uniform( 0.0, 6.28 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterVercos( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 6.28, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = vercos( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterVercos( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterVercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterVercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/versin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/versin/test/test.js
index dabc31357bdf..a014eb6a80bb 100644
--- a/lib/node_modules/@stdlib/math/iter/special/versin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/versin/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterVersin( uniform( 0.0, 6.28 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		'iter': N
 	});
 	it = iterVersin( rand );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	x = uniform( 0.0, 6.28, {
 		'iter': N,
@@ -103,12 +103,12 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 	for ( i = 0; i < N; i++ ) {
 		r = it.next();
 		expected = versin( x.next().value );
-		t.equal( r.value, expected, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,17 +153,17 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterVersin( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		r = expected[ i ].value;
 		if ( r === r ) {
-			t.equal( actual.value, r, 'returns expected value' );
+			t.strictEqual( actual.value, r, 'returns expected value' );
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
 	}
 	t.end();
 });
@@ -175,20 +175,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterVersin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -200,20 +200,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterVersin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/test/test.js b/lib/node_modules/@stdlib/math/iter/test/test.js
index 49eb06763302..a3c40495cb3c 100644
--- a/lib/node_modules/@stdlib/math/iter/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/tools/map/test/test.js b/lib/node_modules/@stdlib/math/iter/tools/map/test/test.js
index 072d12f8e9f5..de91d0ebc27c 100644
--- a/lib/node_modules/@stdlib/math/iter/tools/map/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/tools/map/test/test.js
@@ -128,12 +128,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterMap( randu(), sin );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -151,19 +151,19 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 	};
 	rand = randu( opts );
 	it = iterMap( rand, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < opts.iter; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, opts.iter, 'has expected length' );
+	t.strictEqual( expected.length, opts.iter, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -184,12 +184,12 @@ tape( 'the function supports specifying a return value for when an input iterato
 		'invalid': null
 	};
 	it = iterMap( map( randu(), toString ), scale, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( r.value, null, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, null, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 
@@ -209,20 +209,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMap( randu(), sin );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -234,20 +234,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMap( randu(), sin );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -271,16 +271,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterMap( rand, sin );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -298,7 +298,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterMap( randu(), sin );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -316,7 +316,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterMap( rand, sin );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/tools/map2/test/test.js b/lib/node_modules/@stdlib/math/iter/tools/map2/test/test.js
index 0f4354172a37..bc310d236d6a 100644
--- a/lib/node_modules/@stdlib/math/iter/tools/map2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/tools/map2/test/test.js
@@ -156,12 +156,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterMap2( randu(), randu(), copysign );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -172,12 +172,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalars)', fu
 	var i;
 
 	it = iterMap2( 4.0, -3.0, copysign );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( v.value, -4.0, 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( v.value, -4.0, 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -212,7 +212,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	it1 = array2iterator( values2 );
 
 	it = iterMap2( it0, it1, copysign );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -250,7 +250,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	scalar = -4.0;
 
 	it = iterMap2( it0, scalar, copysign );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -288,7 +288,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	it1 = array2iterator( values1 );
 
 	it = iterMap2( scalar, it1, copysign );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -328,7 +328,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	it1 = array2iterator( values2 );
 
 	it = iterMap2( it0, it1, copysign );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -368,7 +368,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	it1 = array2iterator( values2 );
 
 	it = iterMap2( it0, it1, copysign );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -390,7 +390,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	];
 
 	it = iterMap2( iterEmpty(), iterEmpty(), copysign );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -429,16 +429,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	it1 = array2iterator( values2 );
 
 	it = iterMap2( it0, it1, copysign );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -473,16 +473,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	it1 = array2iterator( values2 );
 
 	it = iterMap2( it0, it1, copysign );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -497,12 +497,12 @@ tape( 'the function supports specifying a return value for when an input iterato
 		'invalid': null
 	};
 	it = iterMap2( map( randu(), toString ), randu(), scale, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( r.value, null, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, null, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 
@@ -522,20 +522,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMap2( randu(), randu(), copysign );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -547,20 +547,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMap2( randu(), randu(), copysign );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -589,16 +589,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	rand2[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterMap2( rand1, rand2, copysign );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -618,16 +618,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	});
 
 	it1 = iterMap2( 4.0, 3.0, copysign );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -641,7 +641,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterMap2( randu(), randu(), copysign );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -659,7 +659,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterMap2( rand, rand, copysign );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/tools/map3/test/test.js b/lib/node_modules/@stdlib/math/iter/tools/map3/test/test.js
index be0c571c7f3e..81309c11ee5a 100644
--- a/lib/node_modules/@stdlib/math/iter/tools/map3/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/tools/map3/test/test.js
@@ -183,12 +183,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterMap3( randu(), randu(), randu(), clamp );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -199,12 +199,12 @@ tape( 'the function returns an iterator protocol-compliant object (scalars)', fu
 	var i;
 
 	it = iterMap3( 4.0, -3.0, 2.0, clamp );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( v.value, 2.0, 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( v.value, 2.0, 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -243,7 +243,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	it2 = array2iterator( values3 );
 
 	it = iterMap3( it0, it1, it2, clamp );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -285,7 +285,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	scalar = -4.0;
 
 	it = iterMap3( it0, scalar, it2, clamp );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -327,7 +327,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	it2 = array2iterator( values2 );
 
 	it = iterMap3( scalar, it1, it2, clamp );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -371,7 +371,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	it2 = array2iterator( values3 );
 
 	it = iterMap3( it0, it1, it2, clamp );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -415,7 +415,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	it2 = array2iterator( values3 );
 
 	it = iterMap3( it0, it1, it2, clamp );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -437,7 +437,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	];
 
 	it = iterMap3( iterEmpty(), iterEmpty(), iterEmpty(), clamp );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -480,16 +480,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	it2 = array2iterator( values3 );
 
 	it = iterMap3( it0, it1, it2, clamp );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -528,16 +528,16 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	it2 = array2iterator( values3 );
 
 	it = iterMap3( it0, it1, it2, clamp );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
 		if ( isnan( expected[ i ].value ) ) {
-			t.equal( isnan( actual.value ), true, 'returns expected value' );
+			t.strictEqual( isnan( actual.value ), true, 'returns expected value' );
 		} else {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		}
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -552,12 +552,12 @@ tape( 'the function supports specifying a return value for when an input iterato
 		'invalid': null
 	};
 	it = iterMap3( map( randu(), toString ), randu(), randu(), scale, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( r.value, null, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, null, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 
@@ -577,20 +577,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMap3( randu(), randu(), randu(), clamp );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -602,20 +602,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMap3( randu(), randu(), randu(), clamp );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -648,16 +648,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	rand3[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterMap3( rand1, rand2, rand3, clamp );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -677,16 +677,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	});
 
 	it1 = iterMap3( 4.0, 3.0, 5.0, clamp );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -700,7 +700,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterMap3( randu(), randu(), randu(), clamp );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -718,7 +718,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterMap3( rand, rand, rand, clamp );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/tools/test/test.js b/lib/node_modules/@stdlib/math/iter/tools/test/test.js
index 4703875b1edd..e682e93dba4d 100644
--- a/lib/node_modules/@stdlib/math/iter/tools/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/tools/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/utils/test/test.js b/lib/node_modules/@stdlib/math/iter/utils/test/test.js
index 9931b3a8638f..da72de67868b 100644
--- a/lib/node_modules/@stdlib/math/iter/utils/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/utils/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/special/test/test.js b/lib/node_modules/@stdlib/math/special/test/test.js
index 4e371cb599bd..035d37a30f27 100644
--- a/lib/node_modules/@stdlib/math/special/test/test.js
+++ b/lib/node_modules/@stdlib/math/special/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains strided array interfaces', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/strided/ops/test/test.js b/lib/node_modules/@stdlib/math/strided/ops/test/test.js
index f57880316e3f..ba13d88a29c8 100644
--- a/lib/node_modules/@stdlib/math/strided/ops/test/test.js
+++ b/lib/node_modules/@stdlib/math/strided/ops/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains strided array interfaces', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/strided/special/test/test.js b/lib/node_modules/@stdlib/math/strided/special/test/test.js
index 4e371cb599bd..035d37a30f27 100644
--- a/lib/node_modules/@stdlib/math/strided/special/test/test.js
+++ b/lib/node_modules/@stdlib/math/strided/special/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains strided array interfaces', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/strided/test/test.js b/lib/node_modules/@stdlib/math/strided/test/test.js
index 630b5b5a6ff7..76eceb93c544 100644
--- a/lib/node_modules/@stdlib/math/strided/test/test.js
+++ b/lib/node_modules/@stdlib/math/strided/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/test/test.js b/lib/node_modules/@stdlib/math/test/test.js
index c6af10804d93..8ee77b9a188b 100644
--- a/lib/node_modules/@stdlib/math/test/test.js
+++ b/lib/node_modules/@stdlib/math/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( math );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/tools/test/test.js b/lib/node_modules/@stdlib/math/tools/test/test.js
index 14b2e3cb37f1..673646932c2b 100644
--- a/lib/node_modules/@stdlib/math/tools/test/test.js
+++ b/lib/node_modules/@stdlib/math/tools/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains math tools', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });

From a147b7d6ef754925120fcc7bdec2b40842a3615a Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Tue, 12 Aug 2025 21:55:45 -0500
Subject: [PATCH 04/32] test: use .strictEqual() instead of .equal() and fix
 lint errors

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/array/base/assert/test/test.js    |   2 +-
 .../@stdlib/array/base/banded/test/test.js    |   2 +-
 .../@stdlib/array/base/binary2d/test/test.js  |   4 +-
 .../@stdlib/array/base/binary3d/test/test.js  |   6 +-
 .../@stdlib/array/base/binary4d/test/test.js  |   8 +-
 .../@stdlib/array/base/binary5d/test/test.js  |  10 +-
 .../@stdlib/array/base/binarynd/test/test.js  |  30 +-
 .../base/broadcasted-binary2d/test/test.js    |   4 +-
 .../base/broadcasted-binary3d/test/test.js    |   6 +-
 .../base/broadcasted-binary4d/test/test.js    |   8 +-
 .../base/broadcasted-binary5d/test/test.js    |  10 +-
 .../broadcasted-quaternary2d/test/test.js     |   4 +-
 .../broadcasted-quaternary3d/test/test.js     |   6 +-
 .../broadcasted-quaternary4d/test/test.js     |   8 +-
 .../broadcasted-quaternary5d/test/test.js     |  10 +-
 .../base/broadcasted-quinary2d/test/test.js   |   4 +-
 .../base/broadcasted-quinary4d/test/test.js   |   8 +-
 .../base/broadcasted-ternary2d/test/test.js   |   4 +-
 .../base/broadcasted-ternary3d/test/test.js   |   6 +-
 .../base/broadcasted-ternary4d/test/test.js   |   8 +-
 .../base/broadcasted-ternary5d/test/test.js   |  10 +-
 .../base/broadcasted-unary2d/test/test.js     |   4 +-
 .../base/broadcasted-unary3d/test/test.js     |   6 +-
 .../base/broadcasted-unary4d/test/test.js     |   8 +-
 .../base/broadcasted-unary5d/test/test.js     |  10 +-
 .../array/base/filled2d-by/test/test.js       |   4 +-
 .../@stdlib/array/base/filled2d/test/test.js  |   4 +-
 .../array/base/filled3d-by/test/test.js       |   6 +-
 .../@stdlib/array/base/filled3d/test/test.js  |   6 +-
 .../array/base/filled4d-by/test/test.js       |   8 +-
 .../@stdlib/array/base/filled4d/test/test.js  |   8 +-
 .../array/base/filled5d-by/test/test.js       |  10 +-
 .../@stdlib/array/base/filled5d/test/test.js  |  10 +-
 .../array/base/fillednd-by/test/test.js       |  30 +-
 .../@stdlib/array/base/fillednd/test/test.js  |  30 +-
 .../@stdlib/array/base/first/test/test.js     |   2 +-
 .../@stdlib/array/base/incrspace/test/test.js |   2 +-
 .../@stdlib/array/base/index-of/test/test.js  |   2 +-
 .../array/base/last-index-of/test/test.js     |   2 +-
 .../@stdlib/array/base/last/test/test.js      |   2 +-
 .../array/base/map2d/test/test.assign.js      |   4 +-
 .../array/base/map2d/test/test.main.js        |   4 +-
 .../array/base/map3d/test/test.assign.js      |   6 +-
 .../array/base/map3d/test/test.main.js        |   6 +-
 .../array/base/map4d/test/test.assign.js      |   8 +-
 .../array/base/map4d/test/test.main.js        |   8 +-
 .../array/base/map5d/test/test.assign.js      |  10 +-
 .../array/base/map5d/test/test.main.js        |  10 +-
 .../array/base/mskbinary2d/test/test.js       |   4 +-
 .../array/base/mskbinary3d/test/test.js       |   6 +-
 .../array/base/mskbinary4d/test/test.js       |   8 +-
 .../array/base/mskbinary5d/test/test.js       |  10 +-
 .../array/base/mskunary2d/test/test.js        |   4 +-
 .../array/base/mskunary3d/test/test.js        |   6 +-
 .../array/base/mskunary4d/test/test.js        |   8 +-
 .../array/base/mskunary5d/test/test.js        |  10 +-
 .../@stdlib/array/base/ones2d/test/test.js    |   4 +-
 .../@stdlib/array/base/ones3d/test/test.js    |   6 +-
 .../@stdlib/array/base/ones4d/test/test.js    |   8 +-
 .../@stdlib/array/base/ones5d/test/test.js    |  10 +-
 .../@stdlib/array/base/onesnd/test/test.js    |  30 +-
 .../array/base/quaternary2d/test/test.js      |   4 +-
 .../array/base/quaternary3d/test/test.js      |   6 +-
 .../array/base/quaternary4d/test/test.js      |   8 +-
 .../array/base/quaternary5d/test/test.js      |  10 +-
 .../@stdlib/array/base/quinary2d/test/test.js |   4 +-
 .../@stdlib/array/base/quinary3d/test/test.js |   6 +-
 .../@stdlib/array/base/quinary4d/test/test.js |   8 +-
 .../@stdlib/array/base/quinary5d/test/test.js |  10 +-
 .../symmetric-banded/filled2d-by/test/test.js |   2 +-
 .../array/base/symmetric-banded/test/test.js  |   2 +-
 .../base/symmetric/filled2d-by/test/test.js   |   2 +-
 .../@stdlib/array/base/symmetric/test/test.js |   2 +-
 .../@stdlib/array/base/ternary2d/test/test.js |   4 +-
 .../@stdlib/array/base/ternary3d/test/test.js |   6 +-
 .../@stdlib/array/base/ternary4d/test/test.js |   8 +-
 .../@stdlib/array/base/ternary5d/test/test.js |  10 +-
 .../@stdlib/array/base/test/test.js           |   2 +-
 .../array/base/unary2d-by/test/test.js        |   4 +-
 .../@stdlib/array/base/unary2d/test/test.js   |   4 +-
 .../array/base/unary3d-by/test/test.js        |   6 +-
 .../@stdlib/array/base/unary3d/test/test.js   |   6 +-
 .../array/base/unary4d-by/test/test.js        |   8 +-
 .../@stdlib/array/base/unary4d/test/test.js   |   8 +-
 .../array/base/unary5d-by/test/test.js        |  10 +-
 .../@stdlib/array/base/unary5d/test/test.js   |  10 +-
 .../@stdlib/array/base/unarynd/test/test.js   |  30 +-
 .../@stdlib/array/base/zeros2d/test/test.js   |   4 +-
 .../@stdlib/array/base/zeros3d/test/test.js   |   6 +-
 .../@stdlib/array/base/zeros4d/test/test.js   |   8 +-
 .../@stdlib/array/base/zeros5d/test/test.js   |  10 +-
 .../@stdlib/array/base/zerosnd/test/test.js   |  30 +-
 .../@stdlib/array/from-iterator/test/test.js  |  22 +-
 .../@stdlib/array/incrspace/test/test.js      |   2 +-
 .../array/linspace/test/test.validate.js      |  10 +-
 lib/node_modules/@stdlib/array/test/test.js   |   2 +-
 .../array/to-circular-iterator/test/test.js   | 158 ++++-----
 .../array/to-iterator-right/test/test.js      | 128 +++----
 .../@stdlib/array/to-iterator/test/test.js    | 156 ++++-----
 .../to-sparse-iterator-right/test/test.js     | 163 ++++-----
 .../array/to-sparse-iterator/test/test.js     | 163 ++++-----
 .../array/to-strided-iterator/test/test.js    | 132 ++++----
 .../array/to-view-iterator-right/test/test.js | 320 +++++++++---------
 .../array/to-view-iterator/test/test.js       | 320 +++++++++---------
 .../utils/async/parallel/test/test.factory.js |   4 +-
 .../series-waterfall/test/test.factory.js     |  16 +-
 .../async/series-waterfall/test/test.main.js  |  14 +-
 .../@stdlib/utils/async/test/test.js          |   2 +-
 .../utils/constant-function/test/test.js      |   6 +-
 .../utils/constructor-name/test/test.js       |  18 +-
 .../utils/copy/test/test.copy_error.js        | 110 +++---
 .../@stdlib/utils/copy/test/test.deep_copy.js |  26 +-
 .../@stdlib/utils/copy/test/test.js           |   6 +-
 .../@stdlib/utils/decorate-after/test/test.js |   2 +-
 .../@stdlib/utils/deep-get/test/test.dget.js  |   4 +-
 .../utils/deep-get/test/test.factory.js       |   4 +-
 .../@stdlib/utils/deep-get/test/test.js       |   4 +-
 .../utils/deep-get/test/test.validate.js      |  10 +-
 .../@stdlib/utils/deep-pluck/test/test.js     |   7 +-
 .../utils/deep-pluck/test/test.validate.js    |  17 +-
 .../@stdlib/utils/deep-set/test/test.dset.js  |  14 +-
 .../utils/deep-set/test/test.factory.js       |  14 +-
 .../@stdlib/utils/deep-set/test/test.js       |  12 +-
 .../utils/deep-set/test/test.validate.js      |  18 +-
 .../test/test.js                              |  10 +-
 .../test/test.js                              |  10 +-
 .../test/test.js                              |  14 +-
 .../test/test.js                              |  16 +-
 .../test/test.js                              |  24 +-
 .../define-memoized-property/test/test.js     |  62 ++--
 .../test/test.js                              |  24 +-
 .../test/test.js                              |  10 +-
 .../test/test.js                              |   4 +-
 .../test/test.js                              |   4 +-
 .../test/test.js                              |   8 +-
 .../test/test.js                              |  12 +-
 .../utils/define-properties/test/test.js      |   4 +-
 .../utils/define-property/test/test.js        |   6 +-
 .../define-property/test/test.polyfill.js     |   4 +-
 .../define-read-only-accessor/test/test.js    |   4 +-
 .../define-read-only-property/test/test.js    |   4 +-
 .../define-read-write-accessor/test/test.js   |   8 +-
 .../define-write-only-accessor/test/test.js   |  12 +-
 .../@stdlib/utils/dirname/test/test.js        |   2 +-
 .../@stdlib/utils/dsv/base/parse/test/test.js |   8 +-
 .../@stdlib/utils/dsv/base/test/test.js       |   2 +-
 .../@stdlib/utils/dsv/test/test.js            |   2 +-
 .../@stdlib/utils/eval/test/test.js           |   2 +-
 .../@stdlib/utils/extname/test/test.js        |   2 +-
 .../utils/flatten-array/test/test.factory.js  |   4 +-
 .../@stdlib/utils/flatten-array/test/test.js  |   2 +-
 .../utils/flatten-array/test/test.main.js     |   4 +-
 .../utils/flatten-array/test/test.validate.js |  10 +-
 .../utils/flatten-object/test/test.factory.js |   6 +-
 .../@stdlib/utils/flatten-object/test/test.js |   2 +-
 .../utils/flatten-object/test/test.main.js    |   4 +-
 .../flatten-object/test/test.validate.js      |  14 +-
 .../@stdlib/utils/function-name/test/test.js  |  24 +-
 .../get-prototype-of/test/test.detect.js      |   6 +-
 .../utils/get-prototype-of/test/test.js       |  14 +-
 .../get-prototype-of/test/test.native.js      |  10 +-
 .../get-prototype-of/test/test.polyfill.js    |  18 +-
 .../utils/identity-function/test/test.js      |   4 +-
 .../@stdlib/utils/index-of/test/test.js       |  42 +--
 .../test/test.is_constructor_prototype.js     |   2 +-
 .../test.is_constructor_prototype_wrapper.js  |   8 +-
 .../@stdlib/utils/merge/test/test.defaults.js |   2 +-
 .../@stdlib/utils/merge/test/test.factory.js  |  30 +-
 .../@stdlib/utils/merge/test/test.js          |   2 +-
 .../@stdlib/utils/merge/test/test.main.js     |  14 +-
 .../@stdlib/utils/merge/test/test.validate.js |  18 +-
 .../@stdlib/utils/move-property/test/test.js  |   6 +-
 .../@stdlib/utils/noop/test/test.js           |   6 +-
 .../utils/open-url/test/test.browser.js       |   2 +-
 .../@stdlib/utils/open-url/test/test.js       |  18 +-
 .../@stdlib/utils/parallel/test/test.main.js  |   7 +-
 .../utils/parallel/test/test.node.env.js      |  14 +-
 .../utils/parallel/test/test.node.exec.js     |  27 +-
 .../utils/parallel/test/test.node.options.js  |  12 +-
 .../parallel/test/test.node.worker.close.js   |   4 +-
 .../parallel/test/test.node.worker.exec.js    |  10 +-
 .../parallel/test/test.node.worker.spawn.js   |  34 +-
 .../parallel/test/test.node.worker.worker.js  |   2 +-
 .../utils/parallel/test/test.validate.js      |  20 +-
 .../@stdlib/utils/parse-json/test/test.js     |   8 +-
 .../@stdlib/utils/parse-ndjson/test/test.js   |   2 +-
 .../@stdlib/utils/pluck/test/test.js          |   6 +-
 .../@stdlib/utils/pluck/test/test.validate.js |   8 +-
 .../@stdlib/utils/reduce2d/test/test.js       |   2 +-
 .../utils/regexp-from-string/test/test.js     |   4 +-
 .../@stdlib/utils/some-own-by/test/test.js    |   6 +-
 lib/node_modules/@stdlib/utils/test/test.js   |   2 +-
 .../utils/timeit/test/test.validate.js        |  16 +-
 .../@stdlib/utils/type-of/test/test.check.js  |   8 +-
 .../@stdlib/utils/type-of/test/test.js        |  20 +-
 .../@stdlib/utils/type-of/test/test.main.js   |  16 +-
 .../utils/type-of/test/test.polyfill.js       |  16 +-
 197 files changed, 1691 insertions(+), 1687 deletions(-)

diff --git a/lib/node_modules/@stdlib/array/base/assert/test/test.js b/lib/node_modules/@stdlib/array/base/assert/test/test.js
index 9931b3a8638f..da72de67868b 100644
--- a/lib/node_modules/@stdlib/array/base/assert/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/assert/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/base/banded/test/test.js b/lib/node_modules/@stdlib/array/base/banded/test/test.js
index d1e6eeb4039e..30bee535777f 100644
--- a/lib/node_modules/@stdlib/array/base/banded/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/banded/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'returns expected value' );
+	t.strictEqual( keys.length > 0, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/base/binary2d/test/test.js b/lib/node_modules/@stdlib/array/base/binary2d/test/test.js
index 684b9e5e74f9..2db3435c9c6e 100644
--- a/lib/node_modules/@stdlib/array/base/binary2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/binary2d/test/test.js
@@ -62,7 +62,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -91,7 +91,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/binary3d/test/test.js b/lib/node_modules/@stdlib/array/base/binary3d/test/test.js
index 0ea9818a451e..5ecc98174f87 100644
--- a/lib/node_modules/@stdlib/array/base/binary3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/binary3d/test/test.js
@@ -80,7 +80,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -121,7 +121,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -162,7 +162,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/binary4d/test/test.js b/lib/node_modules/@stdlib/array/base/binary4d/test/test.js
index a9009f785b44..f65cdc59ef47 100644
--- a/lib/node_modules/@stdlib/array/base/binary4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/binary4d/test/test.js
@@ -86,7 +86,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -131,7 +131,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -176,7 +176,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -221,7 +221,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a four element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a four element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/binary5d/test/test.js b/lib/node_modules/@stdlib/array/base/binary5d/test/test.js
index 08603c2d67e3..df50205153fd 100644
--- a/lib/node_modules/@stdlib/array/base/binary5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/binary5d/test/test.js
@@ -92,7 +92,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -141,7 +141,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -190,7 +190,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -239,7 +239,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a four element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a four element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -288,7 +288,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/binarynd/test/test.js b/lib/node_modules/@stdlib/array/base/binarynd/test/test.js
index 7760e2534a41..b11aa76faedf 100644
--- a/lib/node_modules/@stdlib/array/base/binarynd/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/binarynd/test/test.js
@@ -569,7 +569,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero (1d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero (1d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -593,7 +593,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero (2d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero (2d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -620,7 +620,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero (2d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero (2d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -647,7 +647,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero (3d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -680,7 +680,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero (3d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -713,7 +713,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero (3d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -746,7 +746,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero (4d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -791,7 +791,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero (4d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -836,7 +836,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero (4d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -881,7 +881,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero (4d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -926,7 +926,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero (5d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -995,7 +995,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero (5d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -1064,7 +1064,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero (5d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -1133,7 +1133,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero (5d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -1202,7 +1202,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fifth element equal to zero (5d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fifth element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-binary2d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-binary2d/test/test.js
index e2d6c5aaf7c0..8b65a7233e72 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-binary2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-binary2d/test/test.js
@@ -104,7 +104,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -134,7 +134,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-binary3d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-binary3d/test/test.js
index f8ca937d8d6b..f8162d83f262 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-binary3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-binary3d/test/test.js
@@ -134,7 +134,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -166,7 +166,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -198,7 +198,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-binary4d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-binary4d/test/test.js
index e9e3ff467329..9ac5ed05fd9b 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-binary4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-binary4d/test/test.js
@@ -194,7 +194,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -228,7 +228,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -262,7 +262,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -296,7 +296,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a four element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a four element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-binary5d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-binary5d/test/test.js
index 08b289aea7fb..f226f902666b 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-binary5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-binary5d/test/test.js
@@ -248,7 +248,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -284,7 +284,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -320,7 +320,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -356,7 +356,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a four element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a four element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -392,7 +392,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-quaternary2d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-quaternary2d/test/test.js
index 6deb9c3ae896..c77d256535be 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-quaternary2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-quaternary2d/test/test.js
@@ -127,7 +127,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -163,7 +163,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-quaternary3d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-quaternary3d/test/test.js
index 151d76bda189..e76ceb0552cf 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-quaternary3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-quaternary3d/test/test.js
@@ -169,7 +169,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -207,7 +207,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -245,7 +245,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-quaternary4d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-quaternary4d/test/test.js
index bc8b5f23c02f..498222ca4999 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-quaternary4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-quaternary4d/test/test.js
@@ -253,7 +253,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -291,7 +291,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -329,7 +329,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -367,7 +367,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-quaternary5d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-quaternary5d/test/test.js
index fb84d5de480a..764f00d545bb 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-quaternary5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-quaternary5d/test/test.js
@@ -261,7 +261,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -299,7 +299,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -337,7 +337,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -375,7 +375,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -413,7 +413,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-quinary2d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-quinary2d/test/test.js
index 16aa95ba3d4a..8cfedaf3513a 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-quinary2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-quinary2d/test/test.js
@@ -157,7 +157,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -196,7 +196,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-quinary4d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-quinary4d/test/test.js
index 11f4b65a13b8..09936120a86d 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-quinary4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-quinary4d/test/test.js
@@ -296,7 +296,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -353,7 +353,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -410,7 +410,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -467,7 +467,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-ternary2d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-ternary2d/test/test.js
index 1171bda74bb1..6b9dd91197e8 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-ternary2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-ternary2d/test/test.js
@@ -114,7 +114,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
@@ -147,7 +147,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-ternary3d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-ternary3d/test/test.js
index 3801e65a0592..bfba035fb60b 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-ternary3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-ternary3d/test/test.js
@@ -160,7 +160,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -195,7 +195,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -230,7 +230,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-ternary4d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-ternary4d/test/test.js
index e0ac1cf4a78d..084b5f13f98e 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-ternary4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-ternary4d/test/test.js
@@ -149,7 +149,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -186,7 +186,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -223,7 +223,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -260,7 +260,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a forth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a forth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-ternary5d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-ternary5d/test/test.js
index 44f857dee43b..e8b11f7ddd9c 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-ternary5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-ternary5d/test/test.js
@@ -133,7 +133,7 @@ tape( 'the function applies a provided callback to broadcasted input arrays and
 	t.end();
 } );
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero ', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero ', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -172,7 +172,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 } );
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero ', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero ', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -211,7 +211,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 } );
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a third element equal to zero ', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a third element.strictEqual to zero ', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -250,7 +250,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 } );
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a fourth element equal to zero ', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a fourth element.strictEqual to zero ', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -289,7 +289,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 } );
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a fifth element equal to zero ', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a fifth element.strictEqual to zero ', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-unary2d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-unary2d/test/test.js
index fbd7fae9b60b..1ef03381674e 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-unary2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-unary2d/test/test.js
@@ -99,7 +99,7 @@ tape( 'the function applies a provided callback to a broadcasted input array and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -127,7 +127,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-unary3d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-unary3d/test/test.js
index 004387346c96..edc74610fcc2 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-unary3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-unary3d/test/test.js
@@ -143,7 +143,7 @@ tape( 'the function applies a provided callback to a broadcasted input array and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -177,7 +177,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -211,7 +211,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-unary4d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-unary4d/test/test.js
index f795506bb546..ae8d67947402 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-unary4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-unary4d/test/test.js
@@ -225,7 +225,7 @@ tape( 'the function applies a provided callback to a broadcasted input array and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -261,7 +261,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -297,7 +297,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -333,7 +333,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/broadcasted-unary5d/test/test.js b/lib/node_modules/@stdlib/array/base/broadcasted-unary5d/test/test.js
index 476c9f57aebb..56473c0ce3b8 100644
--- a/lib/node_modules/@stdlib/array/base/broadcasted-unary5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/broadcasted-unary5d/test/test.js
@@ -349,7 +349,7 @@ tape( 'the function applies a provided callback to a broadcasted input array and
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -387,7 +387,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -425,7 +425,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -463,7 +463,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
@@ -501,7 +501,7 @@ tape( 'the function does not invoke a provided callback if provided an output sh
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided an output shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided an output shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shapes;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/filled2d-by/test/test.js b/lib/node_modules/@stdlib/array/base/filled2d-by/test/test.js
index b62218d2ac9c..ea3434aab16d 100644
--- a/lib/node_modules/@stdlib/array/base/filled2d-by/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/filled2d-by/test/test.js
@@ -52,7 +52,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -71,7 +71,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/filled2d/test/test.js b/lib/node_modules/@stdlib/array/base/filled2d/test/test.js
index d1b8f7f5850e..88ceef8bfd4b 100644
--- a/lib/node_modules/@stdlib/array/base/filled2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/filled2d/test/test.js
@@ -51,7 +51,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -69,7 +69,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/filled3d-by/test/test.js b/lib/node_modules/@stdlib/array/base/filled3d-by/test/test.js
index 44f2f3aead3d..5f2dff286ec3 100644
--- a/lib/node_modules/@stdlib/array/base/filled3d-by/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/filled3d-by/test/test.js
@@ -71,7 +71,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -90,7 +90,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -109,7 +109,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/filled3d/test/test.js b/lib/node_modules/@stdlib/array/base/filled3d/test/test.js
index 8f684b355cb2..0b730d3c1c76 100644
--- a/lib/node_modules/@stdlib/array/base/filled3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/filled3d/test/test.js
@@ -77,7 +77,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -95,7 +95,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -114,7 +114,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/filled4d-by/test/test.js b/lib/node_modules/@stdlib/array/base/filled4d-by/test/test.js
index 3da2ad9c2e78..11b2b7fcccf9 100644
--- a/lib/node_modules/@stdlib/array/base/filled4d-by/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/filled4d-by/test/test.js
@@ -87,7 +87,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -106,7 +106,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -125,7 +125,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -163,7 +163,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/filled4d/test/test.js b/lib/node_modules/@stdlib/array/base/filled4d/test/test.js
index 19aca3089801..ddc4de1b81da 100644
--- a/lib/node_modules/@stdlib/array/base/filled4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/filled4d/test/test.js
@@ -95,7 +95,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -113,7 +113,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -132,7 +132,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -166,7 +166,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/filled5d-by/test/test.js b/lib/node_modules/@stdlib/array/base/filled5d-by/test/test.js
index 7aa4c91ff981..fac489a486ad 100644
--- a/lib/node_modules/@stdlib/array/base/filled5d-by/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/filled5d-by/test/test.js
@@ -124,7 +124,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -143,7 +143,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -162,7 +162,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -200,7 +200,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -240,7 +240,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a four
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/filled5d/test/test.js b/lib/node_modules/@stdlib/array/base/filled5d/test/test.js
index 9e0fb6d80087..43c3eb9f1bfa 100644
--- a/lib/node_modules/@stdlib/array/base/filled5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/filled5d/test/test.js
@@ -115,7 +115,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -133,7 +133,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -152,7 +152,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -186,7 +186,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -220,7 +220,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a four
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/fillednd-by/test/test.js b/lib/node_modules/@stdlib/array/base/fillednd-by/test/test.js
index 571da2231539..d43b541e1bb6 100644
--- a/lib/node_modules/@stdlib/array/base/fillednd-by/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/fillednd-by/test/test.js
@@ -265,7 +265,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty array if provided a shape having a first element equal to zero (1d)', function test( t ) {
+tape( 'the function returns an empty array if provided a shape having a first element.strictEqual to zero (1d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -277,7 +277,7 @@ tape( 'the function returns an empty array if provided a shape having a first el
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (2d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (2d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -295,7 +295,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (2d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (2d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -314,7 +314,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (3d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -332,7 +332,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (3d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -351,7 +351,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero (3d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -370,7 +370,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (4d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -388,7 +388,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (4d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -407,7 +407,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero (4d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -441,7 +441,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero (4d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -475,7 +475,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a four
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (5d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -493,7 +493,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -512,7 +512,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -546,7 +546,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -580,7 +580,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a four
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fifth element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fifth element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/fillednd/test/test.js b/lib/node_modules/@stdlib/array/base/fillednd/test/test.js
index 519cd1711bf0..7e4622fb6e42 100644
--- a/lib/node_modules/@stdlib/array/base/fillednd/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/fillednd/test/test.js
@@ -264,7 +264,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty array if provided a shape having a first element equal to zero (1d)', function test( t ) {
+tape( 'the function returns an empty array if provided a shape having a first element.strictEqual to zero (1d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -276,7 +276,7 @@ tape( 'the function returns an empty array if provided a shape having a first el
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (2d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (2d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -294,7 +294,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (2d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (2d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -313,7 +313,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (3d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -331,7 +331,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (3d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -350,7 +350,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero (3d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -369,7 +369,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (4d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -387,7 +387,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (4d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -406,7 +406,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero (4d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -440,7 +440,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero (4d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -474,7 +474,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a four
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (5d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -492,7 +492,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -511,7 +511,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -545,7 +545,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -579,7 +579,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a four
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fifth element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fifth element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/first/test/test.js b/lib/node_modules/@stdlib/array/base/first/test/test.js
index b37f73f91e52..ebbb5bcd8f49 100644
--- a/lib/node_modules/@stdlib/array/base/first/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/first/test/test.js
@@ -44,7 +44,7 @@ tape( 'the function returns the first element of an array-like object', function
 	expected = 1;
 	actual = first( x );
 
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/array/base/incrspace/test/test.js b/lib/node_modules/@stdlib/array/base/incrspace/test/test.js
index eaf424bf2ee5..838819d576fe 100644
--- a/lib/node_modules/@stdlib/array/base/incrspace/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/incrspace/test/test.js
@@ -56,7 +56,7 @@ tape( 'the function returns a linearly spaced array', function test( t ) {
 
 	// Large array:
 	actual = incrspace( start, 1e6, 1 );
-	t.equal( actual.length, 1e6, 'returns expected value' );
+	t.strictEqual( actual.length, 1e6, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/base/index-of/test/test.js b/lib/node_modules/@stdlib/array/base/index-of/test/test.js
index b8c19a18c67c..da0c5ddc15d6 100644
--- a/lib/node_modules/@stdlib/array/base/index-of/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/index-of/test/test.js
@@ -288,7 +288,7 @@ tape( 'the function returns `-1` if provided an empty array', function test( t )
 	t.end();
 });
 
-tape( 'the function returns `-1` if provided a search element equal to `NaN`', function test( t ) {
+tape( 'the function returns `-1` if provided a search element.strictEqual to `NaN`', function test( t ) {
 	var actual;
 	var x;
 
diff --git a/lib/node_modules/@stdlib/array/base/last-index-of/test/test.js b/lib/node_modules/@stdlib/array/base/last-index-of/test/test.js
index 89c67779cfd1..81d51f189f80 100644
--- a/lib/node_modules/@stdlib/array/base/last-index-of/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/last-index-of/test/test.js
@@ -303,7 +303,7 @@ tape( 'the function returns `-1` if provided an empty array', function test( t )
 	t.end();
 });
 
-tape( 'the function returns `-1` if provided a search element equal to `NaN`', function test( t ) {
+tape( 'the function returns `-1` if provided a search element.strictEqual to `NaN`', function test( t ) {
 	var actual;
 	var x;
 
diff --git a/lib/node_modules/@stdlib/array/base/last/test/test.js b/lib/node_modules/@stdlib/array/base/last/test/test.js
index 0d4a4c24333a..6353f67919e3 100644
--- a/lib/node_modules/@stdlib/array/base/last/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/last/test/test.js
@@ -44,7 +44,7 @@ tape( 'the function returns the last element of an array-like object', function
 	expected = 3;
 	actual = last( x );
 
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/array/base/map2d/test/test.assign.js b/lib/node_modules/@stdlib/array/base/map2d/test/test.assign.js
index 6512ab8ac131..7d8c171144e7 100644
--- a/lib/node_modules/@stdlib/array/base/map2d/test/test.assign.js
+++ b/lib/node_modules/@stdlib/array/base/map2d/test/test.assign.js
@@ -61,7 +61,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -88,7 +88,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/map2d/test/test.main.js b/lib/node_modules/@stdlib/array/base/map2d/test/test.main.js
index e1afd6285f42..00b1a3e8b474 100644
--- a/lib/node_modules/@stdlib/array/base/map2d/test/test.main.js
+++ b/lib/node_modules/@stdlib/array/base/map2d/test/test.main.js
@@ -57,7 +57,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
@@ -79,7 +79,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/map3d/test/test.assign.js b/lib/node_modules/@stdlib/array/base/map3d/test/test.assign.js
index 4e4cdca5b15b..099026df0a35 100644
--- a/lib/node_modules/@stdlib/array/base/map3d/test/test.assign.js
+++ b/lib/node_modules/@stdlib/array/base/map3d/test/test.assign.js
@@ -65,7 +65,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -94,7 +94,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -123,7 +123,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/map3d/test/test.main.js b/lib/node_modules/@stdlib/array/base/map3d/test/test.main.js
index f918eb59ef29..10b031173156 100644
--- a/lib/node_modules/@stdlib/array/base/map3d/test/test.main.js
+++ b/lib/node_modules/@stdlib/array/base/map3d/test/test.main.js
@@ -61,7 +61,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
@@ -85,7 +85,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
@@ -111,7 +111,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/map4d/test/test.assign.js b/lib/node_modules/@stdlib/array/base/map4d/test/test.assign.js
index f1af7abc301d..d2ac374a443f 100644
--- a/lib/node_modules/@stdlib/array/base/map4d/test/test.assign.js
+++ b/lib/node_modules/@stdlib/array/base/map4d/test/test.assign.js
@@ -69,7 +69,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -100,7 +100,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -131,7 +131,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -162,7 +162,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/map4d/test/test.main.js b/lib/node_modules/@stdlib/array/base/map4d/test/test.main.js
index 47fa72e2c869..9fdc47560b05 100644
--- a/lib/node_modules/@stdlib/array/base/map4d/test/test.main.js
+++ b/lib/node_modules/@stdlib/array/base/map4d/test/test.main.js
@@ -65,7 +65,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
@@ -91,7 +91,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
@@ -119,7 +119,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
@@ -149,7 +149,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/map5d/test/test.assign.js b/lib/node_modules/@stdlib/array/base/map5d/test/test.assign.js
index 7a8987673b54..e7b16631499c 100644
--- a/lib/node_modules/@stdlib/array/base/map5d/test/test.assign.js
+++ b/lib/node_modules/@stdlib/array/base/map5d/test/test.assign.js
@@ -73,7 +73,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -106,7 +106,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -139,7 +139,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -172,7 +172,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -205,7 +205,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/map5d/test/test.main.js b/lib/node_modules/@stdlib/array/base/map5d/test/test.main.js
index db996f7cc607..0f36789ce476 100644
--- a/lib/node_modules/@stdlib/array/base/map5d/test/test.main.js
+++ b/lib/node_modules/@stdlib/array/base/map5d/test/test.main.js
@@ -69,7 +69,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
@@ -97,7 +97,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
@@ -127,7 +127,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
@@ -159,7 +159,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
@@ -193,7 +193,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var out;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/mskbinary2d/test/test.js b/lib/node_modules/@stdlib/array/base/mskbinary2d/test/test.js
index 68a5267ac7f4..5b6f553c9abb 100644
--- a/lib/node_modules/@stdlib/array/base/mskbinary2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/mskbinary2d/test/test.js
@@ -90,7 +90,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -124,7 +124,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/mskbinary3d/test/test.js b/lib/node_modules/@stdlib/array/base/mskbinary3d/test/test.js
index 96b4fe65b692..eed384cfbd5d 100644
--- a/lib/node_modules/@stdlib/array/base/mskbinary3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/mskbinary3d/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -101,7 +101,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -135,7 +135,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/mskbinary4d/test/test.js b/lib/node_modules/@stdlib/array/base/mskbinary4d/test/test.js
index ad1ff0b7db35..9513900da023 100644
--- a/lib/node_modules/@stdlib/array/base/mskbinary4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/mskbinary4d/test/test.js
@@ -122,7 +122,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -168,7 +168,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -213,7 +213,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 		t.ok( false, 'should not invoke callback' );
 	}
 });
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -259,7 +259,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/mskbinary5d/test/test.js b/lib/node_modules/@stdlib/array/base/mskbinary5d/test/test.js
index 6f8d60e0f594..dbe79781d46c 100644
--- a/lib/node_modules/@stdlib/array/base/mskbinary5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/mskbinary5d/test/test.js
@@ -138,7 +138,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -190,7 +190,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -241,7 +241,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 		t.ok( false, 'should not invoke callback' );
 	}
 });
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -293,7 +293,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -344,7 +344,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 		t.ok( false, 'should not invoke callback' );
 	}
 });
-tape( 'the function does not invoke a provided callback if provided a shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/mskunary2d/test/test.js b/lib/node_modules/@stdlib/array/base/mskunary2d/test/test.js
index e092ec574e99..79b40834bc3b 100644
--- a/lib/node_modules/@stdlib/array/base/mskunary2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/mskunary2d/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -113,7 +113,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/mskunary3d/test/test.js b/lib/node_modules/@stdlib/array/base/mskunary3d/test/test.js
index 3670195a88a3..669a9d23e412 100644
--- a/lib/node_modules/@stdlib/array/base/mskunary3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/mskunary3d/test/test.js
@@ -107,7 +107,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -141,7 +141,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -175,7 +175,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/mskunary4d/test/test.js b/lib/node_modules/@stdlib/array/base/mskunary4d/test/test.js
index bf91c88f2dfd..1149baba5b36 100644
--- a/lib/node_modules/@stdlib/array/base/mskunary4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/mskunary4d/test/test.js
@@ -125,7 +125,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -163,7 +163,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -201,7 +201,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -238,7 +238,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 		t.ok( false, 'should not invoke callback' );
 	}
 });
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/mskunary5d/test/test.js b/lib/node_modules/@stdlib/array/base/mskunary5d/test/test.js
index c0cf069591d8..bbde0e7dacf3 100644
--- a/lib/node_modules/@stdlib/array/base/mskunary5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/mskunary5d/test/test.js
@@ -200,7 +200,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -241,7 +241,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -282,7 +282,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -323,7 +323,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -365,7 +365,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/ones2d/test/test.js b/lib/node_modules/@stdlib/array/base/ones2d/test/test.js
index e8b2edb94d1d..2dfd168429aa 100644
--- a/lib/node_modules/@stdlib/array/base/ones2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/ones2d/test/test.js
@@ -51,7 +51,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -69,7 +69,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/ones3d/test/test.js b/lib/node_modules/@stdlib/array/base/ones3d/test/test.js
index d42a1ecd0f09..5a1dbcf4e7db 100644
--- a/lib/node_modules/@stdlib/array/base/ones3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/ones3d/test/test.js
@@ -77,7 +77,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -95,7 +95,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -114,7 +114,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/ones4d/test/test.js b/lib/node_modules/@stdlib/array/base/ones4d/test/test.js
index 3a8a56a1cd59..0f1f773e010d 100644
--- a/lib/node_modules/@stdlib/array/base/ones4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/ones4d/test/test.js
@@ -95,7 +95,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -113,7 +113,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -132,7 +132,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -166,7 +166,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/ones5d/test/test.js b/lib/node_modules/@stdlib/array/base/ones5d/test/test.js
index 471306f3d520..6080be6b96f6 100644
--- a/lib/node_modules/@stdlib/array/base/ones5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/ones5d/test/test.js
@@ -115,7 +115,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -133,7 +133,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -152,7 +152,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -186,7 +186,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -220,7 +220,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a four
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/onesnd/test/test.js b/lib/node_modules/@stdlib/array/base/onesnd/test/test.js
index bd82b6e122fb..1b4926e72858 100644
--- a/lib/node_modules/@stdlib/array/base/onesnd/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/onesnd/test/test.js
@@ -264,7 +264,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty array if provided a shape having a first element equal to zero (1d)', function test( t ) {
+tape( 'the function returns an empty array if provided a shape having a first element.strictEqual to zero (1d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -276,7 +276,7 @@ tape( 'the function returns an empty array if provided a shape having a first el
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (2d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (2d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -294,7 +294,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (2d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (2d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -313,7 +313,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (3d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -331,7 +331,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (3d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -350,7 +350,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero (3d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -369,7 +369,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (4d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -387,7 +387,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (4d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -406,7 +406,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero (4d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -440,7 +440,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero (4d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -474,7 +474,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a four
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (5d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -492,7 +492,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -511,7 +511,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -545,7 +545,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -579,7 +579,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a four
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fifth element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fifth element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/quaternary2d/test/test.js b/lib/node_modules/@stdlib/array/base/quaternary2d/test/test.js
index 561eb89e39cc..ac31013ff124 100644
--- a/lib/node_modules/@stdlib/array/base/quaternary2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/quaternary2d/test/test.js
@@ -72,7 +72,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -111,7 +111,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/quaternary3d/test/test.js b/lib/node_modules/@stdlib/array/base/quaternary3d/test/test.js
index 095dcbafd83e..d75f94831f08 100644
--- a/lib/node_modules/@stdlib/array/base/quaternary3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/quaternary3d/test/test.js
@@ -82,7 +82,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -129,7 +129,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -176,7 +176,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/quaternary4d/test/test.js b/lib/node_modules/@stdlib/array/base/quaternary4d/test/test.js
index 28bd30e13426..bf9627676062 100644
--- a/lib/node_modules/@stdlib/array/base/quaternary4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/quaternary4d/test/test.js
@@ -92,7 +92,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -147,7 +147,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -202,7 +202,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -257,7 +257,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/quaternary5d/test/test.js b/lib/node_modules/@stdlib/array/base/quaternary5d/test/test.js
index 11c64569c40f..757638fbc272 100644
--- a/lib/node_modules/@stdlib/array/base/quaternary5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/quaternary5d/test/test.js
@@ -102,7 +102,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -165,7 +165,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -228,7 +228,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -291,7 +291,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -354,7 +354,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/quinary2d/test/test.js b/lib/node_modules/@stdlib/array/base/quinary2d/test/test.js
index 6c4ec8bdbc98..4e82691cbecf 100644
--- a/lib/node_modules/@stdlib/array/base/quinary2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/quinary2d/test/test.js
@@ -77,7 +77,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -121,7 +121,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/quinary3d/test/test.js b/lib/node_modules/@stdlib/array/base/quinary3d/test/test.js
index 73162eb2919a..46f083a36354 100644
--- a/lib/node_modules/@stdlib/array/base/quinary3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/quinary3d/test/test.js
@@ -89,7 +89,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -143,7 +143,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -197,7 +197,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/quinary4d/test/test.js b/lib/node_modules/@stdlib/array/base/quinary4d/test/test.js
index 02465aec422a..e514127992d9 100644
--- a/lib/node_modules/@stdlib/array/base/quinary4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/quinary4d/test/test.js
@@ -101,7 +101,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -165,7 +165,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -229,7 +229,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -293,7 +293,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/quinary5d/test/test.js b/lib/node_modules/@stdlib/array/base/quinary5d/test/test.js
index c8d8b7b996f3..3dffe8c0d2bb 100644
--- a/lib/node_modules/@stdlib/array/base/quinary5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/quinary5d/test/test.js
@@ -113,7 +113,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -187,7 +187,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -261,7 +261,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -335,7 +335,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -409,7 +409,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/symmetric-banded/filled2d-by/test/test.js b/lib/node_modules/@stdlib/array/base/symmetric-banded/filled2d-by/test/test.js
index 2beacfc3b690..ffa08fb3c894 100644
--- a/lib/node_modules/@stdlib/array/base/symmetric-banded/filled2d-by/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/symmetric-banded/filled2d-by/test/test.js
@@ -60,7 +60,7 @@ tape( 'the function returns a filled symmetric banded nested array', function te
 	}
 });
 
-tape( 'the function returns an empty outer array if provided a first argument equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a first argument.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/symmetric-banded/test/test.js b/lib/node_modules/@stdlib/array/base/symmetric-banded/test/test.js
index d1e6eeb4039e..30bee535777f 100644
--- a/lib/node_modules/@stdlib/array/base/symmetric-banded/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/symmetric-banded/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'returns expected value' );
+	t.strictEqual( keys.length > 0, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/base/symmetric/filled2d-by/test/test.js b/lib/node_modules/@stdlib/array/base/symmetric/filled2d-by/test/test.js
index 57cded949a7e..0728e62b0c4e 100644
--- a/lib/node_modules/@stdlib/array/base/symmetric/filled2d-by/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/symmetric/filled2d-by/test/test.js
@@ -52,7 +52,7 @@ tape( 'the function returns a filled symmetric nested array', function test( t )
 	}
 });
 
-tape( 'the function returns an empty outer array if provided a first argument equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a first argument.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/symmetric/test/test.js b/lib/node_modules/@stdlib/array/base/symmetric/test/test.js
index d1e6eeb4039e..30bee535777f 100644
--- a/lib/node_modules/@stdlib/array/base/symmetric/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/symmetric/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'returns expected value' );
+	t.strictEqual( keys.length > 0, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/base/ternary2d/test/test.js b/lib/node_modules/@stdlib/array/base/ternary2d/test/test.js
index 1e31a9a30908..d2cd1a43bcc9 100644
--- a/lib/node_modules/@stdlib/array/base/ternary2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/ternary2d/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -101,7 +101,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/ternary3d/test/test.js b/lib/node_modules/@stdlib/array/base/ternary3d/test/test.js
index c132bd48616c..f5166284d7e6 100644
--- a/lib/node_modules/@stdlib/array/base/ternary3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/ternary3d/test/test.js
@@ -91,7 +91,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -143,7 +143,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -195,7 +195,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/ternary4d/test/test.js b/lib/node_modules/@stdlib/array/base/ternary4d/test/test.js
index ec8e3d234a02..c8df0668b305 100644
--- a/lib/node_modules/@stdlib/array/base/ternary4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/ternary4d/test/test.js
@@ -99,7 +99,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -157,7 +157,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -215,7 +215,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -273,7 +273,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/ternary5d/test/test.js b/lib/node_modules/@stdlib/array/base/ternary5d/test/test.js
index d6be85cbe1be..2f47b271c93a 100644
--- a/lib/node_modules/@stdlib/array/base/ternary5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/ternary5d/test/test.js
@@ -107,7 +107,7 @@ tape( 'the function applies a provided callback to nested input arrays and assig
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -171,7 +171,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -235,7 +235,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -299,7 +299,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
@@ -363,7 +363,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var out;
diff --git a/lib/node_modules/@stdlib/array/base/test/test.js b/lib/node_modules/@stdlib/array/base/test/test.js
index 4703875b1edd..e682e93dba4d 100644
--- a/lib/node_modules/@stdlib/array/base/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/base/unary2d-by/test/test.js b/lib/node_modules/@stdlib/array/base/unary2d-by/test/test.js
index 319bec6c5444..5b56a4b202f4 100644
--- a/lib/node_modules/@stdlib/array/base/unary2d-by/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/unary2d-by/test/test.js
@@ -85,7 +85,7 @@ tape( 'the function applies a function to each nested input array element accord
 	t.end();
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -110,7 +110,7 @@ tape( 'the function does not invoke provided functions if provided a shape havin
 	}
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/unary2d/test/test.js b/lib/node_modules/@stdlib/array/base/unary2d/test/test.js
index 19bd6c0e27ed..d2ea81f5c68a 100644
--- a/lib/node_modules/@stdlib/array/base/unary2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/unary2d/test/test.js
@@ -58,7 +58,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -83,7 +83,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/unary3d-by/test/test.js b/lib/node_modules/@stdlib/array/base/unary3d-by/test/test.js
index a6a76bf49609..8ab38a499437 100644
--- a/lib/node_modules/@stdlib/array/base/unary3d-by/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/unary3d-by/test/test.js
@@ -109,7 +109,7 @@ tape( 'the function applies a function to each nested input array element accord
 	t.end();
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -136,7 +136,7 @@ tape( 'the function does not invoke provided functions if provided a shape havin
 	}
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -163,7 +163,7 @@ tape( 'the function does not invoke provided functions if provided a shape havin
 	}
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/unary3d/test/test.js b/lib/node_modules/@stdlib/array/base/unary3d/test/test.js
index 08fa398697c5..172b5b94c850 100644
--- a/lib/node_modules/@stdlib/array/base/unary3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/unary3d/test/test.js
@@ -70,7 +70,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -101,7 +101,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -132,7 +132,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/unary4d-by/test/test.js b/lib/node_modules/@stdlib/array/base/unary4d-by/test/test.js
index 1ce2affd0175..e35c307f0af2 100644
--- a/lib/node_modules/@stdlib/array/base/unary4d-by/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/unary4d-by/test/test.js
@@ -101,7 +101,7 @@ tape( 'the function applies a function to each nested input array element accord
 	t.end();
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -130,7 +130,7 @@ tape( 'the function does not invoke provided functions if provided a shape havin
 	}
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -159,7 +159,7 @@ tape( 'the function does not invoke provided functions if provided a shape havin
 	}
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -188,7 +188,7 @@ tape( 'the function does not invoke provided functions if provided a shape havin
 	}
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/unary4d/test/test.js b/lib/node_modules/@stdlib/array/base/unary4d/test/test.js
index f1636b83c238..9ca22e2996ee 100644
--- a/lib/node_modules/@stdlib/array/base/unary4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/unary4d/test/test.js
@@ -94,7 +94,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -137,7 +137,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -180,7 +180,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -223,7 +223,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/unary5d-by/test/test.js b/lib/node_modules/@stdlib/array/base/unary5d-by/test/test.js
index d1e2f2c863c2..7065bc46cf19 100644
--- a/lib/node_modules/@stdlib/array/base/unary5d-by/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/unary5d-by/test/test.js
@@ -109,7 +109,7 @@ tape( 'the function applies a function to each nested input array element accord
 	t.end();
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -140,7 +140,7 @@ tape( 'the function does not invoke provided functions if provided a shape havin
 	}
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -171,7 +171,7 @@ tape( 'the function does not invoke provided functions if provided a shape havin
 	}
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -202,7 +202,7 @@ tape( 'the function does not invoke provided functions if provided a shape havin
 	}
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -231,7 +231,7 @@ tape( 'the function does not invoke provided functions if provided a shape havin
 	}
 });
 
-tape( 'the function does not invoke provided functions if provided a shape having a five element equal to zero', function test( t ) {
+tape( 'the function does not invoke provided functions if provided a shape having a five element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/unary5d/test/test.js b/lib/node_modules/@stdlib/array/base/unary5d/test/test.js
index eec0535769f4..c42f2f78b340 100644
--- a/lib/node_modules/@stdlib/array/base/unary5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/unary5d/test/test.js
@@ -142,7 +142,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -209,7 +209,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -276,7 +276,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -343,7 +343,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -410,7 +410,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/unarynd/test/test.js b/lib/node_modules/@stdlib/array/base/unarynd/test/test.js
index eb4d0453f5d1..2eb2ec4aea21 100644
--- a/lib/node_modules/@stdlib/array/base/unarynd/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/unarynd/test/test.js
@@ -432,7 +432,7 @@ tape( 'the function applies a provided callback to a nested input array and assi
 	t.end();
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero (1d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero (1d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -454,7 +454,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero (2d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero (2d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -479,7 +479,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero (2d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero (2d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -504,7 +504,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero (3d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -535,7 +535,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero (3d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -566,7 +566,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero (3d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -597,7 +597,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero (4d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -640,7 +640,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero (4d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -683,7 +683,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero (4d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -726,7 +726,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero (4d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -769,7 +769,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a first element equal to zero (5d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a first element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -836,7 +836,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a second element equal to zero (5d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a second element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -903,7 +903,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a third element equal to zero (5d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a third element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -970,7 +970,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fourth element equal to zero (5d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fourth element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
@@ -1037,7 +1037,7 @@ tape( 'the function does not invoke a provided callback if provided a shape havi
 	}
 });
 
-tape( 'the function does not invoke a provided callback if provided a shape having a fifth element equal to zero (5d)', function test( t ) {
+tape( 'the function does not invoke a provided callback if provided a shape having a fifth element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var shape;
 	var x;
diff --git a/lib/node_modules/@stdlib/array/base/zeros2d/test/test.js b/lib/node_modules/@stdlib/array/base/zeros2d/test/test.js
index 959e4b0de2b5..748e59daad25 100644
--- a/lib/node_modules/@stdlib/array/base/zeros2d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/zeros2d/test/test.js
@@ -51,7 +51,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -69,7 +69,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/zeros3d/test/test.js b/lib/node_modules/@stdlib/array/base/zeros3d/test/test.js
index 8e77a23be18e..7fc6678f9d0f 100644
--- a/lib/node_modules/@stdlib/array/base/zeros3d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/zeros3d/test/test.js
@@ -77,7 +77,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -95,7 +95,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -114,7 +114,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/zeros4d/test/test.js b/lib/node_modules/@stdlib/array/base/zeros4d/test/test.js
index b02e589a6f47..b5c6382229b0 100644
--- a/lib/node_modules/@stdlib/array/base/zeros4d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/zeros4d/test/test.js
@@ -95,7 +95,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -113,7 +113,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -132,7 +132,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -166,7 +166,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/zeros5d/test/test.js b/lib/node_modules/@stdlib/array/base/zeros5d/test/test.js
index 2b70e386a664..841a1559171b 100644
--- a/lib/node_modules/@stdlib/array/base/zeros5d/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/zeros5d/test/test.js
@@ -115,7 +115,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -133,7 +133,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -152,7 +152,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -186,7 +186,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
@@ -220,7 +220,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a four
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fifth element equal to zero', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fifth element.strictEqual to zero', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/base/zerosnd/test/test.js b/lib/node_modules/@stdlib/array/base/zerosnd/test/test.js
index 0b36573f191f..52f126f2618e 100644
--- a/lib/node_modules/@stdlib/array/base/zerosnd/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/zerosnd/test/test.js
@@ -264,7 +264,7 @@ tape( 'the function returns a filled nested array', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns an empty array if provided a shape having a first element equal to zero (1d)', function test( t ) {
+tape( 'the function returns an empty array if provided a shape having a first element.strictEqual to zero (1d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -276,7 +276,7 @@ tape( 'the function returns an empty array if provided a shape having a first el
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (2d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (2d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -294,7 +294,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (2d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (2d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -313,7 +313,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (3d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -331,7 +331,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (3d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -350,7 +350,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero (3d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero (3d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -369,7 +369,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (4d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -387,7 +387,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (4d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -406,7 +406,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero (4d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -440,7 +440,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero (4d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero (4d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -474,7 +474,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a four
 	t.end();
 });
 
-tape( 'the function returns an empty outer array if provided a shape having a first element equal to zero (5d)', function test( t ) {
+tape( 'the function returns an empty outer array if provided a shape having a first element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -492,7 +492,7 @@ tape( 'the function returns an empty outer array if provided a shape having a fi
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a second element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a second element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -511,7 +511,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a seco
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a third element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a third element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -545,7 +545,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a thir
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fourth element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fourth element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
@@ -579,7 +579,7 @@ tape( 'the function returns empty inner arrays if provided a shape having a four
 	t.end();
 });
 
-tape( 'the function returns empty inner arrays if provided a shape having a fifth element equal to zero (5d)', function test( t ) {
+tape( 'the function returns empty inner arrays if provided a shape having a fifth element.strictEqual to zero (5d)', function test( t ) {
 	var expected;
 	var actual;
 
diff --git a/lib/node_modules/@stdlib/array/from-iterator/test/test.js b/lib/node_modules/@stdlib/array/from-iterator/test/test.js
index a10879bb7c48..9f06b7e8e4f7 100644
--- a/lib/node_modules/@stdlib/array/from-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/array/from-iterator/test/test.js
@@ -266,7 +266,7 @@ tape( 'the function supports filling a provided output array', function test( t
 	actual = iterator2array( it, out );
 	expected = new Float64Array( values );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -293,12 +293,12 @@ tape( 'the function supports filling a provided output array (accessors)', funct
 	actual = iterator2array( it, out );
 	expected = new Complex64Array( values );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	for ( i = 0; i < expected.length; i++ ) {
 		z1 = actual.get( i );
 		z2 = expected.get( i );
-		t.equal( realf( z1 ), realf( z2 ), 'returns expected value' );
-		t.equal( imagf( z1 ), imagf( z2 ), 'returns expected value' );
+		t.strictEqual( realf( z1 ), realf( z2 ), 'returns expected value' );
+		t.strictEqual( imagf( z1 ), imagf( z2 ), 'returns expected value' );
 	}
 	t.end();
 });
@@ -317,7 +317,7 @@ tape( 'the function supports filling a provided output array (short iterator)',
 	actual = iterator2array( it, out );
 	expected = new Float64Array( [ 1, 2, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -336,7 +336,7 @@ tape( 'the function supports filling a provided output array (callback)', functi
 	actual = iterator2array( it, out, scale );
 	expected = new Float64Array( [ 1, 4, 9, 16 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -359,7 +359,7 @@ tape( 'the function supports filling a provided output array (callback; short it
 	actual = iterator2array( it, out, scale );
 	expected = new Float64Array( [ 1, 4, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -384,7 +384,7 @@ tape( 'the function supports specifying the evaluation context of a provided cal
 	actual = iterator2array( it, scale, ctx );
 	expected = [ 1, 4, 9, 16 ];
 
-	t.equal( ctx.count, 4, 'returns expected value' );
+	t.strictEqual( ctx.count, 4, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -412,7 +412,7 @@ tape( 'the function supports specifying the evaluation context of a provided cal
 	actual = iterator2array( it, out, scale, ctx );
 	expected = new Float64Array( [ 1, 4, 9, 16 ] );
 
-	t.equal( ctx.count, 4, 'returns expected value' );
+	t.strictEqual( ctx.count, 4, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -424,13 +424,13 @@ tape( 'the function supports specifying the evaluation context of a provided cal
 
 tape( 'if provided an output argument, the function supports infinite iterators', function test( t ) {
 	var out = iterator2array( randu(), new Float64Array( 10 ) );
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 });
 
 tape( 'if provided an output argument, the function supports infinite iterators (callback)', function test( t ) {
 	var out = iterator2array( randu(), new Float64Array( 10 ), scale );
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 
 	function scale( v, i ) {
diff --git a/lib/node_modules/@stdlib/array/incrspace/test/test.js b/lib/node_modules/@stdlib/array/incrspace/test/test.js
index d0f95f67a98b..ca1d03fd5b84 100644
--- a/lib/node_modules/@stdlib/array/incrspace/test/test.js
+++ b/lib/node_modules/@stdlib/array/incrspace/test/test.js
@@ -143,7 +143,7 @@ tape( 'the function returns a linearly spaced array', function test( t ) {
 
 	// Large array:
 	actual = incrspace( start, 1e6, 1 );
-	t.equal( actual.length, 1e6 );
+	t.strictEqual( actual.length, 1e6 );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/linspace/test/test.validate.js b/lib/node_modules/@stdlib/array/linspace/test/test.validate.js
index 572ce5f9306b..7ddd8fe7b1b7 100644
--- a/lib/node_modules/@stdlib/array/linspace/test/test.validate.js
+++ b/lib/node_modules/@stdlib/array/linspace/test/test.validate.js
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an options object', functio
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns an error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns an error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided a `dtype` option which is not a
 		err = validate( {}, {
 			'dtype': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns an error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns an error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns an error if provided an `endpoint` option which is n
 		err = validate( {}, {
 			'endpoint': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns an error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns an error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -126,7 +126,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -147,7 +147,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/array/test/test.js b/lib/node_modules/@stdlib/array/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/array/test/test.js
+++ b/lib/node_modules/@stdlib/array/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/to-circular-iterator/test/test.js b/lib/node_modules/@stdlib/array/to-circular-iterator/test/test.js
index 84e21c0fa3e9..b7917fd4a72e 100644
--- a/lib/node_modules/@stdlib/array/to-circular-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-circular-iterator/test/test.js
@@ -351,14 +351,14 @@ tape( 'the function returns an iterator protocol-compliant object which repeated
 	];
 
 	it = circarray2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length*2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
 	t.end();
@@ -409,14 +409,14 @@ tape( 'the function returns an iterator protocol-compliant object which repeated
 	];
 
 	it = circarray2iterator( values, {} );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length*2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
 	t.end();
@@ -473,14 +473,14 @@ tape( 'the function returns an iterator protocol-compliant object which repeated
 	];
 
 	it = circarray2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length*2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
 	t.end();
@@ -500,7 +500,7 @@ tape( 'the function returns an iterator protocol-compliant object which repeated
 	];
 
 	it = circarray2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [ it.next() ];
 	t.deepEqual( actual, expected, 'returns expected values' );
@@ -517,18 +517,18 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = circarray2iterator( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	t.end();
 
@@ -555,18 +555,18 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	};
 
 	it = circarray2iterator( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	t.end();
 
@@ -586,7 +586,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [];
 
 	it = circarray2iterator( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [
 		{
@@ -652,14 +652,14 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 7
 	};
 	it = circarray2iterator( values, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -715,14 +715,14 @@ tape( 'the function supports limiting the number of iterations (callback)', func
 		'iter': 7
 	};
 	it = circarray2iterator( values, opts, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -783,14 +783,14 @@ tape( 'the function supports specifying the iteration direction', function test(
 		'dir': -1
 	};
 	it = circarray2iterator( values, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -847,14 +847,14 @@ tape( 'the function supports specifying the iteration direction (callback)', fun
 		'dir': -1
 	};
 	it = circarray2iterator( values, opts, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -873,20 +873,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = circarray2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -898,20 +898,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = circarray2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -927,20 +927,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = circarray2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -952,20 +952,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = circarray2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -988,16 +988,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = circarray2iterator( values );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -1016,16 +1016,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = circarray2iterator( values, scale );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -1043,7 +1043,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = circarray2iterator( [ 1, 2, 3, 4 ] );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -1057,7 +1057,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = circarray2iterator( [ 1, 2, 3, 4 ], scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/to-iterator-right/test/test.js b/lib/node_modules/@stdlib/array/to-iterator-right/test/test.js
index 20f19b48c977..1a1534dab46c 100644
--- a/lib/node_modules/@stdlib/array/to-iterator-right/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-iterator-right/test/test.js
@@ -151,14 +151,14 @@ tape( 'the function returns an iterator protocol-compliant object, iterating fro
 	];
 
 	it = array2iteratorRight( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -204,14 +204,14 @@ tape( 'the function returns an iterator protocol-compliant object, iterating fro
 	];
 
 	it = array2iteratorRight( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -229,19 +229,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = array2iteratorRight( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -268,19 +268,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	};
 
 	it = array2iteratorRight( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -298,20 +298,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = array2iteratorRight( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -323,20 +323,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = array2iteratorRight( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -352,20 +352,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = array2iteratorRight( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -377,20 +377,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = array2iteratorRight( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -413,16 +413,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = array2iteratorRight( values );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -441,16 +441,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = array2iteratorRight( values, scale );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -468,7 +468,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = array2iteratorRight( [ 1, 2, 3, 4 ] );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -482,7 +482,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = array2iteratorRight( [ 1, 2, 3, 4 ], scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/to-iterator/test/test.js b/lib/node_modules/@stdlib/array/to-iterator/test/test.js
index 38f57683d507..a3554675cb1c 100644
--- a/lib/node_modules/@stdlib/array/to-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-iterator/test/test.js
@@ -155,14 +155,14 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	];
 
 	it = array2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -208,14 +208,14 @@ tape( 'the function returns an iterator protocol-compliant object (array-like ob
 	];
 
 	it = array2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -257,26 +257,26 @@ tape( 'the function returns an iterator protocol-compliant object (accessors)',
 	];
 
 	it = array2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'object', 'returns an object' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'object', 'returns an object' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
-	t.equal( actual.length, expected.length, 'returns expected value' );
+	t.strictEqual( actual.length, expected.length, 'returns expected value' );
 	for ( i = 0; i < expected.length; i++ ) {
 		v1 = actual[ i ];
 		v2 = expected[ i ];
 		if ( i < expected.length-1 ) {
-			t.equal( realf( v1.value ), realf( v2.value ), 'returns expected value' );
-			t.equal( imagf( v1.value ), imagf( v2.value ), 'returns expected value' );
+			t.strictEqual( realf( v1.value ), realf( v2.value ), 'returns expected value' );
+			t.strictEqual( imagf( v1.value ), imagf( v2.value ), 'returns expected value' );
 		}
-		t.equal( v1.done, v2.done, 'returns expected value' );
+		t.strictEqual( v1.done, v2.done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -291,19 +291,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = array2iterator( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -330,19 +330,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	};
 
 	it = array2iterator( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -387,26 +387,26 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	];
 
 	it = array2iterator( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'object', 'returns an object' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'object', 'returns an object' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
-	t.equal( actual.length, expected.length, 'returns expected value' );
+	t.strictEqual( actual.length, expected.length, 'returns expected value' );
 	for ( i = 0; i < expected.length; i++ ) {
 		v1 = actual[ i ];
 		v2 = expected[ i ];
 		if ( i < expected.length-1 ) {
-			t.equal( realf( v1.value ), realf( v2.value ), 'returns expected value' );
-			t.equal( imagf( v1.value ), imagf( v2.value ), 'returns expected value' );
+			t.strictEqual( realf( v1.value ), realf( v2.value ), 'returns expected value' );
+			t.strictEqual( imagf( v1.value ), imagf( v2.value ), 'returns expected value' );
 		}
-		t.equal( v1.done, v2.done, 'returns expected value' );
+		t.strictEqual( v1.done, v2.done, 'returns expected value' );
 	}
 	t.end();
 
@@ -422,20 +422,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = array2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -447,20 +447,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = array2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -476,20 +476,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = array2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -501,20 +501,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = array2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -537,16 +537,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = array2iterator( values );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -565,16 +565,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = array2iterator( values, scale );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -592,7 +592,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = array2iterator( [ 1, 2, 3, 4 ] );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -606,7 +606,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = array2iterator( [ 1, 2, 3, 4 ], scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/to-sparse-iterator-right/test/test.js b/lib/node_modules/@stdlib/array/to-sparse-iterator-right/test/test.js
index 0a7f3e6453bd..47a082fcb4ef 100644
--- a/lib/node_modules/@stdlib/array/to-sparse-iterator-right/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-sparse-iterator-right/test/test.js
@@ -24,6 +24,7 @@ var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
 var iteratorSymbol = require( '@stdlib/symbol/iterator' );
 var noop = require( '@stdlib/utils/noop' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var sparsearray2iteratorRight = require( './../lib' );
 
 
@@ -143,14 +144,14 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	];
 
 	it = sparsearray2iteratorRight( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -164,7 +165,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty array)'
 	var values;
 	var it;
 
-	values = new Array( 1e5 );
+	values = zeros( 1e5 );
 	expected = [
 		{
 			'done': true
@@ -172,7 +173,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty array)'
 	];
 
 	it = sparsearray2iteratorRight( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -189,7 +190,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty end)',
 	var r;
 	var i;
 
-	values = new Array( 4 );
+	values = zeros( 4 );
 
 	// Leave the last element empty:
 	for ( i = 0; i < values.length-1; i++ ) {
@@ -214,14 +215,14 @@ tape( 'the function returns an iterator protocol-compliant object (empty end)',
 	];
 
 	it = sparsearray2iteratorRight( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -237,7 +238,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty start)'
 	var r;
 	var i;
 
-	values = new Array( 4 );
+	values = zeros( 4 );
 
 	// Leave the first element empty:
 	for ( i = 1; i < values.length; i++ ) {
@@ -263,14 +264,14 @@ tape( 'the function returns an iterator protocol-compliant object (empty start)'
 	];
 
 	it = sparsearray2iteratorRight( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -286,7 +287,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty start+e
 	var r;
 	var i;
 
-	values = new Array( 4 );
+	values = zeros( 4 );
 
 	// Leave the first and last elements empty:
 	for ( i = 1; i < values.length-1; i++ ) {
@@ -308,14 +309,14 @@ tape( 'the function returns an iterator protocol-compliant object (empty start+e
 	];
 
 	it = sparsearray2iteratorRight( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -356,14 +357,14 @@ tape( 'the function returns an iterator protocol-compliant object (array-like ob
 	];
 
 	it = sparsearray2iteratorRight( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -378,7 +379,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	var r;
 	var i;
 
-	values = new Array( 4 );
+	values = zeros( 4 );
 
 	// Leave the last element empty:
 	for ( i = 0; i < values.length-1; i++ ) {
@@ -386,19 +387,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	}
 
 	it = sparsearray2iteratorRight( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-1, 'has expected length' );
+	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -424,19 +425,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	};
 
 	it = sparsearray2iteratorRight( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-1, 'has expected length' );
+	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -474,7 +475,7 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	];
 
 	it = sparsearray2iteratorRight( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
@@ -513,7 +514,7 @@ tape( 'the function returns an iterator protocol-compliant object (callback)', f
 	];
 
 	it = sparsearray2iteratorRight( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
@@ -536,20 +537,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = sparsearray2iteratorRight( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -561,20 +562,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = sparsearray2iteratorRight( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -590,20 +591,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = sparsearray2iteratorRight( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -615,20 +616,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = sparsearray2iteratorRight( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -651,16 +652,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = sparsearray2iteratorRight( values );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -679,16 +680,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = sparsearray2iteratorRight( values, scale );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -706,7 +707,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = sparsearray2iteratorRight( [ 1, 2, 3, 4 ] );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -720,7 +721,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = sparsearray2iteratorRight( [ 1, 2, 3, 4 ], scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/to-sparse-iterator/test/test.js b/lib/node_modules/@stdlib/array/to-sparse-iterator/test/test.js
index 05d2abd466d4..e70a888a636f 100644
--- a/lib/node_modules/@stdlib/array/to-sparse-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-sparse-iterator/test/test.js
@@ -24,6 +24,7 @@ var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
 var iteratorSymbol = require( '@stdlib/symbol/iterator' );
 var noop = require( '@stdlib/utils/noop' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var sparsearray2iterator = require( './../lib' );
 
 
@@ -143,14 +144,14 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	];
 
 	it = sparsearray2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -164,7 +165,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty array)'
 	var values;
 	var it;
 
-	values = new Array( 1e5 );
+	values = zeros( 1e5 );
 	expected = [
 		{
 			'done': true
@@ -172,7 +173,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty array)'
 	];
 
 	it = sparsearray2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -189,7 +190,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty end)',
 	var r;
 	var i;
 
-	values = new Array( 4 );
+	values = zeros( 4 );
 
 	// Leave the last element empty:
 	for ( i = 0; i < values.length-1; i++ ) {
@@ -214,14 +215,14 @@ tape( 'the function returns an iterator protocol-compliant object (empty end)',
 	];
 
 	it = sparsearray2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -237,7 +238,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty start)'
 	var r;
 	var i;
 
-	values = new Array( 4 );
+	values = zeros( 4 );
 
 	// Leave the first element empty:
 	for ( i = 1; i < values.length; i++ ) {
@@ -263,14 +264,14 @@ tape( 'the function returns an iterator protocol-compliant object (empty start)'
 	];
 
 	it = sparsearray2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -286,7 +287,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty start+e
 	var r;
 	var i;
 
-	values = new Array( 4 );
+	values = zeros( 4 );
 
 	// Leave the first and last elements empty:
 	for ( i = 1; i < values.length-1; i++ ) {
@@ -308,14 +309,14 @@ tape( 'the function returns an iterator protocol-compliant object (empty start+e
 	];
 
 	it = sparsearray2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -356,14 +357,14 @@ tape( 'the function returns an iterator protocol-compliant object (array-like ob
 	];
 
 	it = sparsearray2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -378,7 +379,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	var r;
 	var i;
 
-	values = new Array( 4 );
+	values = zeros( 4 );
 
 	// Leave the last element empty:
 	for ( i = 0; i < values.length-1; i++ ) {
@@ -386,19 +387,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	}
 
 	it = sparsearray2iterator( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-1, 'has expected length' );
+	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -424,19 +425,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	};
 
 	it = sparsearray2iterator( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-1, 'has expected length' );
+	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -474,7 +475,7 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	];
 
 	it = sparsearray2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
@@ -513,7 +514,7 @@ tape( 'the function returns an iterator protocol-compliant object (callback)', f
 	];
 
 	it = sparsearray2iterator( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
@@ -536,20 +537,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = sparsearray2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -561,20 +562,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = sparsearray2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -590,20 +591,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = sparsearray2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -615,20 +616,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = sparsearray2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -651,16 +652,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = sparsearray2iterator( values );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -679,16 +680,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = sparsearray2iterator( values, scale );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -706,7 +707,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = sparsearray2iterator( [ 1, 2, 3, 4 ] );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -720,7 +721,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = sparsearray2iterator( [ 1, 2, 3, 4 ], scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/to-strided-iterator/test/test.js b/lib/node_modules/@stdlib/array/to-strided-iterator/test/test.js
index b312cc599895..4816473d8246 100644
--- a/lib/node_modules/@stdlib/array/to-strided-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-strided-iterator/test/test.js
@@ -323,14 +323,14 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	];
 
 	it = stridedarray2iterator( 4, values, 1, 2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < 4; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -384,14 +384,14 @@ tape( 'the function returns an iterator protocol-compliant object (array-like ob
 	];
 
 	it = stridedarray2iterator( 5, values, -1, 7 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < 5; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -409,19 +409,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = stridedarray2iterator( 4, values, -1, 3, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ 4, 6, 6, 4 ];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -447,19 +447,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	};
 
 	it = stridedarray2iterator( 4, values, 1, 0, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [ 1, 4, 9, 16 ];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -500,7 +500,7 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	];
 
 	it = stridedarray2iterator( 4, values, 1, 0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
@@ -543,7 +543,7 @@ tape( 'the function returns an iterator protocol-compliant object (callback)', f
 	];
 
 	it = stridedarray2iterator( 4, values, 1, 0, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
@@ -566,20 +566,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = stridedarray2iterator( 4, [ 1, 2, 3, 4 ], 1, 0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -591,20 +591,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = stridedarray2iterator( 4, [ 1, 2, 3, 4 ], 1, 0, scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -620,20 +620,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = stridedarray2iterator( 4, [ 1, 2, 3, 4 ], 1, 0 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -645,20 +645,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = stridedarray2iterator( 4, [ 1, 2, 3, 4 ], 1, 0, scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -681,16 +681,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = stridedarray2iterator( 4, values, 1, 0 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -709,16 +709,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = stridedarray2iterator( 4, values, 1, 0, scale );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -736,7 +736,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = stridedarray2iterator( 4, [ 1, 2, 3, 4 ], 1, 0 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = stridedarray2iterator( 4, [ 1, 2, 3, 4 ], 1, 0, scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/to-view-iterator-right/test/test.js b/lib/node_modules/@stdlib/array/to-view-iterator-right/test/test.js
index 5dbff1e97949..51e31db06cf7 100644
--- a/lib/node_modules/@stdlib/array/to-view-iterator-right/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-view-iterator-right/test/test.js
@@ -376,14 +376,14 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	];
 
 	it = arrayview2iteratorRight( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -415,14 +415,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin)', func
 	];
 
 	it = arrayview2iteratorRight( values, 2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -454,14 +454,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end)',
 	];
 
 	it = arrayview2iteratorRight( values, 1, 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -497,14 +497,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end)',
 	];
 
 	it = arrayview2iteratorRight( values, 1, 3000 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -540,14 +540,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0)', fu
 	];
 
 	it = arrayview2iteratorRight( values, -3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -587,14 +587,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0)', fu
 	];
 
 	it = arrayview2iteratorRight( values, -300 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -626,14 +626,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0+end)'
 	];
 
 	it = arrayview2iteratorRight( values, -3, 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -665,14 +665,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end<0)'
 	];
 
 	it = arrayview2iteratorRight( values, 1, -1 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -694,7 +694,7 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end<0)'
 	];
 
 	it = arrayview2iteratorRight( values, 0, -3000 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -727,14 +727,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0+end<0
 	];
 
 	it = arrayview2iteratorRight( values, -3, -1 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -780,14 +780,14 @@ tape( 'the function returns an iterator protocol-compliant object (array-like ob
 	];
 
 	it = arrayview2iteratorRight( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -805,19 +805,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iteratorRight( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -842,21 +842,21 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iteratorRight( values, scale, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
-	t.equal( ctx.count, values.length, 'returns expected value' );
+	t.strictEqual( ctx.count, values.length, 'returns expected value' );
 
 	t.end();
 
@@ -878,19 +878,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iteratorRight( values, 1, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-1, 'has expected length' );
+	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -911,19 +911,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iteratorRight( values, -3, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-1, 'has expected length' );
+	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -944,19 +944,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iteratorRight( values, 0, 2, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-2, 'has expected length' );
+	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -977,19 +977,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iteratorRight( values, 0, -2, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-2, 'has expected length' );
+	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -1010,19 +1010,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iteratorRight( values, -3, -1, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-2, 'has expected length' );
+	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -1043,19 +1043,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iteratorRight( values, 1, -1, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-2, 'has expected length' );
+	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -1082,19 +1082,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	};
 
 	it = arrayview2iteratorRight( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -1112,20 +1112,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -1137,20 +1137,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -1166,20 +1166,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -1191,20 +1191,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -1227,16 +1227,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = arrayview2iteratorRight( values );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -1255,16 +1255,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = arrayview2iteratorRight( values, 1 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -1283,16 +1283,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = arrayview2iteratorRight( values, 1, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -1311,16 +1311,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = arrayview2iteratorRight( values, scale );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -1343,16 +1343,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = arrayview2iteratorRight( values, 1, scale );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -1375,16 +1375,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = arrayview2iteratorRight( values, 1, 3, scale );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -1402,7 +1402,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ] );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -1416,7 +1416,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ], 1 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -1430,7 +1430,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ], 1, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -1444,7 +1444,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ], scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -1462,7 +1462,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ], 1, scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -1480,7 +1480,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ], 1, 3, scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/to-view-iterator/test/test.js b/lib/node_modules/@stdlib/array/to-view-iterator/test/test.js
index 74df8447c7b9..be0a7ecfdbdf 100644
--- a/lib/node_modules/@stdlib/array/to-view-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-view-iterator/test/test.js
@@ -376,14 +376,14 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	];
 
 	it = arrayview2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -415,14 +415,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin)', func
 	];
 
 	it = arrayview2iterator( values, 2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < 2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -454,14 +454,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end)',
 	];
 
 	it = arrayview2iterator( values, 1, 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < 2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -497,14 +497,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end)',
 	];
 
 	it = arrayview2iterator( values, 1, 3000 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -540,14 +540,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0)', fu
 	];
 
 	it = arrayview2iterator( values, -3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -587,14 +587,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0)', fu
 	];
 
 	it = arrayview2iterator( values, -300 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -626,14 +626,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0+end)'
 	];
 
 	it = arrayview2iterator( values, -3, 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -665,14 +665,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end<0)'
 	];
 
 	it = arrayview2iterator( values, 1, -1 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -694,7 +694,7 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end<0)'
 	];
 
 	it = arrayview2iterator( values, 0, -3000 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -727,14 +727,14 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0+end<0
 	];
 
 	it = arrayview2iterator( values, -3, -1 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -780,14 +780,14 @@ tape( 'the function returns an iterator protocol-compliant object (array-like ob
 	];
 
 	it = arrayview2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -805,19 +805,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iterator( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -842,21 +842,21 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iterator( values, scale, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
-	t.equal( ctx.count, values.length, 'returns expected value' );
+	t.strictEqual( ctx.count, values.length, 'returns expected value' );
 
 	t.end();
 
@@ -878,19 +878,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iterator( values, 1, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-1, 'has expected length' );
+	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -911,19 +911,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iterator( values, -3, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-1, 'has expected length' );
+	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -944,19 +944,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iterator( values, 1, 3, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-2, 'has expected length' );
+	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -977,19 +977,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iterator( values, -3, 3, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-2, 'has expected length' );
+	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -1010,19 +1010,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iterator( values, -3, -1, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-2, 'has expected length' );
+	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -1043,19 +1043,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = [ 1, 2, 3, 4 ];
 
 	it = arrayview2iterator( values, 1, -1, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length-2, 'has expected length' );
+	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -1082,19 +1082,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	};
 
 	it = arrayview2iterator( values, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -1112,20 +1112,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = arrayview2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -1137,20 +1137,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = arrayview2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -1166,20 +1166,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = arrayview2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -1191,20 +1191,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = arrayview2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -1227,16 +1227,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = arrayview2iterator( values );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -1255,16 +1255,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = arrayview2iterator( values, 1 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -1283,16 +1283,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = arrayview2iterator( values, 1, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -1311,16 +1311,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = arrayview2iterator( values, scale );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -1343,16 +1343,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = arrayview2iterator( values, 1, scale );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -1375,16 +1375,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = [ 1, 2, 3, 4 ];
 
 	it1 = arrayview2iterator( values, 1, 3, scale );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -1402,7 +1402,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = arrayview2iterator( [ 1, 2, 3, 4 ] );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -1416,7 +1416,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = arrayview2iterator( [ 1, 2, 3, 4 ], 1 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -1430,7 +1430,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = arrayview2iterator( [ 1, 2, 3, 4 ], 1, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -1444,7 +1444,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = arrayview2iterator( [ 1, 2, 3, 4 ], scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -1462,7 +1462,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = arrayview2iterator( [ 1, 2, 3, 4 ], 1, scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -1480,7 +1480,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = arrayview2iterator( [ 1, 2, 3, 4 ], 1, 3, scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/utils/async/parallel/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/parallel/test/test.factory.js
index cc5260e2e14d..bf9172c60751 100644
--- a/lib/node_modules/@stdlib/utils/async/parallel/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/parallel/test/test.factory.js
@@ -215,13 +215,13 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a function', function test( t ) {
 	var f = factory( [ noop ] );
-	t.equal( typeof f, 'function', 'returns expected value' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a function (options)', function test( t ) {
 	var f = factory( [ noop ], {} );
-	t.equal( typeof f, 'function', 'returns expected value' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.factory.js
index 940d4fe9cad8..6f79d0233f16 100644
--- a/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.factory.js
@@ -88,7 +88,7 @@ tape( 'the function throws an error if not provided a callback argument which is
 
 tape( 'the function returns a function', function test( t ) {
 	var f = factory( [noop], noop );
-	t.equal( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -103,12 +103,12 @@ tape( 'the function returns a function which executes each function in series, p
 		next( null, str );
 	}
 	function bar( res, next ) {
-		t.equal( res, str, 'invoked with result of previous function' );
+		t.strictEqual( res, str, 'invoked with result of previous function' );
 		next( null, 'hello', 'world' );
 	}
 	function fun( str1, str2, next ) {
-		t.equal( str1, 'hello', 'invoked with result 1' );
-		t.equal( str2, 'world', 'invoked with result 2' );
+		t.strictEqual( str1, 'hello', 'invoked with result 1' );
+		t.strictEqual( str2, 'world', 'invoked with result 2' );
 		next();
 	}
 	function done( error ) {
@@ -139,7 +139,7 @@ tape( 'the function returns a function which immediately returns an error to a p
 	}
 	function done( error ) {
 		t.ok( error, 'returns an error' );
-		t.equal( error.message, 'boop', 'equal message' );
+		t.strictEqual( error.message, 'boop', 'equal message' );
 		t.end();
 	}
 
@@ -161,12 +161,12 @@ tape( 'the function returns a function which supports executing each function in
 		next();
 	}
 	function bar( next ) {
-		t.equal( this._idx, 0, 'correct this context' );
+		t.strictEqual( this._idx, 0, 'correct this context' );
 		this._idx += 1;
 		next();
 	}
 	function fun( next ) {
-		t.equal( this._idx, 1, 'correct this context' );
+		t.strictEqual( this._idx, 1, 'correct this context' );
 		this._idx += 1;
 		next();
 	}
@@ -174,7 +174,7 @@ tape( 'the function returns a function which supports executing each function in
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( locals._idx, 2, 'correct this context' ); // eslint-disable-line no-underscore-dangle
+		t.strictEqual( locals._idx, 2, 'correct this context' ); // eslint-disable-line no-underscore-dangle
 		t.end();
 	}
 
diff --git a/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.main.js b/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.main.js
index 7bb7e33a4619..e9372c19d65c 100644
--- a/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.main.js
@@ -96,12 +96,12 @@ tape( 'the function executes each function in series, passing the results of one
 		next( null, str );
 	}
 	function bar( res, next ) {
-		t.equal( res, str, 'invoked with result of previous function' );
+		t.strictEqual( res, str, 'invoked with result of previous function' );
 		next( null, 'hello', 'world' );
 	}
 	function fun( str1, str2, next ) {
-		t.equal( str1, 'hello', 'invoked with result 1' );
-		t.equal( str2, 'world', 'invoked with result 2' );
+		t.strictEqual( str1, 'hello', 'invoked with result 1' );
+		t.strictEqual( str2, 'world', 'invoked with result 2' );
 		next();
 	}
 	function done( error ) {
@@ -130,7 +130,7 @@ tape( 'the function immediately returns an error to a provided callback', functi
 	}
 	function done( error ) {
 		t.ok( error, 'returns an error' );
-		t.equal( error.message, 'boop', 'equal message' );
+		t.strictEqual( error.message, 'boop', 'equal message' );
 		t.end();
 	}
 
@@ -150,12 +150,12 @@ tape( 'the function supports executing each function in series with a specified
 		next();
 	}
 	function bar( next ) {
-		t.equal( this._idx, 0, 'correct this context' );
+		t.strictEqual( this._idx, 0, 'correct this context' );
 		this._idx += 1;
 		next();
 	}
 	function fun( next ) {
-		t.equal( this._idx, 1, 'correct this context' );
+		t.strictEqual( this._idx, 1, 'correct this context' );
 		this._idx += 1;
 		next();
 	}
@@ -163,7 +163,7 @@ tape( 'the function supports executing each function in series with a specified
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( locals._idx, 2, 'correct this context' ); // eslint-disable-line no-underscore-dangle
+		t.strictEqual( locals._idx, 2, 'correct this context' ); // eslint-disable-line no-underscore-dangle
 		t.end();
 	}
 
diff --git a/lib/node_modules/@stdlib/utils/async/test/test.js b/lib/node_modules/@stdlib/utils/async/test/test.js
index 1405003d4f58..2b64d64a5f92 100644
--- a/lib/node_modules/@stdlib/utils/async/test/test.js
+++ b/lib/node_modules/@stdlib/utils/async/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains async utilities', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/constant-function/test/test.js b/lib/node_modules/@stdlib/utils/constant-function/test/test.js
index bd29a9375291..4922476df6c8 100644
--- a/lib/node_modules/@stdlib/utils/constant-function/test/test.js
+++ b/lib/node_modules/@stdlib/utils/constant-function/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.equal( typeof constantFunction(), 'function', 'returns a function' );
+	t.strictEqual( typeof constantFunction(), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -43,7 +43,7 @@ tape( 'the returned function always returns the same value', function test( t )
 
 	fcn = constantFunction( 3.14 );
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( fcn(), 3.14, 'returns 3.14' );
+		t.strictEqual( fcn(), 3.14, 'returns 3.14' );
 	}
 	t.end();
 });
@@ -56,7 +56,7 @@ tape( 'if the value is an object reference, the returned function always returns
 	arr = [ 1, 2, 3 ];
 	fcn = constantFunction( arr );
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( fcn(), arr, 'returns same reference' );
+		t.strictEqual( fcn(), arr, 'returns same reference' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/constructor-name/test/test.js b/lib/node_modules/@stdlib/utils/constructor-name/test/test.js
index 9f14be5133fc..7fe6495416bb 100644
--- a/lib/node_modules/@stdlib/utils/constructor-name/test/test.js
+++ b/lib/node_modules/@stdlib/utils/constructor-name/test/test.js
@@ -140,7 +140,7 @@ tape( 'the function returns the name of a value\'s constructor', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = constructorName( values[i] );
-		t.equal( v, expected[i], 'returns '+expected[i]+' when provided '+values[i] );
+		t.strictEqual( v, expected[i], 'returns '+expected[i]+' when provided '+values[i] );
 	}
 	t.end();
 });
@@ -166,7 +166,7 @@ tape( 'the function supports environments lacking `Function.name` support', func
 	foo = new Foo();
 	v = constructorName( foo );
 
-	t.equal( v, 'Foo', 'returns Foo' );
+	t.strictEqual( v, 'Foo', 'returns Foo' );
 	t.end();
 
 	function nativeClass() {
@@ -181,7 +181,7 @@ tape( 'the function supports Map objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasMapSupport() ) {
 		v = constructorName( new Map() );
-		t.equal( v, 'Map', 'returns Map' );
+		t.strictEqual( v, 'Map', 'returns Map' );
 	}
 	t.end();
 });
@@ -190,7 +190,7 @@ tape( 'the function supports WeakMap objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasWeakMapSupport() ) {
 		v = constructorName( new WeakMap() );
-		t.equal( v, 'WeakMap', 'returns WeakMap' );
+		t.strictEqual( v, 'WeakMap', 'returns WeakMap' );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function supports Set objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasSetSupport() ) {
 		v = constructorName( new Set() );
-		t.equal( v, 'Set', 'returns Set' );
+		t.strictEqual( v, 'Set', 'returns Set' );
 	}
 	t.end();
 });
@@ -208,7 +208,7 @@ tape( 'the function supports WeakSet objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasWeakSetSupport() ) {
 		v = constructorName( new WeakSet() );
-		t.equal( v, 'WeakSet', 'returns WeakSet' );
+		t.strictEqual( v, 'WeakSet', 'returns WeakSet' );
 	}
 	t.end();
 });
@@ -217,7 +217,7 @@ tape( 'the function supports Symbol objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasSymbolSupport() ) {
 		v = constructorName( Symbol( 'foo' ) );
-		t.equal( v, 'Symbol', 'returns Symbol' );
+		t.strictEqual( v, 'Symbol', 'returns Symbol' );
 	}
 	t.end();
 });
@@ -228,13 +228,13 @@ tape( 'the function supports custom objects', function test( t ) {
 		return this;
 	}
 	v = constructorName( new Person() );
-	t.equal( v, 'Person', 'returns Person' );
+	t.strictEqual( v, 'Person', 'returns Person' );
 	t.end();
 });
 
 tape( 'if a value\'s constructor is an anonymous function, the function returns an empty string', function test( t ) {
 	var v = constructorName( new (function () {})() ); // eslint-disable-line func-names, no-extra-parens
-	t.equal( v, '', 'returns empty string' );
+	t.strictEqual( v, '', 'returns empty string' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/copy/test/test.copy_error.js b/lib/node_modules/@stdlib/utils/copy/test/test.copy_error.js
index b595b348a000..fa5642f0aa2b 100644
--- a/lib/node_modules/@stdlib/utils/copy/test/test.copy_error.js
+++ b/lib/node_modules/@stdlib/utils/copy/test/test.copy_error.js
@@ -51,11 +51,11 @@ tape( 'generic <Error> object', function test( t ) {
 	var err1 = new Error( 'beep' );
 	var err2 = copy( err1 );
 
-	t.equal( err1 !== err2, true, 'separate instances' );
-	t.equal( err2 instanceof Error, true, 'instance of Error' );
-	t.equal( err2.message, err1.message, 'equal messages' );
-	t.equal( err2.name, err1.name, 'equal names' );
-	t.equal( err2.stack, err1.stack, 'equal stack trace' );
+	t.strictEqual( err1 !== err2, true, 'separate instances' );
+	t.strictEqual( err2 instanceof Error, true, 'instance of Error' );
+	t.strictEqual( err2.message, err1.message, 'equal messages' );
+	t.strictEqual( err2.name, err1.name, 'equal names' );
+	t.strictEqual( err2.stack, err1.stack, 'equal stack trace' );
 	t.end();
 });
 
@@ -63,11 +63,11 @@ tape( '<TypeError>', function test( t ) {
 	var err1 = new TypeError( 'invalid type' );
 	var err2 = copy( err1 );
 
-	t.equal( err1 !== err2, true, 'separate instances' );
-	t.equal( err2 instanceof TypeError, true, 'instance of TypeError' );
-	t.equal( err2.message, err1.message, 'equal messages' );
-	t.equal( err2.name, err1.name, 'equal names' );
-	t.equal( err2.stack, err1.stack, 'equal stack trace' );
+	t.strictEqual( err1 !== err2, true, 'separate instances' );
+	t.strictEqual( err2 instanceof TypeError, true, 'instance of TypeError' );
+	t.strictEqual( err2.message, err1.message, 'equal messages' );
+	t.strictEqual( err2.name, err1.name, 'equal names' );
+	t.strictEqual( err2.stack, err1.stack, 'equal stack trace' );
 	t.end();
 });
 
@@ -75,11 +75,11 @@ tape( '<RangeError>', function test( t ) {
 	var err1 = new RangeError( 'out-of-range' );
 	var err2 = copy( err1 );
 
-	t.equal( err1 !== err2, true, 'separate instances' );
-	t.equal( err2 instanceof RangeError, true, 'instance of RangeError' );
-	t.equal( err2.message, err1.message, 'equal messages' );
-	t.equal( err2.name, err1.name, 'equal names' );
-	t.equal( err2.stack, err1.stack, 'equal stack trace' );
+	t.strictEqual( err1 !== err2, true, 'separate instances' );
+	t.strictEqual( err2 instanceof RangeError, true, 'instance of RangeError' );
+	t.strictEqual( err2.message, err1.message, 'equal messages' );
+	t.strictEqual( err2.name, err1.name, 'equal names' );
+	t.strictEqual( err2.stack, err1.stack, 'equal stack trace' );
 	t.end();
 });
 
@@ -87,11 +87,11 @@ tape( '<SyntaxError>', function test( t ) {
 	var err1 = new SyntaxError( 'bad syntax' );
 	var err2 = copy( err1 );
 
-	t.equal( err1 !== err2, true, 'separate instances' );
-	t.equal( err2 instanceof SyntaxError, true, 'instance of SyntaxError' );
-	t.equal( err2.message, err1.message, 'equal messages' );
-	t.equal( err2.name, err1.name, 'equal names' );
-	t.equal( err2.stack, err1.stack, 'equal stack trace' );
+	t.strictEqual( err1 !== err2, true, 'separate instances' );
+	t.strictEqual( err2 instanceof SyntaxError, true, 'instance of SyntaxError' );
+	t.strictEqual( err2.message, err1.message, 'equal messages' );
+	t.strictEqual( err2.name, err1.name, 'equal names' );
+	t.strictEqual( err2.stack, err1.stack, 'equal stack trace' );
 	t.end();
 });
 
@@ -99,11 +99,11 @@ tape( '<ReferenceError>', function test( t ) {
 	var err1 = new ReferenceError( 'undefined variable' );
 	var err2 = copy( err1 );
 
-	t.equal( err1 !== err2, true, 'separate instances' );
-	t.equal( err2 instanceof ReferenceError, true, 'instance of ReferenceError' );
-	t.equal( err2.message, err1.message, 'equal messages' );
-	t.equal( err2.name, err1.name, 'equal names' );
-	t.equal( err2.stack, err1.stack, 'equal stack trace' );
+	t.strictEqual( err1 !== err2, true, 'separate instances' );
+	t.strictEqual( err2 instanceof ReferenceError, true, 'instance of ReferenceError' );
+	t.strictEqual( err2.message, err1.message, 'equal messages' );
+	t.strictEqual( err2.name, err1.name, 'equal names' );
+	t.strictEqual( err2.stack, err1.stack, 'equal stack trace' );
 	t.end();
 });
 
@@ -111,11 +111,11 @@ tape( '<EvalError>', function test( t ) {
 	var err1 = new EvalError( 'eval err1' );
 	var err2 = copy( err1 );
 
-	t.equal( err1 !== err2, true, 'separate instances' );
-	t.equal( err2 instanceof EvalError, true, 'instance of EvalError' );
-	t.equal( err2.message, err1.message, 'equal messages' );
-	t.equal( err2.name, err1.name, 'equal names' );
-	t.equal( err2.stack, err1.stack, 'equal stack trace' );
+	t.strictEqual( err1 !== err2, true, 'separate instances' );
+	t.strictEqual( err2 instanceof EvalError, true, 'instance of EvalError' );
+	t.strictEqual( err2.message, err1.message, 'equal messages' );
+	t.strictEqual( err2.name, err1.name, 'equal names' );
+	t.strictEqual( err2.stack, err1.stack, 'equal stack trace' );
 	t.end();
 });
 
@@ -123,11 +123,11 @@ tape( '<URIError>', function test( t ) {
 	var err1 = new URIError( 'bad URI' );
 	var err2 = copy( err1 );
 
-	t.equal( err1 !== err2, true, 'separate instances' );
-	t.equal( err2 instanceof URIError, true, 'instance of URIError' );
-	t.equal( err2.message, err1.message, 'equal messages' );
-	t.equal( err2.name, err1.name, 'equal names' );
-	t.equal( err2.stack, err1.stack, 'equal stack trace' );
+	t.strictEqual( err1 !== err2, true, 'separate instances' );
+	t.strictEqual( err2 instanceof URIError, true, 'instance of URIError' );
+	t.strictEqual( err2.message, err1.message, 'equal messages' );
+	t.strictEqual( err2.name, err1.name, 'equal names' );
+	t.strictEqual( err2.stack, err1.stack, 'equal stack trace' );
 	t.end();
 });
 
@@ -141,7 +141,7 @@ tape( 'environments missing a `stack` trace', function test( t ) {
 	err1.constructor = createError;
 
 	err2 = copy( err1 );
-	t.equal( err2.stack, '', 'no stack trace' );
+	t.strictEqual( err2.stack, '', 'no stack trace' );
 
 	t.end();
 
@@ -160,7 +160,7 @@ tape( '`code` property (Node.js)', function test( t ) {
 	err1.code = 43;
 
 	err2 = copy( err1 );
-	t.equal( err2.code, err1.code, 'equal codes' );
+	t.strictEqual( err2.code, err1.code, 'equal codes' );
 
 	t.end();
 });
@@ -173,7 +173,7 @@ tape( '`errno` property (Node.js)', function test( t ) {
 	err1.errno = 'EACCES';
 
 	err2 = copy( err1 );
-	t.equal( err1.errno, err2.errno, 'equal errno' );
+	t.strictEqual( err1.errno, err2.errno, 'equal errno' );
 
 	t.end();
 });
@@ -186,7 +186,7 @@ tape( '`syscall` property (Node.js)', function test( t ) {
 	err1.syscall = 'boop';
 
 	err2 = copy( err1 );
-	t.equal( err2.syscall, err1.syscall, 'equal syscall values' );
+	t.strictEqual( err2.syscall, err1.syscall, 'equal syscall values' );
 
 	t.end();
 });
@@ -201,8 +201,8 @@ tape( 'additional (enumerable) properties', function test( t ) {
 	err1.boop = 'beep';
 
 	err2 = copy( err1 );
-	t.equal( err2.beep, err1.beep, 'data descriptor' );
-	t.equal( err2.boop, err1.boop, 'data descriptor' );
+	t.strictEqual( err2.beep, err1.beep, 'data descriptor' );
+	t.strictEqual( err2.boop, err1.boop, 'data descriptor' );
 
 	// Accessor descriptor...
 	err1 = new Error( 'errrr' );
@@ -222,8 +222,8 @@ tape( 'additional (enumerable) properties', function test( t ) {
 	});
 
 	err2 = copy( err1 );
-	t.equal( err2.beep, err1.beep, 'accessor descriptor' );
-	t.equal( err2.boop, err1.boop, 'accessor descriptor' );
+	t.strictEqual( err2.beep, err1.beep, 'accessor descriptor' );
+	t.strictEqual( err2.boop, err1.boop, 'accessor descriptor' );
 
 	// Deep equal...
 	err1 = new Error( 'errrr' );
@@ -240,12 +240,12 @@ tape( 'custom errors (proto)', function test( t ) {
 	var err1 = new CustomError1( 'custom error' );
 	var err2 = copy( err1 );
 
-	t.equal( err1 !== err2, true, 'separate instances' );
-	t.equal( err2 instanceof CustomError1, true, 'instance of CustomError' );
-	t.equal( err2 instanceof Error, true, 'instance of Error' );
-	t.equal( err2.message, err1.message, 'equal messages' );
-	t.equal( err2.name, err1.name, 'equal names' );
-	t.equal( err2.stack, err1.stack, 'equal stack trace' );
+	t.strictEqual( err1 !== err2, true, 'separate instances' );
+	t.strictEqual( err2 instanceof CustomError1, true, 'instance of CustomError' );
+	t.strictEqual( err2 instanceof Error, true, 'instance of Error' );
+	t.strictEqual( err2.message, err1.message, 'equal messages' );
+	t.strictEqual( err2.name, err1.name, 'equal names' );
+	t.strictEqual( err2.stack, err1.stack, 'equal stack trace' );
 	t.end();
 });
 
@@ -254,11 +254,11 @@ tape( 'custom errors (subclass; ES2015)', opts, function test( t ) {
 	var err1 = new CustomError2( 'custom error' );
 	var err2 = copy( err1 );
 
-	t.equal( err1 !== err2, true, 'separate instances' );
-	t.equal( err2 instanceof CustomError2, true, 'instance of CustomError' );
-	t.equal( err2 instanceof Error, true, 'instance of Error' );
-	t.equal( err2.message, err1.message, 'equal messages' );
-	t.equal( err2.name, err1.name, 'equal names' );
-	t.equal( err2.stack, err1.stack, 'equal stack trace' );
+	t.strictEqual( err1 !== err2, true, 'separate instances' );
+	t.strictEqual( err2 instanceof CustomError2, true, 'instance of CustomError' );
+	t.strictEqual( err2 instanceof Error, true, 'instance of Error' );
+	t.strictEqual( err2.message, err1.message, 'equal messages' );
+	t.strictEqual( err2.name, err1.name, 'equal names' );
+	t.strictEqual( err2.stack, err1.stack, 'equal stack trace' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/copy/test/test.deep_copy.js b/lib/node_modules/@stdlib/utils/copy/test/test.deep_copy.js
index 264879e183e4..79e5985c0d7b 100644
--- a/lib/node_modules/@stdlib/utils/copy/test/test.deep_copy.js
+++ b/lib/node_modules/@stdlib/utils/copy/test/test.deep_copy.js
@@ -62,7 +62,7 @@ tape( 'copy primitives', function test( t ) {
 		val = values[ i ];
 		cp = {};
 		actual = copy( val, cp, [val], [cp], LEVEL );
-		t.equal( actual, val, 'copies a ' + (typeof val) + ' primitive' );
+		t.strictEqual( actual, val, 'copies a ' + (typeof val) + ' primitive' );
 	}
 	t.end();
 });
@@ -170,7 +170,7 @@ tape( 'copy `Boolean` objects to boolean primitives', function test( t ) {
 	actual = copy( val, cp, [val], [cp], LEVEL );
 
 	t.notEqual( typeof actual, 'object', 'not an object' );
-	t.equal( actual, true, 'equal values' );
+	t.strictEqual( actual, true, 'equal values' );
 
 	t.end();
 });
@@ -185,7 +185,7 @@ tape( 'copy `String` objects to string primitives', function test( t ) {
 	actual = copy( val, cp, [val], [cp], LEVEL );
 
 	t.notEqual( typeof actual, 'object', 'not an object' );
-	t.equal( actual, 'beep', 'equal values' );
+	t.strictEqual( actual, 'beep', 'equal values' );
 
 	t.end();
 });
@@ -200,7 +200,7 @@ tape( 'copy `Number` objects to number primitives', function test( t ) {
 	actual = copy( val, cp, [val], [cp], LEVEL );
 
 	t.notEqual( typeof actual, 'object', 'not an object' );
-	t.equal( actual, 3.14, 'equal values' );
+	t.strictEqual( actual, 3.14, 'equal values' );
 
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'copy `Date` objects', function test( t ) {
 	actual = copy( val, cp, [val], [cp], LEVEL );
 
 	t.notEqual( actual, val, 'distinct references' );
-	t.equal( +actual, +val, 'equal values' );
+	t.strictEqual( +actual, +val, 'equal values' );
 
 	t.end();
 });
@@ -230,7 +230,7 @@ tape( 'copy `RegExp` objects', function test( t ) {
 	actual = copy( val, cp, [val], [cp], LEVEL );
 
 	t.notEqual( actual, val, 'distinct references' );
-	t.equal( actual.toString(), val.toString(), 'equal values' );
+	t.strictEqual( actual.toString(), val.toString(), 'equal values' );
 
 	t.end();
 });
@@ -492,7 +492,7 @@ tape( 'circular references', function test( t ) {
 
 	assert.deepEqual( actual, val );
 	t.ok( true, 'deep equal' );
-	t.equal( actual, actual.to, 'circular reference' );
+	t.strictEqual( actual, actual.to, 'circular reference' );
 
 	t.end();
 });
@@ -509,13 +509,13 @@ tape( 'arbitrary depth', function test( t ) {
 	assert.deepEqual( actual, fixtures.expectedObj1 );
 	t.ok( true, 'level 1' );
 
-	t.equal( actual.bool, fixtures.expectedObj1.bool, 'boolean primitive' );
+	t.strictEqual( actual.bool, fixtures.expectedObj1.bool, 'boolean primitive' );
 
-	t.equal( actual.uint8carr, fixtures.expectedObj1.uint8carr, 'share typed array ref' );
+	t.strictEqual( actual.uint8carr, fixtures.expectedObj1.uint8carr, 'share typed array ref' );
 
-	t.equal( actual.arr, fixtures.expectedObj1.arr, 'share array ref' );
+	t.strictEqual( actual.arr, fixtures.expectedObj1.arr, 'share array ref' );
 
-	t.equal( actual.obj, fixtures.expectedObj1.obj, 'share object ref' );
+	t.strictEqual( actual.obj, fixtures.expectedObj1.obj, 'share object ref' );
 
 	t.end();
 });
@@ -533,7 +533,7 @@ tape( 'arbitrary depth', function test( t ) {
 	assert.deepEqual( actual, fixtures.expectedObj2 );
 	t.ok( true, 'deep equal' );
 
-	t.equal( actual.bool, fixtures.expectedObj2.bool, 'boolean primitive' );
+	t.strictEqual( actual.bool, fixtures.expectedObj2.bool, 'boolean primitive' );
 
 	t.notEqual( actual.uint8carr, fixtures.expectedObj2.uint8carr, 'distinct typed arrays' );
 
@@ -541,7 +541,7 @@ tape( 'arbitrary depth', function test( t ) {
 
 	t.notEqual( actual.obj, fixtures.expectedObj2.obj, 'distinct objects' );
 
-	t.equal( actual.obj.a, fixtures.expectedObj2.obj.a, 'shared nested objects' );
+	t.strictEqual( actual.obj.a, fixtures.expectedObj2.obj.a, 'shared nested objects' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/copy/test/test.js b/lib/node_modules/@stdlib/utils/copy/test/test.js
index 02b092dac05d..08e7f8c13d89 100644
--- a/lib/node_modules/@stdlib/utils/copy/test/test.js
+++ b/lib/node_modules/@stdlib/utils/copy/test/test.js
@@ -69,10 +69,10 @@ tape( 'the function deep copies an input value', function test( t ) {
 
 	// Primitives...
 	actual = copy( 'beep' );
-	t.equal( actual, 'beep', 'returns expected value' );
+	t.strictEqual( actual, 'beep', 'returns expected value' );
 
 	actual = copy( 5 );
-	t.equal( actual, 5, 'returns expected value' );
+	t.strictEqual( actual, 5, 'returns expected value' );
 
 	// Empty arrays...
 	actual = copy( fixtures.emptyArr );
@@ -117,6 +117,6 @@ tape( 'the function supports deep coping to a specified level', function test( t
 
 tape( 'when provided a level equal to 0, the function returns the input reference', function test( t ) {
 	var actual = copy( fixtures.obj, 0 );
-	t.equal( actual, fixtures.obj, 'copy to depth 0' );
+	t.strictEqual( actual, fixtures.obj, 'copy to depth 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/decorate-after/test/test.js b/lib/node_modules/@stdlib/utils/decorate-after/test/test.js
index d7d7a1ffce9c..1a205acb39a7 100644
--- a/lib/node_modules/@stdlib/utils/decorate-after/test/test.js
+++ b/lib/node_modules/@stdlib/utils/decorate-after/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `decorateAfter` functions', function test( t ) {
-	t.equal( typeof decorateAfter.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof decorateAfter.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/deep-get/test/test.dget.js b/lib/node_modules/@stdlib/utils/deep-get/test/test.dget.js
index 67bcac6a63af..db6389abeba0 100644
--- a/lib/node_modules/@stdlib/utils/deep-get/test/test.dget.js
+++ b/lib/node_modules/@stdlib/utils/deep-get/test/test.dget.js
@@ -87,10 +87,10 @@ tape( 'the function returns `undefined` if unable to successfully get', function
 	};
 
 	actual = dget( obj, ['a', 'b', 'djfajdfaj'] );
-	t.equal( actual, void 0, 'returns undefined' );
+	t.strictEqual( actual, void 0, 'returns undefined' );
 
 	actual = dget( obj, ['null', 'e'] );
-	t.equal( actual, void 0, 'returns undefined' );
+	t.strictEqual( actual, void 0, 'returns undefined' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/deep-get/test/test.factory.js b/lib/node_modules/@stdlib/utils/deep-get/test/test.factory.js
index 88993c719cb5..d64005b11ccd 100644
--- a/lib/node_modules/@stdlib/utils/deep-get/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/deep-get/test/test.factory.js
@@ -117,7 +117,7 @@ tape( 'the function returns a function', function test( t ) {
 	var dget = factory( 'a/b', {
 		'sep': '/'
 	});
-	t.equal( typeof dget, 'function', 'returns a function' );
+	t.strictEqual( typeof dget, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -141,7 +141,7 @@ tape( 'the created function returns `undefined` if provided a non-object or null
 	});
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( dget( values[ i ] ), void 0, 'returns undefined' );
+		t.strictEqual( dget( values[ i ] ), void 0, 'returns undefined' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/deep-get/test/test.js b/lib/node_modules/@stdlib/utils/deep-get/test/test.js
index fc3650806615..a26d4608e57f 100644
--- a/lib/node_modules/@stdlib/utils/deep-get/test/test.js
+++ b/lib/node_modules/@stdlib/utils/deep-get/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function exports a factory function', function test( t ) {
-	t.equal( typeof deepGet.factory, 'function', 'exports a factory function' );
+	t.strictEqual( typeof deepGet.factory, 'function', 'exports a factory function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'the function returns `undefined` if provided a non-object or null', funct
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( deepGet( values[ i ], 'a.b.c' ), void 0, 'returns undefined' );
+		t.strictEqual( deepGet( values[ i ], 'a.b.c' ), void 0, 'returns undefined' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/deep-get/test/test.validate.js b/lib/node_modules/@stdlib/utils/deep-get/test/test.validate.js
index 5cc56fe0b025..c117aa6d4286 100644
--- a/lib/node_modules/@stdlib/utils/deep-get/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/deep-get/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns an error if provided a separator option which is not
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -89,15 +89,15 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'sep': '_'
 	};
 	obj = {};
-	t.equal( validate( obj, opts ), null, 'returns null' );
-	t.equal( obj.sep, '_', 'sets sep option' );
+	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( obj.sep, '_', 'sets sep option' );
 
 	opts = {
 		'beep': true,
 		'boop': false
 	};
 	obj = {};
-	t.equal( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/deep-pluck/test/test.js b/lib/node_modules/@stdlib/utils/deep-pluck/test/test.js
index 17780c062f27..830eb09aac55 100644
--- a/lib/node_modules/@stdlib/utils/deep-pluck/test/test.js
+++ b/lib/node_modules/@stdlib/utils/deep-pluck/test/test.js
@@ -30,7 +30,8 @@ var deepPluck = require( './../lib' );
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
-	t.equal( typeof deepPluck, 'function', 'main export is a function' );
+	t.ok( true, __filename );
+	t.strictEqual( typeof deepPluck, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -136,7 +137,7 @@ tape( 'the function supports mutating an input array', function test( t ) {
 		'copy': false
 	});
 
-	t.equal( actual, arr, 'returns same array reference' );
+	t.strictEqual( actual, arr, 'returns same array reference' );
 	t.deepEqual( arr, expected, 'input array is mutated' );
 	t.end();
 });
@@ -217,7 +218,7 @@ tape( 'the function does not deep copy deep plucked values', function test( t )
 	actual = deepPluck( arr, 'a.b' );
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( actual[0], arr[0].a.b, 'deep plucked values are not deep copied' );
+	t.strictEqual( actual[0], arr[0].a.b, 'deep plucked values are not deep copied' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/deep-pluck/test/test.validate.js b/lib/node_modules/@stdlib/utils/deep-pluck/test/test.validate.js
index 20a1bb4c5f10..7ce917ccae6c 100644
--- a/lib/node_modules/@stdlib/utils/deep-pluck/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/deep-pluck/test/test.validate.js
@@ -27,7 +27,8 @@ var validate = require( './../lib/validate.js' );
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.ok( true, __filename );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -49,7 +50,7 @@ tape( 'the function returns an error if not provided an options object', functio
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided ' + values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided ' + values[ i ] );
 	}
 	t.end();
 });
@@ -74,7 +75,7 @@ tape( 'the function returns an error if provided a `copy` option which is not a
 		err = validate( {}, {
 			'copy': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided ' + values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided ' + values[ i ] );
 	}
 	t.end();
 });
@@ -99,7 +100,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided ' + values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided ' + values[ i ] );
 	}
 	t.end();
 });
@@ -115,9 +116,9 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.copy, true, 'sets the copy option' );
-	t.equal( obj.sep, '|', 'sets the sep option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.copy, true, 'sets the copy option' );
+	t.strictEqual( obj.sep, '|', 'sets the sep option' );
 	t.end();
 });
 
@@ -132,7 +133,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/deep-set/test/test.dset.js b/lib/node_modules/@stdlib/utils/deep-set/test/test.dset.js
index 9a6421cc2bd2..3eeb4e78c902 100644
--- a/lib/node_modules/@stdlib/utils/deep-set/test/test.dset.js
+++ b/lib/node_modules/@stdlib/utils/deep-set/test/test.dset.js
@@ -76,7 +76,7 @@ tape( 'the function deep sets a nested property value', function test( t ) {
 
 	bool = dset( obj, ['a', 'b', 'c'], false, 'beep' );
 	t.deepEqual( obj, expected, 'deep sets object' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.end();
 });
 
@@ -104,7 +104,7 @@ tape( 'the function returns `true` if able to successfully set', function test(
 	};
 
 	bool = dset( obj, ['a', 'b', 'c'], false, 'beep' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.end();
 });
 
@@ -132,10 +132,10 @@ tape( 'the function returns `false` if unable to successfully set', function tes
 	};
 
 	bool = dset( obj, ['a', 'b', 'djfajdfaj'], false, 'beep' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = dset( obj, ['null', 'e'], false, 'beep' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 	t.end();
 });
 
@@ -183,7 +183,7 @@ tape( 'the function deep sets an array', function test( t ) {
 
 	bool = dset( obj, ['arr', 0, 'y'], false, 200 );
 	t.deepEqual( obj, expected, 'deep sets object' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.end();
 });
 
@@ -234,7 +234,7 @@ tape( 'the function creates properties which do not exist', function test( t ) {
 
 	bool = dset( obj, ['arr', 2, 'y'], true, 200 );
 	t.deepEqual( obj, expected, 'deep sets object' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.end();
 });
 
@@ -283,7 +283,7 @@ tape( 'the function deep sets using a callback function', function test( t ) {
 
 	bool = dset( obj, ['a', 'b', 'c'], false, set );
 	t.deepEqual( obj, expected, 'deep sets object' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.end();
 
 	function set( val ) {
diff --git a/lib/node_modules/@stdlib/utils/deep-set/test/test.factory.js b/lib/node_modules/@stdlib/utils/deep-set/test/test.factory.js
index 613cb3e59766..e892d042020a 100644
--- a/lib/node_modules/@stdlib/utils/deep-set/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/deep-set/test/test.factory.js
@@ -119,7 +119,7 @@ tape( 'the function returns a function', function test( t ) {
 		'create': true,
 		'sep': '/'
 	});
-	t.equal( typeof dset, 'function', 'returns a function' );
+	t.strictEqual( typeof dset, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -144,7 +144,7 @@ tape( 'the returned function returns `false` if provided a non-object or null',
 	});
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( dset( values[ i ], 5 ), false, 'returns false' );
+		t.strictEqual( dset( values[ i ], 5 ), false, 'returns false' );
 	}
 	t.end();
 });
@@ -163,13 +163,13 @@ tape( 'the returned function returns a boolean', function test( t ) {
 		'a': 5
 	};
 	bool = dset( obj, 4 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {
 		'b': 5
 	};
 	bool = dset( obj, 4 );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	dset = factory( 'a', {
 		'create': true
@@ -179,7 +179,7 @@ tape( 'the returned function returns a boolean', function test( t ) {
 		'b': 5
 	};
 	bool = dset( obj, 4 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -205,7 +205,7 @@ tape( 'the returned function deep sets', function test( t ) {
 		}
 	};
 
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.deepEqual( obj, expected, 'deep sets object' );
 
 	bool = dset( obj, 40 );
@@ -215,7 +215,7 @@ tape( 'the returned function deep sets', function test( t ) {
 		}
 	};
 
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.deepEqual( obj, expected, 'deep sets object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/deep-set/test/test.js b/lib/node_modules/@stdlib/utils/deep-set/test/test.js
index cf05e846d27c..2f3a44bef5c0 100644
--- a/lib/node_modules/@stdlib/utils/deep-set/test/test.js
+++ b/lib/node_modules/@stdlib/utils/deep-set/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function exports a factory function', function test( t ) {
-	t.equal( typeof deepSet.factory, 'function', 'exports a factory function' );
+	t.strictEqual( typeof deepSet.factory, 'function', 'exports a factory function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'the function returns `false` if provided a non-object or null', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( deepSet( values[ i ], 'a.b.c', 5 ), false, 'returns false' );
+		t.strictEqual( deepSet( values[ i ], 'a.b.c', 5 ), false, 'returns false' );
 	}
 	t.end();
 });
@@ -156,12 +156,12 @@ tape( 'the function returns a boolean', function test( t ) {
 		'a': 5
 	};
 	bool = deepSet( obj, 'a', 4 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = deepSet( obj, 'b', 4, {
 		'create': false
 	});
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -184,7 +184,7 @@ tape( 'the function deep sets', function test( t ) {
 		}
 	};
 
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.deepEqual( obj, expected, 'deep sets object' );
 
 	bool = deepSet( obj, ['a', 'b'], 40 );
@@ -194,7 +194,7 @@ tape( 'the function deep sets', function test( t ) {
 		}
 	};
 
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.deepEqual( obj, expected, 'deep sets object' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/deep-set/test/test.validate.js b/lib/node_modules/@stdlib/utils/deep-set/test/test.validate.js
index 9f7ace4fc859..f2127561ac9b 100644
--- a/lib/node_modules/@stdlib/utils/deep-set/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/deep-set/test/test.validate.js
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -66,7 +66,7 @@ tape( 'the function returns an error if provided a `create` option which is not
 		5,
 		null,
 		NaN,
-		new Boolean( true ), // eslint-disable-line no-new-wrappers
+		new Boolean( true ),
 		void 0,
 		[],
 		{},
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided a `create` option which is not
 		err = validate( {}, {
 			'create': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 	var i;
 
 	values = [
-		new String( '5' ), // eslint-disable-line no-new-wrappers
+		new String( '5' ),
 		null,
 		5,
 		NaN,
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -117,16 +117,16 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'sep': '_'
 	};
 	obj = {};
-	t.equal( validate( obj, opts ), null, 'returns null' );
-	t.equal( obj.create, true, 'sets create option' );
-	t.equal( obj.sep, '_', 'sets sep option' );
+	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( obj.create, true, 'sets create option' );
+	t.strictEqual( obj.sep, '_', 'sets sep option' );
 
 	opts = {
 		'beep': true,
 		'boop': false
 	};
 	obj = {};
-	t.equal( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/define-configurable-read-only-accessor/test/test.js b/lib/node_modules/@stdlib/utils/define-configurable-read-only-accessor/test/test.js
index 866caffdab5e..e1c9e4fa64f3 100644
--- a/lib/node_modules/@stdlib/utils/define-configurable-read-only-accessor/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-configurable-read-only-accessor/test/test.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function sets a property on a provided object', function test( t ) {
 	var obj = {};
 	setConfigurableReadOnlyAccessor( obj, 'foo', getter );
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 	t.end();
 
 	function getter() {
@@ -79,13 +79,13 @@ tape( 'the read-only property is configurable', function test( t ) {
 	defineProperty( obj, 'foo', desc );
 	t.deepEqual( propertyDescriptor( obj, 'foo' ), desc, 'property can be reconfigured' );
 
-	t.equal( obj.beep, 'bar', 'returns expected value' );
-	t.equal( hasOwnProp( obj, 'beep' ), true, 'has property' );
+	t.strictEqual( obj.beep, 'bar', 'returns expected value' );
+	t.strictEqual( hasOwnProp( obj, 'beep' ), true, 'has property' );
 
 	// Configurable properties can be deleted...
 	delete obj.beep;
-	t.equal( obj.beep, void 0, 'returns expected value' );
-	t.equal( hasOwnProp( obj, 'beep' ), false, 'does not have property' );
+	t.strictEqual( obj.beep, void 0, 'returns expected value' );
+	t.strictEqual( hasOwnProp( obj, 'beep' ), false, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/utils/define-configurable-read-only-property/test/test.js b/lib/node_modules/@stdlib/utils/define-configurable-read-only-property/test/test.js
index 47888fa45fda..dbd0a8085d63 100644
--- a/lib/node_modules/@stdlib/utils/define-configurable-read-only-property/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-configurable-read-only-property/test/test.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function sets a property on a provided object', function test( t ) {
 	var obj = {};
 	setConfigurableReadOnly( obj, 'foo', 'bar' );
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 	t.end();
 });
 
@@ -71,13 +71,13 @@ tape( 'the read-only property is configurable', function test( t ) {
 	defineProperty( obj, 'foo', desc );
 	t.deepEqual( propertyDescriptor( obj, 'foo' ), desc, 'property can be reconfigured' );
 
-	t.equal( obj.beep, 'boop', 'returns expected value' );
-	t.equal( hasOwnProp( obj, 'beep' ), true, 'has property' );
+	t.strictEqual( obj.beep, 'boop', 'returns expected value' );
+	t.strictEqual( hasOwnProp( obj, 'beep' ), true, 'has property' );
 
 	// Configurable properties can be deleted...
 	delete obj.beep;
-	t.equal( obj.beep, void 0, 'returns expected value' );
-	t.equal( hasOwnProp( obj, 'beep' ), false, 'does not have property' );
+	t.strictEqual( obj.beep, void 0, 'returns expected value' );
+	t.strictEqual( hasOwnProp( obj, 'beep' ), false, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/define-configurable-read-write-accessor/test/test.js b/lib/node_modules/@stdlib/utils/define-configurable-read-write-accessor/test/test.js
index 531f0fc5c068..6c83402163d5 100644
--- a/lib/node_modules/@stdlib/utils/define-configurable-read-write-accessor/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-configurable-read-write-accessor/test/test.js
@@ -41,7 +41,7 @@ tape( 'the function sets a property on a provided object', function test( t ) {
 	var val = 0;
 
 	setConfigurableReadWriteAccessor( obj, 'foo', getter, setter );
-	t.equal( obj.foo, val, 'returns expected value' );
+	t.strictEqual( obj.foo, val, 'returns expected value' );
 
 	t.end();
 
@@ -59,10 +59,10 @@ tape( 'the read-write property is writable', function test( t ) {
 	var val = 0;
 
 	setConfigurableReadWriteAccessor( obj, 'foo', getter, setter );
-	t.equal( obj.foo, 0, 'returns expected value' );
+	t.strictEqual( obj.foo, 0, 'returns expected value' );
 
 	obj.foo = 1;
-	t.equal( obj.foo, 1, 'returns expected value' );
+	t.strictEqual( obj.foo, 1, 'returns expected value' );
 
 	t.end();
 
@@ -95,13 +95,13 @@ tape( 'the read-write property is configurable', function test( t ) {
 	defineProperty( obj, 'foo', desc );
 	t.deepEqual( propertyDescriptor( obj, 'foo' ), desc, 'property can be reconfigured' );
 
-	t.equal( obj.beep, 0, 'returns expected value' );
-	t.equal( hasOwnProp( obj, 'beep' ), true, 'has property' );
+	t.strictEqual( obj.beep, 0, 'returns expected value' );
+	t.strictEqual( hasOwnProp( obj, 'beep' ), true, 'has property' );
 
 	// Configurable properties can be deleted...
 	delete obj.beep;
-	t.equal( obj.beep, void 0, 'returns expected value' );
-	t.equal( hasOwnProp( obj, 'beep' ), false, 'does not have property' );
+	t.strictEqual( obj.beep, void 0, 'returns expected value' );
+	t.strictEqual( hasOwnProp( obj, 'beep' ), false, 'does not have property' );
 	t.end();
 
 	function getter() {
diff --git a/lib/node_modules/@stdlib/utils/define-configurable-write-only-accessor/test/test.js b/lib/node_modules/@stdlib/utils/define-configurable-write-only-accessor/test/test.js
index a18ec73b0465..9cc9b4c231f7 100644
--- a/lib/node_modules/@stdlib/utils/define-configurable-write-only-accessor/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-configurable-write-only-accessor/test/test.js
@@ -43,7 +43,7 @@ tape( 'the function sets a property on a provided object', function test( t ) {
 	setConfigurableWriteOnlyAccessor( obj, 'foo', setter );
 	obj.foo = 'bar';
 
-	t.equal( val, 'bar', 'equals expected value' );
+	t.strictEqual( val, 'bar', 'equals expected value' );
 	t.end();
 
 	function setter( v ) {
@@ -56,9 +56,9 @@ tape( 'the write-only property is not readable', function test( t ) {
 	var val = '';
 
 	setConfigurableWriteOnlyAccessor( obj, 'foo', setter );
-	t.equal( obj.foo, void 0, 'property cannot be get' );
+	t.strictEqual( obj.foo, void 0, 'property cannot be get' );
 
-	t.equal( val, '', 'equals expected value' );
+	t.strictEqual( val, '', 'equals expected value' );
 	t.end();
 
 	function setter(v ) {
@@ -86,14 +86,14 @@ tape( 'the write-only property is not configurable', function test( t ) {
 	defineProperty( obj, 'foo', desc );
 	t.deepEqual( propertyDescriptor( obj, 'foo' ), desc, 'property can be reconfigured' );
 
-	t.equal( hasOwnProp( obj, 'beep' ), true, 'has property' );
+	t.strictEqual( hasOwnProp( obj, 'beep' ), true, 'has property' );
 
 	// Configurable properties can be deleted...
 	delete obj.beep;
-	t.equal( obj.beep, void 0, 'returns expected value' );
-	t.equal( hasOwnProp( obj, 'beep' ), false, 'does not have property' );
+	t.strictEqual( obj.beep, void 0, 'returns expected value' );
+	t.strictEqual( hasOwnProp( obj, 'beep' ), false, 'does not have property' );
 
-	t.equal( val, '', 'equals expected value' );
+	t.strictEqual( val, '', 'equals expected value' );
 	t.end();
 
 	function setter( v ) {
@@ -108,7 +108,7 @@ tape( 'the write-only property is enumerable', function test( t ) {
 	setConfigurableWriteOnlyAccessor( obj, 'foo', setter );
 	t.deepEqual( objectKeys( obj ), [ 'foo' ], 'property is enumerable' );
 
-	t.equal( val, '', 'equals expected value' );
+	t.strictEqual( val, '', 'equals expected value' );
 	t.end();
 
 	function setter( v ) {
diff --git a/lib/node_modules/@stdlib/utils/define-memoized-configurable-read-only-property/test/test.js b/lib/node_modules/@stdlib/utils/define-memoized-configurable-read-only-property/test/test.js
index 3235bbeba528..7b32fdd9e808 100644
--- a/lib/node_modules/@stdlib/utils/define-memoized-configurable-read-only-property/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-memoized-configurable-read-only-property/test/test.js
@@ -100,10 +100,10 @@ tape( 'the function sets a configurable memoized read-only property on a provide
 	count = 0;
 
 	setMemoizedConfigurableReadOnly( obj, 'foo', foo );
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( obj.foo, 'bar', 'returns expected value' );
-		t.equal( count, 1, 'returns expected value' );
+		t.strictEqual( obj.foo, 'bar', 'returns expected value' );
+		t.strictEqual( count, 1, 'returns expected value' );
 	}
 	expected = {
 		'configurable': true,
@@ -125,15 +125,15 @@ tape( 'the set property is configurable, even after deferred evaluation', functi
 
 	obj = {};
 	setMemoizedConfigurableReadOnly( obj, 'foo', foo );
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
-	t.equal( isEnumerableProperty( obj, 'foo' ), true, 'is enumerable' );
-	t.equal( isWritableProperty( obj, 'foo' ), false, 'is not writable' );
-	t.equal( isConfigurableProperty( obj, 'foo' ), true, 'is configurable' );
-
-	t.equal( obj.foo, 'bar', 'returns expected value' );
-	t.equal( isEnumerableProperty( obj, 'foo' ), true, 'is enumerable' );
-	t.equal( isWritableProperty( obj, 'foo' ), false, 'is not writable' );
-	t.equal( isConfigurableProperty( obj, 'foo' ), true, 'is configurable' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( isEnumerableProperty( obj, 'foo' ), true, 'is enumerable' );
+	t.strictEqual( isWritableProperty( obj, 'foo' ), false, 'is not writable' );
+	t.strictEqual( isConfigurableProperty( obj, 'foo' ), true, 'is configurable' );
+
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( isEnumerableProperty( obj, 'foo' ), true, 'is enumerable' );
+	t.strictEqual( isWritableProperty( obj, 'foo' ), false, 'is not writable' );
+	t.strictEqual( isConfigurableProperty( obj, 'foo' ), true, 'is configurable' );
 	t.end();
 
 	function foo() {
diff --git a/lib/node_modules/@stdlib/utils/define-memoized-property/test/test.js b/lib/node_modules/@stdlib/utils/define-memoized-property/test/test.js
index 18f482393772..f895054e8fd6 100644
--- a/lib/node_modules/@stdlib/utils/define-memoized-property/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-memoized-property/test/test.js
@@ -131,10 +131,10 @@ tape( 'the function sets a memoized property on a provided object', function tes
 	defineMemoizedProperty( obj, 'foo', {
 		'value': foo
 	});
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( obj.foo, 'bar', 'returns expected value' );
-		t.equal( count, 1, 'returns expected value' );
+		t.strictEqual( obj.foo, 'bar', 'returns expected value' );
+		t.strictEqual( count, 1, 'returns expected value' );
 	}
 	expected = {
 		'configurable': false,
@@ -153,10 +153,10 @@ tape( 'the function sets a memoized property on a provided object', function tes
 		'writable': true,
 		'value': foo
 	});
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( obj.foo, 'bar', 'returns expected value' );
-		t.equal( count, 1, 'returns expected value' );
+		t.strictEqual( obj.foo, 'bar', 'returns expected value' );
+		t.strictEqual( count, 1, 'returns expected value' );
 	}
 	expected = {
 		'configurable': false,
@@ -182,10 +182,10 @@ tape( 'by default, the function sets a non-enumerable memoized property on a pro
 	defineMemoizedProperty( obj, 'foo', {
 		'value': foo
 	});
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
 	t.deepEqual( objectKeys( obj ), [], 'property is not enumerable' );
 
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 	t.deepEqual( objectKeys( obj ), [], 'property is not enumerable' );
 
 	expected = {
@@ -212,10 +212,10 @@ tape( 'the function supports setting an enumerable memoized property on a provid
 		'enumerable': true,
 		'value': foo
 	});
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
 	t.deepEqual( objectKeys( obj ), [ 'foo' ], 'property is enumerable' );
 
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 	t.deepEqual( objectKeys( obj ), [ 'foo' ], 'property is enumerable' );
 
 	expected = {
@@ -242,10 +242,10 @@ tape( 'the function supports setting a non-enumerable memoized property on a pro
 		'enumerable': false,
 		'value': foo
 	});
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
 	t.deepEqual( objectKeys( obj ), [], 'property is not enumerable' );
 
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 	t.deepEqual( objectKeys( obj ), [], 'property is not enumerable' );
 
 	expected = {
@@ -271,9 +271,9 @@ tape( 'by default, the function sets a non-writable memoized property on a provi
 	defineMemoizedProperty( obj, 'foo', {
 		'value': foo
 	});
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
-	t.equal( isWritableProperty( obj, 'foo' ), false, 'is not writable' );
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( isWritableProperty( obj, 'foo' ), false, 'is not writable' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 
 	expected = {
 		'configurable': false,
@@ -299,9 +299,9 @@ tape( 'the function supports setting a writable memoized property on a provided
 		'writable': true,
 		'value': foo
 	});
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
-	t.equal( isWritableProperty( obj, 'foo' ), true, 'is writable' );
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( isWritableProperty( obj, 'foo' ), true, 'is writable' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 
 	expected = {
 		'configurable': false,
@@ -327,9 +327,9 @@ tape( 'the function supports setting a non-writable memoized property on a provi
 		'writable': false,
 		'value': foo
 	});
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
-	t.equal( isWritableProperty( obj, 'foo' ), false, 'is not writable' );
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( isWritableProperty( obj, 'foo' ), false, 'is not writable' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 
 	expected = {
 		'configurable': false,
@@ -354,8 +354,8 @@ tape( 'by default, the function sets a non-configurable memoized property on a p
 	defineMemoizedProperty( obj, 'foo', {
 		'value': foo
 	});
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 
 	expected = {
 		'configurable': false,
@@ -381,8 +381,8 @@ tape( 'the function supports setting a configurable memoized property on a provi
 		'configurable': true,
 		'value': foo
 	});
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 
 	expected = {
 		'configurable': true,
@@ -408,8 +408,8 @@ tape( 'the function supports setting a non-configurable memoized property on a p
 		'configurable': false,
 		'value': foo
 	});
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 
 	expected = {
 		'configurable': false,
@@ -434,11 +434,11 @@ tape( 'until deferred evaluation, the set property is temporarily configurable',
 		'configurable': false,
 		'value': foo
 	});
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
-	t.equal( isConfigurableProperty( obj, 'foo' ), true, 'is configurable' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( isConfigurableProperty( obj, 'foo' ), true, 'is configurable' );
 
-	t.equal( obj.foo, 'bar', 'returns expected value' );
-	t.equal( isConfigurableProperty( obj, 'foo' ), false, 'is not configurable' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( isConfigurableProperty( obj, 'foo' ), false, 'is not configurable' );
 	t.end();
 
 	function foo() {
diff --git a/lib/node_modules/@stdlib/utils/define-memoized-read-only-property/test/test.js b/lib/node_modules/@stdlib/utils/define-memoized-read-only-property/test/test.js
index 4beff3b22076..5f2c9cd69469 100644
--- a/lib/node_modules/@stdlib/utils/define-memoized-read-only-property/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-memoized-read-only-property/test/test.js
@@ -100,10 +100,10 @@ tape( 'the function sets a memoized read-only property on a provided object', fu
 	count = 0;
 
 	setMemoizedReadOnly( obj, 'foo', foo );
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( obj.foo, 'bar', 'returns expected value' );
-		t.equal( count, 1, 'returns expected value' );
+		t.strictEqual( obj.foo, 'bar', 'returns expected value' );
+		t.strictEqual( count, 1, 'returns expected value' );
 	}
 	expected = {
 		'configurable': false,
@@ -125,15 +125,15 @@ tape( 'until deferred evaluation, the set property is temporarily configurable',
 
 	obj = {};
 	setMemoizedReadOnly( obj, 'foo', foo );
-	t.equal( hasOwnProp( obj, 'foo' ), true, 'has property' );
-	t.equal( isEnumerableProperty( obj, 'foo' ), true, 'is enumerable' );
-	t.equal( isWritableProperty( obj, 'foo' ), false, 'is not writable' );
-	t.equal( isConfigurableProperty( obj, 'foo' ), true, 'is configurable' );
-
-	t.equal( obj.foo, 'bar', 'returns expected value' );
-	t.equal( isEnumerableProperty( obj, 'foo' ), true, 'is enumerable' );
-	t.equal( isWritableProperty( obj, 'foo' ), false, 'is not writable' );
-	t.equal( isConfigurableProperty( obj, 'foo' ), false, 'is not configurable' );
+	t.strictEqual( hasOwnProp( obj, 'foo' ), true, 'has property' );
+	t.strictEqual( isEnumerableProperty( obj, 'foo' ), true, 'is enumerable' );
+	t.strictEqual( isWritableProperty( obj, 'foo' ), false, 'is not writable' );
+	t.strictEqual( isConfigurableProperty( obj, 'foo' ), true, 'is configurable' );
+
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( isEnumerableProperty( obj, 'foo' ), true, 'is enumerable' );
+	t.strictEqual( isWritableProperty( obj, 'foo' ), false, 'is not writable' );
+	t.strictEqual( isConfigurableProperty( obj, 'foo' ), false, 'is not configurable' );
 	t.end();
 
 	function foo() {
diff --git a/lib/node_modules/@stdlib/utils/define-nonenumerable-property/test/test.js b/lib/node_modules/@stdlib/utils/define-nonenumerable-property/test/test.js
index 639052b1ab1e..f893ed408c30 100644
--- a/lib/node_modules/@stdlib/utils/define-nonenumerable-property/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-nonenumerable-property/test/test.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function sets a property on a provided object', function test( t ) {
 	var obj = {};
 	setNonEnumerableProperty( obj, 'foo', 'bar' );
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 	t.end();
 });
 
@@ -48,7 +48,7 @@ tape( 'the property is writable', function test( t ) {
 
 	obj = {};
 	setNonEnumerableProperty( obj, 'foo', 'bar' );
-	t.equal( isWritableProperty( obj, 'foo' ), true, 'property is writable' );
+	t.strictEqual( isWritableProperty( obj, 'foo' ), true, 'property is writable' );
 
 	// The following should not throw...
 	obj.foo = 'beep';
@@ -63,11 +63,11 @@ tape( 'the property is configurable', function test( t ) {
 	setNonEnumerableProperty( obj, 'foo', 'bar' );
 
 	delete obj.foo;
-	t.equal( obj.foo, void 0, 'returns expected value' );
+	t.strictEqual( obj.foo, void 0, 'returns expected value' );
 
 	obj = {};
 	setNonEnumerableProperty( obj, 'foo', 'bar' );
-	t.equal( isConfigurableProperty( obj, 'foo' ), true, 'property is configurable' );
+	t.strictEqual( isConfigurableProperty( obj, 'foo' ), true, 'property is configurable' );
 
 	// The following should not throw...
 	defineProperty( obj, 'foo', {
@@ -83,6 +83,6 @@ tape( 'the property is configurable', function test( t ) {
 tape( 'the property is not enumerable (in supporting environments; ES5+)', function test( t ) {
 	var obj = {};
 	setNonEnumerableProperty( obj, 'foo', 'bar' );
-	t.equal( isNonEnumerableProperty( obj, 'foo' ), true, 'property is not enumerable' );
+	t.strictEqual( isNonEnumerableProperty( obj, 'foo' ), true, 'property is not enumerable' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/define-nonenumerable-read-only-accessor/test/test.js b/lib/node_modules/@stdlib/utils/define-nonenumerable-read-only-accessor/test/test.js
index 10aa2abfdb9a..604a62638681 100644
--- a/lib/node_modules/@stdlib/utils/define-nonenumerable-read-only-accessor/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-nonenumerable-read-only-accessor/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function sets a property on a provided object', function test( t ) {
 	var obj = {};
 	setNonEnumerableReadOnlyAccessor( obj, 'foo', getter );
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 	t.end();
 
 	function getter() {
@@ -87,7 +87,7 @@ tape( 'the read-only property is not configurable', function test( t ) {
 tape( 'the read-only property is not enumerable', function test( t ) {
 	var obj = {};
 	setNonEnumerableReadOnlyAccessor( obj, 'foo', getter );
-	t.equal( objectKeys( obj ).length, 0, 'property is not enumerable' );
+	t.strictEqual( objectKeys( obj ).length, 0, 'property is not enumerable' );
 	t.end();
 
 	function getter() {
diff --git a/lib/node_modules/@stdlib/utils/define-nonenumerable-read-only-property/test/test.js b/lib/node_modules/@stdlib/utils/define-nonenumerable-read-only-property/test/test.js
index 33af708c45e1..bb0c590b576f 100644
--- a/lib/node_modules/@stdlib/utils/define-nonenumerable-read-only-property/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-nonenumerable-read-only-property/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function sets a property on a provided object', function test( t ) {
 	var obj = {};
 	setNonEnumerableReadOnly( obj, 'foo', 'bar' );
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 	t.end();
 });
 
@@ -76,6 +76,6 @@ tape( 'the read-only property is not configurable', function test( t ) {
 tape( 'the read-only property is not enumerable', function test( t ) {
 	var obj = {};
 	setNonEnumerableReadOnly( obj, 'foo', 'bar' );
-	t.equal( objectKeys( obj ).length, 0, 'property is not enumerable' );
+	t.strictEqual( objectKeys( obj ).length, 0, 'property is not enumerable' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/define-nonenumerable-read-write-accessor/test/test.js b/lib/node_modules/@stdlib/utils/define-nonenumerable-read-write-accessor/test/test.js
index 851300ea9415..6829115ebbd3 100644
--- a/lib/node_modules/@stdlib/utils/define-nonenumerable-read-write-accessor/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-nonenumerable-read-write-accessor/test/test.js
@@ -39,7 +39,7 @@ tape( 'the function sets a property on a provided object', function test( t ) {
 	var val = 0;
 
 	setNonEnumerableReadWriteAccessor( obj, 'foo', getter, setter );
-	t.equal( obj.foo, val, 'returns expected value' );
+	t.strictEqual( obj.foo, val, 'returns expected value' );
 
 	t.end();
 
@@ -57,10 +57,10 @@ tape( 'the read-write property is writable', function test( t ) {
 	var val = 0;
 
 	setNonEnumerableReadWriteAccessor( obj, 'foo', getter, setter );
-	t.equal( obj.foo, 0, 'returns expected value' );
+	t.strictEqual( obj.foo, 0, 'returns expected value' );
 
 	obj.foo = 1;
-	t.equal( obj.foo, 1, 'returns expected value' );
+	t.strictEqual( obj.foo, 1, 'returns expected value' );
 
 	t.end();
 
@@ -111,7 +111,7 @@ tape( 'the read-write property is not enumerable', function test( t ) {
 
 	setNonEnumerableReadWriteAccessor( obj, 'foo', getter, setter );
 
-	t.equal( objectKeys( obj ).length, 0, 'property is not enumerable' );
+	t.strictEqual( objectKeys( obj ).length, 0, 'property is not enumerable' );
 	t.end();
 
 	function getter() {
diff --git a/lib/node_modules/@stdlib/utils/define-nonenumerable-write-only-accessor/test/test.js b/lib/node_modules/@stdlib/utils/define-nonenumerable-write-only-accessor/test/test.js
index 757701710274..6972f9203259 100644
--- a/lib/node_modules/@stdlib/utils/define-nonenumerable-write-only-accessor/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-nonenumerable-write-only-accessor/test/test.js
@@ -41,7 +41,7 @@ tape( 'the function sets a property on a provided object', function test( t ) {
 	setNonEnumerableWriteOnlyAccessor( obj, 'foo', setter );
 	obj.foo = 'bar';
 
-	t.equal( val, 'bar', 'equals expected value' );
+	t.strictEqual( val, 'bar', 'equals expected value' );
 	t.end();
 
 	function setter( v ) {
@@ -54,9 +54,9 @@ tape( 'the write-only property is not readable', function test( t ) {
 	var val = '';
 
 	setNonEnumerableWriteOnlyAccessor( obj, 'foo', setter );
-	t.equal( obj.foo, void 0, 'property cannot be get' );
+	t.strictEqual( obj.foo, void 0, 'property cannot be get' );
 
-	t.equal( val, '', 'equals expected value' );
+	t.strictEqual( val, '', 'equals expected value' );
 	t.end();
 
 	function setter(v ) {
@@ -72,7 +72,7 @@ tape( 'the write-only property is not configurable', function test( t ) {
 	t.throws( foo, Error, 'property cannot be deleted' );
 	t.throws( bar, Error, 'property cannot be reconfigured' );
 
-	t.equal( val, '', 'equals expected value' );
+	t.strictEqual( val, '', 'equals expected value' );
 	t.end();
 
 	function setter( v ) {
@@ -98,9 +98,9 @@ tape( 'the write-only property is not enumerable', function test( t ) {
 	var val = '';
 
 	setNonEnumerableWriteOnlyAccessor( obj, 'foo', setter );
-	t.equal( objectKeys( obj ).length, 0, 'property is not enumerable' );
+	t.strictEqual( objectKeys( obj ).length, 0, 'property is not enumerable' );
 
-	t.equal( val, '', 'equals expected value' );
+	t.strictEqual( val, '', 'equals expected value' );
 	t.end();
 
 	function setter( v ) {
diff --git a/lib/node_modules/@stdlib/utils/define-properties/test/test.js b/lib/node_modules/@stdlib/utils/define-properties/test/test.js
index c82679fd4be3..ca6a9a2fb3c4 100644
--- a/lib/node_modules/@stdlib/utils/define-properties/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-properties/test/test.js
@@ -40,7 +40,7 @@ tape( 'if an environment supports `Object.defineProperties`, the exported value
 		'@stdlib/assert/has-define-properties-support': mock
 	});
 
-	t.equal( defineProperties, builtin, 'exports built-in' );
+	t.strictEqual( defineProperties, builtin, 'exports built-in' );
 	t.end();
 
 	function mock() {
@@ -53,7 +53,7 @@ tape( 'if an environment does not support `Object.defineProperties`, the exporte
 		'@stdlib/assert/has-define-properties-support': mock
 	});
 
-	t.equal( defineProperties, polyfill, 'exports polyfill' );
+	t.strictEqual( defineProperties, polyfill, 'exports polyfill' );
 	t.end();
 
 	function mock() {
diff --git a/lib/node_modules/@stdlib/utils/define-property/test/test.js b/lib/node_modules/@stdlib/utils/define-property/test/test.js
index b8e6a44826d1..436f1988c365 100644
--- a/lib/node_modules/@stdlib/utils/define-property/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-property/test/test.js
@@ -40,7 +40,7 @@ tape( 'if an environment supports `Object.defineProperty`, the exported value is
 		'./has_define_property_support.js': mock
 	});
 
-	t.equal( defineProperty, builtin, 'exports built-in' );
+	t.strictEqual( defineProperty, builtin, 'exports built-in' );
 	t.end();
 
 	function mock() {
@@ -53,7 +53,7 @@ tape( 'if an environment does not support `Object.defineProperty`, the exported
 		'./has_define_property_support.js': mock
 	});
 
-	t.equal( defineProperty, polyfill, 'exports polyfill' );
+	t.strictEqual( defineProperty, polyfill, 'exports polyfill' );
 	t.end();
 
 	function mock() {
@@ -66,6 +66,6 @@ tape( 'the function sets a property on a provided object', function test( t ) {
 	defineProperty( obj, 'foo', {
 		'value': 'bar'
 	});
-	t.equal( obj.foo, 'bar', 'prop foo equals bar' );
+	t.strictEqual( obj.foo, 'bar', 'prop foo equals bar' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/define-property/test/test.polyfill.js b/lib/node_modules/@stdlib/utils/define-property/test/test.polyfill.js
index 96ebe18386d2..7cb5589e8100 100644
--- a/lib/node_modules/@stdlib/utils/define-property/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/utils/define-property/test/test.polyfill.js
@@ -148,14 +148,14 @@ tape( 'the property is enumerable no matter the value of the `enumerable` option
 		'value': 'bar',
 		'enumerable': false
 	});
-	t.equal( objectKeys( obj )[ 0 ], 'foo', 'property is enumerable' );
+	t.strictEqual( objectKeys( obj )[ 0 ], 'foo', 'property is enumerable' );
 
 	obj = {};
 	defineProperty( obj, 'foo', {
 		'value': 'bar',
 		'enumerable': true
 	});
-	t.equal( objectKeys( obj )[ 0 ], 'foo', 'property is enumerable' );
+	t.strictEqual( objectKeys( obj )[ 0 ], 'foo', 'property is enumerable' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/define-read-only-accessor/test/test.js b/lib/node_modules/@stdlib/utils/define-read-only-accessor/test/test.js
index 8bea64c5384a..9cc997581f1f 100644
--- a/lib/node_modules/@stdlib/utils/define-read-only-accessor/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-read-only-accessor/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function sets a property on a provided object', function test( t ) {
 	var obj = {};
 	setReadOnlyAccessor( obj, 'foo', getter );
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 	t.end();
 
 	function getter() {
@@ -87,7 +87,7 @@ tape( 'the read-only property is not configurable', function test( t ) {
 tape( 'the read-only property is enumerable', function test( t ) {
 	var obj = {};
 	setReadOnlyAccessor( obj, 'foo', getter );
-	t.equal( objectKeys( obj )[ 0 ], 'foo', 'property is enumerable' );
+	t.strictEqual( objectKeys( obj )[ 0 ], 'foo', 'property is enumerable' );
 	t.end();
 
 	function getter() {
diff --git a/lib/node_modules/@stdlib/utils/define-read-only-property/test/test.js b/lib/node_modules/@stdlib/utils/define-read-only-property/test/test.js
index 24f990cef129..ce97a38f0ff1 100644
--- a/lib/node_modules/@stdlib/utils/define-read-only-property/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-read-only-property/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function sets a property on a provided object', function test( t ) {
 	var obj = {};
 	setReadOnly( obj, 'foo', 'bar' );
-	t.equal( obj.foo, 'bar', 'returns expected value' );
+	t.strictEqual( obj.foo, 'bar', 'returns expected value' );
 	t.end();
 });
 
@@ -76,6 +76,6 @@ tape( 'the read-only property is not configurable', function test( t ) {
 tape( 'the read-only property is enumerable', function test( t ) {
 	var obj = {};
 	setReadOnly( obj, 'foo', 'bar' );
-	t.equal( objectKeys( obj )[ 0 ], 'foo', 'property is enumerable' );
+	t.strictEqual( objectKeys( obj )[ 0 ], 'foo', 'property is enumerable' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/define-read-write-accessor/test/test.js b/lib/node_modules/@stdlib/utils/define-read-write-accessor/test/test.js
index 89cdf13ad0d3..ff27a9bbf7ba 100644
--- a/lib/node_modules/@stdlib/utils/define-read-write-accessor/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-read-write-accessor/test/test.js
@@ -39,7 +39,7 @@ tape( 'the function sets a property on a provided object', function test( t ) {
 	var val = 0;
 
 	setReadWriteAccessor( obj, 'foo', getter, setter );
-	t.equal( obj.foo, val, 'returns expected value' );
+	t.strictEqual( obj.foo, val, 'returns expected value' );
 
 	t.end();
 
@@ -57,10 +57,10 @@ tape( 'the read-write property is writable', function test( t ) {
 	var val = 0;
 
 	setReadWriteAccessor( obj, 'foo', getter, setter );
-	t.equal( obj.foo, 0, 'returns expected value' );
+	t.strictEqual( obj.foo, 0, 'returns expected value' );
 
 	obj.foo = 1;
-	t.equal( obj.foo, 1, 'returns expected value' );
+	t.strictEqual( obj.foo, 1, 'returns expected value' );
 
 	t.end();
 
@@ -111,7 +111,7 @@ tape( 'the read-write property is enumerable', function test( t ) {
 
 	setReadWriteAccessor( obj, 'foo', getter, setter );
 
-	t.equal( objectKeys( obj )[ 0 ], 'foo', 'property is enumerable' );
+	t.strictEqual( objectKeys( obj )[ 0 ], 'foo', 'property is enumerable' );
 	t.end();
 
 	function getter() {
diff --git a/lib/node_modules/@stdlib/utils/define-write-only-accessor/test/test.js b/lib/node_modules/@stdlib/utils/define-write-only-accessor/test/test.js
index 10134f0d4207..15b21904d9f5 100644
--- a/lib/node_modules/@stdlib/utils/define-write-only-accessor/test/test.js
+++ b/lib/node_modules/@stdlib/utils/define-write-only-accessor/test/test.js
@@ -41,7 +41,7 @@ tape( 'the function sets a property on a provided object', function test( t ) {
 	setWriteOnlyAccessor( obj, 'foo', setter );
 	obj.foo = 'bar';
 
-	t.equal( val, 'bar', 'equals expected value' );
+	t.strictEqual( val, 'bar', 'equals expected value' );
 	t.end();
 
 	function setter( v ) {
@@ -54,9 +54,9 @@ tape( 'the write-only property is not readable', function test( t ) {
 	var val = '';
 
 	setWriteOnlyAccessor( obj, 'foo', setter );
-	t.equal( obj.foo, void 0, 'property cannot be get' );
+	t.strictEqual( obj.foo, void 0, 'property cannot be get' );
 
-	t.equal( val, '', 'equals expected value' );
+	t.strictEqual( val, '', 'equals expected value' );
 	t.end();
 
 	function setter(v ) {
@@ -72,7 +72,7 @@ tape( 'the write-only property is not configurable', function test( t ) {
 	t.throws( foo, Error, 'property cannot be deleted' );
 	t.throws( bar, Error, 'property cannot be reconfigured' );
 
-	t.equal( val, '', 'equals expected value' );
+	t.strictEqual( val, '', 'equals expected value' );
 	t.end();
 
 	function setter( v ) {
@@ -98,9 +98,9 @@ tape( 'the write-only property is enumerable', function test( t ) {
 	var val = '';
 
 	setWriteOnlyAccessor( obj, 'foo', setter );
-	t.equal( objectKeys( obj )[ 0 ], 'foo', 'property is enumerable' );
+	t.strictEqual( objectKeys( obj )[ 0 ], 'foo', 'property is enumerable' );
 
-	t.equal( val, '', 'equals expected value' );
+	t.strictEqual( val, '', 'equals expected value' );
 	t.end();
 
 	function setter( v ) {
diff --git a/lib/node_modules/@stdlib/utils/dirname/test/test.js b/lib/node_modules/@stdlib/utils/dirname/test/test.js
index 34b75d3a11eb..664d8abd625b 100644
--- a/lib/node_modules/@stdlib/utils/dirname/test/test.js
+++ b/lib/node_modules/@stdlib/utils/dirname/test/test.js
@@ -80,7 +80,7 @@ tape( 'the function returns a directory name', function test( t ) {
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( dirname( values[ i ] ), expected[ i ], values[ i ] );
+		t.strictEqual( dirname( values[ i ] ), expected[ i ], values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/dsv/base/parse/test/test.js b/lib/node_modules/@stdlib/utils/dsv/base/parse/test/test.js
index f5e2511070c0..9ff366c0745b 100644
--- a/lib/node_modules/@stdlib/utils/dsv/base/parse/test/test.js
+++ b/lib/node_modules/@stdlib/utils/dsv/base/parse/test/test.js
@@ -34,26 +34,26 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function is a constructor', function test( t ) {
 	var p = new Parser();
-	t.equal( p instanceof Parser, true, 'returns expected value' );
+	t.strictEqual( p instanceof Parser, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function is a constructor (options)', function test( t ) {
 	var p = new Parser( {} );
-	t.equal( p instanceof Parser, true, 'returns expected value' );
+	t.strictEqual( p instanceof Parser, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor does not require the `new` keyword', function test( t ) {
 	var parser = Parser;
 	var p = parser();
-	t.equal( p instanceof Parser, true, 'returns expected value' );
+	t.strictEqual( p instanceof Parser, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor does not require the `new` keyword (options)', function test( t ) {
 	var parser = Parser;
 	var p = parser( {} );
-	t.equal( p instanceof Parser, true, 'returns expected value' );
+	t.strictEqual( p instanceof Parser, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/dsv/base/test/test.js b/lib/node_modules/@stdlib/utils/dsv/base/test/test.js
index 7aaccf61a954..d076d7a5e554 100644
--- a/lib/node_modules/@stdlib/utils/dsv/base/test/test.js
+++ b/lib/node_modules/@stdlib/utils/dsv/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains base utilities for working with data formatted as delimeter separated values (DSV)', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/dsv/test/test.js b/lib/node_modules/@stdlib/utils/dsv/test/test.js
index ace6fb740949..42d905d905b2 100644
--- a/lib/node_modules/@stdlib/utils/dsv/test/test.js
+++ b/lib/node_modules/@stdlib/utils/dsv/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains utilities for working with data formatted as delimeter separated values (DSV)', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/eval/test/test.js b/lib/node_modules/@stdlib/utils/eval/test/test.js
index ab98c591d28b..6353c88152fe 100644
--- a/lib/node_modules/@stdlib/utils/eval/test/test.js
+++ b/lib/node_modules/@stdlib/utils/eval/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'export is an alias for `eval`', function test( t ) {
-	t.equal( evil, eval, 'alias for `eval`' ); // eslint-disable-line no-eval
+	t.strictEqual( evil, eval, 'alias for `eval`' ); // eslint-disable-line no-eval
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/extname/test/test.js b/lib/node_modules/@stdlib/utils/extname/test/test.js
index 70093ab136f2..e2427cdbab46 100644
--- a/lib/node_modules/@stdlib/utils/extname/test/test.js
+++ b/lib/node_modules/@stdlib/utils/extname/test/test.js
@@ -81,7 +81,7 @@ tape( 'the function returns a filename extension', function test( t ) {
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( extname( values[ i ] ), expected[ i ], values[ i ] );
+		t.strictEqual( extname( values[ i ] ), expected[ i ], values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/flatten-array/test/test.factory.js b/lib/node_modules/@stdlib/utils/flatten-array/test/test.factory.js
index 05c9c608c044..5f8d59e1e3f3 100644
--- a/lib/node_modules/@stdlib/utils/flatten-array/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/flatten-array/test/test.factory.js
@@ -155,10 +155,10 @@ tape( 'the function returns a function', function test( t ) {
 	var flattenArray;
 
 	flattenArray = factory( [ 1, 2, 3 ] );
-	t.equal( typeof flattenArray, 'function', 'returns a function' );
+	t.strictEqual( typeof flattenArray, 'function', 'returns a function' );
 
 	flattenArray = factory( [ 1, 2, 3 ], {} );
-	t.equal( typeof flattenArray, 'function', 'returns a function' );
+	t.strictEqual( typeof flattenArray, 'function', 'returns a function' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/flatten-array/test/test.js b/lib/node_modules/@stdlib/utils/flatten-array/test/test.js
index 3635dbccd2c2..c1b6068bf8a5 100644
--- a/lib/node_modules/@stdlib/utils/flatten-array/test/test.js
+++ b/lib/node_modules/@stdlib/utils/flatten-array/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory function', function test( t ) {
-	t.equal( typeof flattenArray.factory, 'function', 'has a factory method' );
+	t.strictEqual( typeof flattenArray.factory, 'function', 'has a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/flatten-array/test/test.main.js b/lib/node_modules/@stdlib/utils/flatten-array/test/test.main.js
index 22a2e5b53733..efe7ae840d0e 100644
--- a/lib/node_modules/@stdlib/utils/flatten-array/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/flatten-array/test/test.main.js
@@ -150,7 +150,7 @@ tape( 'if the `depth` option is `0`, the function returns the input array', func
 		'depth': 0
 	});
 
-	t.equal( arr, actual, 'same reference' );
+	t.strictEqual( arr, actual, 'same reference' );
 	t.deepEqual( actual, expected, 'deep equal' );
 
 	t.end();
@@ -215,7 +215,7 @@ tape( 'the function flattens an array to a specified depth', function test( t )
 	expected = [ 1, 2, 3, [4, [ 5 ], 6], 7, 8, 9 ];
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( arr[ 1 ][ 1 ][ 1 ], actual[ 3 ], 'same reference' );
+	t.strictEqual( arr[ 1 ][ 1 ][ 1 ], actual[ 3 ], 'same reference' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/flatten-array/test/test.validate.js b/lib/node_modules/@stdlib/utils/flatten-array/test/test.validate.js
index 09c8de4fb836..6a6a94e23ff3 100644
--- a/lib/node_modules/@stdlib/utils/flatten-array/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/flatten-array/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided a `depth` option which is not a
 		err = validate( {}, {
 			'depth': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns an error if provided a `copy` option which is not a
 		err = validate( {}, {
 			'copy': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -117,7 +117,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 
-	t.equal( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns null' );
 	t.notEqual( obj, opts, 'different references' );
 	t.deepEqual( obj, opts, 'sets options' );
 
@@ -134,7 +134,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	};
 	obj = {};
 
-	t.equal( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/flatten-object/test/test.factory.js b/lib/node_modules/@stdlib/utils/flatten-object/test/test.factory.js
index 7a66e51f6bc7..411b54831937 100644
--- a/lib/node_modules/@stdlib/utils/flatten-object/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/flatten-object/test/test.factory.js
@@ -90,7 +90,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a function', function test( t ) {
 	var flatten = factory( {} );
-	t.equal( typeof flatten, 'function', 'returns a function' );
+	t.strictEqual( typeof flatten, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -148,7 +148,7 @@ tape( 'if the `depth` option is `0`, the returned function returns the input val
 	};
 	actual = flattenObject( obj );
 
-	t.equal( obj, actual, 'same reference' );
+	t.strictEqual( obj, actual, 'same reference' );
 	t.deepEqual( actual, expected, 'deep equal' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'by default, the returned function does not flatten arrays', function test
 	actual = flattenObject( obj );
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( actual[ 'a.b.c' ], obj.a.b.c, 'same reference' );
+	t.strictEqual( actual[ 'a.b.c' ], obj.a.b.c, 'same reference' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/flatten-object/test/test.js b/lib/node_modules/@stdlib/utils/flatten-object/test/test.js
index c616b8996bf1..d292e4563be0 100644
--- a/lib/node_modules/@stdlib/utils/flatten-object/test/test.js
+++ b/lib/node_modules/@stdlib/utils/flatten-object/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory function', function test( t ) {
-	t.equal( typeof flattenObject.factory, 'function', 'has a factory method' );
+	t.strictEqual( typeof flattenObject.factory, 'function', 'has a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/flatten-object/test/test.main.js b/lib/node_modules/@stdlib/utils/flatten-object/test/test.main.js
index 2a33f31bc1eb..37dcda6b0c89 100644
--- a/lib/node_modules/@stdlib/utils/flatten-object/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/flatten-object/test/test.main.js
@@ -161,7 +161,7 @@ tape( 'if the `depth` option is `0`, the function returns the input value', func
 		'depth': 0
 	});
 
-	t.equal( obj, actual, 'same reference' );
+	t.strictEqual( obj, actual, 'same reference' );
 	t.deepEqual( actual, expected, 'deep equal' );
 
 	t.end();
@@ -316,7 +316,7 @@ tape( 'by default, the function does not flatten arrays', function test( t ) {
 	actual = flattenObject( obj );
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( actual[ 'a.b.c' ], obj.a.b.c, 'same reference' );
+	t.strictEqual( actual[ 'a.b.c' ], obj.a.b.c, 'same reference' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/flatten-object/test/test.validate.js b/lib/node_modules/@stdlib/utils/flatten-object/test/test.validate.js
index 8cd82a5fd3b6..aee7e72278c7 100644
--- a/lib/node_modules/@stdlib/utils/flatten-object/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/flatten-object/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns an error if provided an options argument which is no
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided a `depth` option which is not a
 		err = validate( {}, {
 			'depth': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns an error if provided a `copy` option which is not a
 		err = validate( {}, {
 			'copy': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function returns an error if provided a `flattenArrays` option which
 		err = validate( {}, {
 			'flattenArrays': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function returns an error if provided an `delimiter` option which is
 		err = validate( {}, {
 			'delimiter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -169,7 +169,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 
-	t.equal( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns null' );
 	t.notEqual( obj, opts, 'different references' );
 	t.deepEqual( obj, opts, 'sets options' );
 
@@ -186,7 +186,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	};
 	obj = {};
 
-	t.equal( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/function-name/test/test.js b/lib/node_modules/@stdlib/utils/function-name/test/test.js
index cfd3e0844309..0f4cbe006447 100644
--- a/lib/node_modules/@stdlib/utils/function-name/test/test.js
+++ b/lib/node_modules/@stdlib/utils/function-name/test/test.js
@@ -69,15 +69,15 @@ tape( 'the function returns a function\'s name', function test( t ) {
 	function beep() {
 		return 'boop';
 	}
-	t.equal( functionName( beep ), 'beep', 'returns beep' );
-	t.equal( functionName( Date ), 'Date', 'returns Date' );
-	t.equal( functionName( Buffer ), 'Buffer', 'returns Buffer' );
-	t.equal( functionName( Number ), 'Number', 'returns Number' );
-	t.equal( functionName( Math.sqrt ), 'sqrt', 'returns sqrt' ); // eslint-disable-line stdlib/no-builtin-math
-	t.equal( functionName( Int8Array ), 'Int8Array', 'returns Int8Array' );
-	t.equal( functionName( Boolean ), 'Boolean', 'returns Boolean' );
-	t.equal( functionName( String ), 'String', 'returns String' );
-	t.equal( functionName( Fcn ), 'Function', 'returns Function' );
+	t.strictEqual( functionName( beep ), 'beep', 'returns beep' );
+	t.strictEqual( functionName( Date ), 'Date', 'returns Date' );
+	t.strictEqual( functionName( Buffer ), 'Buffer', 'returns Buffer' );
+	t.strictEqual( functionName( Number ), 'Number', 'returns Number' );
+	t.strictEqual( functionName( Math.sqrt ), 'sqrt', 'returns sqrt' ); // eslint-disable-line stdlib/no-builtin-math
+	t.strictEqual( functionName( Int8Array ), 'Int8Array', 'returns Int8Array' );
+	t.strictEqual( functionName( Boolean ), 'Boolean', 'returns Boolean' );
+	t.strictEqual( functionName( String ), 'String', 'returns String' );
+	t.strictEqual( functionName( Fcn ), 'Function', 'returns Function' );
 	t.end();
 });
 
@@ -95,10 +95,10 @@ tape( 'if provided an anonymous function, the function returns an empty string o
 	*/
 
 	name = functionName( function () {} ); // eslint-disable-line func-names
-	t.equal( check( name ), true, 'returns an empty string (or "anonymous")' );
+	t.strictEqual( check( name ), true, 'returns an empty string (or "anonymous")' );
 
 	name = functionName( new Fcn('a', 'b', 'return') );
-	t.equal( check( name ), true, 'returns an empty string (or "anonymous")' );
+	t.strictEqual( check( name ), true, 'returns an empty string (or "anonymous")' );
 
 	t.end();
 
@@ -114,7 +114,7 @@ tape( 'the function supports returning a function name in ES5 and earlier enviro
 	var functionName = proxyquire( './../lib/main.js', {
 		'@stdlib/assert/has-function-name-support': stub
 	});
-	t.equal( functionName( beep ), 'beep', 'returns beep' );
+	t.strictEqual( functionName( beep ), 'beep', 'returns beep' );
 	t.end();
 
 	function beep() {
diff --git a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.detect.js b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.detect.js
index 801f203d9186..47a52032323e 100644
--- a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.detect.js
+++ b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.detect.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 	getProto = require( './../lib/detect.js' );
 
-	t.equal( typeof getProto, 'function', 'export is a function' );
+	t.strictEqual( typeof getProto, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -44,7 +44,7 @@ tape( 'if an environment supports `Object.getPrototypeOf`, the exported value is
 		'@stdlib/assert/is-function': isFunction
 	});
 
-	t.equal( getProto, builtin, 'exports built-in' );
+	t.strictEqual( getProto, builtin, 'exports built-in' );
 	t.end();
 
 	function isFunction() {
@@ -57,7 +57,7 @@ tape( 'if an environment does not support `Object.getPrototypeOf`, the exported
 		'@stdlib/assert/is-function': isFunction
 	});
 
-	t.equal( getProto, polyfill, 'exports polyfill' );
+	t.strictEqual( getProto, polyfill, 'exports polyfill' );
 	t.end();
 
 	function isFunction() {
diff --git a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.js b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.js
index d8d36967e966..e0fc8d6b0f25 100644
--- a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.js
+++ b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.js
@@ -40,10 +40,10 @@ tape( 'the function returns `null` if provided either `null` or `undefined`', fu
 	var proto;
 
 	proto = getPrototypeOf( null );
-	t.equal( proto, null, 'returns `null` when provided `null`' );
+	t.strictEqual( proto, null, 'returns `null` when provided `null`' );
 
 	proto = getPrototypeOf( void 0 );
-	t.equal( proto, null, 'returns `null` when provided `undefined`' );
+	t.strictEqual( proto, null, 'returns `null` when provided `undefined`' );
 
 	t.end();
 });
@@ -56,11 +56,11 @@ tape( 'the function returns the prototype of a provided value', function test( t
 
 	values = [
 		'beep',
-		new String( 'boop' ), // eslint-disable-line no-new-wrappers
+		new String( 'boop' ),
 		5,
-		new Number( 3.14 ), // eslint-disable-line no-new-wrappers
+		new Number( 3.14 ),
 		true,
-		new Boolean( false ), // eslint-disable-line no-new-wrappers
+		new Boolean( false ),
 		[],
 		{},
 		function foo() {},
@@ -86,13 +86,13 @@ tape( 'the function returns the prototype of a provided value', function test( t
 
 	for ( i = 0; i < values.length; i++ ) {
 		actual = getPrototypeOf( values[i] );
-		t.equal( actual, expected[i], 'returns expected prototype when provided '+values[i] );
+		t.strictEqual( actual, expected[i], 'returns expected prototype when provided '+values[i] );
 	}
 	t.end();
 });
 
 tape( 'the function returns `null` if provided an object created via `Object.create( null )`', function test( t ) {
 	var proto = getPrototypeOf( Object.create( null ) );
-	t.equal( proto, null, 'returns null' );
+	t.strictEqual( proto, null, 'returns null' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.native.js b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.native.js
index 51adf66a8361..5f1af3cc6448 100644
--- a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.native.js
+++ b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.native.js
@@ -43,9 +43,9 @@ tape( 'the function returns the prototype of a provided value', function test( t
 	var i;
 
 	values = [
-		new String( 'boop' ), // eslint-disable-line no-new-wrappers
-		new Number( 3.14 ), // eslint-disable-line no-new-wrappers
-		new Boolean( false ), // eslint-disable-line no-new-wrappers
+		new String( 'boop' ),
+		new Number( 3.14 ),
+		new Boolean( false ),
 		[],
 		{},
 		function foo() {},
@@ -68,13 +68,13 @@ tape( 'the function returns the prototype of a provided value', function test( t
 
 	for ( i = 0; i < values.length; i++ ) {
 		actual = getPrototypeOf( values[i] );
-		t.equal( actual, expected[i], 'returns expected prototype when provided '+values[i] );
+		t.strictEqual( actual, expected[i], 'returns expected prototype when provided '+values[i] );
 	}
 	t.end();
 });
 
 tape( 'the function returns `null` if provided an object created via `Object.create( null )`', function test( t ) {
 	var proto = getPrototypeOf( Object.create( null ) );
-	t.equal( proto, null, 'returns null' );
+	t.strictEqual( proto, null, 'returns null' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.polyfill.js b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.polyfill.js
index dd64b62af2cb..5ee4447745c9 100644
--- a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.polyfill.js
@@ -44,9 +44,9 @@ tape( 'the function returns the prototype of a provided value', function test( t
 	var i;
 
 	values = [
-		new String( 'boop' ), // eslint-disable-line no-new-wrappers
-		new Number( 3.14 ), // eslint-disable-line no-new-wrappers
-		new Boolean( false ), // eslint-disable-line no-new-wrappers
+		new String( 'boop' ),
+		new Number( 3.14 ),
+		new Boolean( false ),
 		[],
 		{},
 		function foo() {},
@@ -69,14 +69,14 @@ tape( 'the function returns the prototype of a provided value', function test( t
 
 	for ( i = 0; i < values.length; i++ ) {
 		actual = getPrototypeOf( values[i] );
-		t.equal( actual, expected[i], 'returns expected prototype when provided '+values[i] );
+		t.strictEqual( actual, expected[i], 'returns expected prototype when provided '+values[i] );
 	}
 	t.end();
 });
 
 tape( 'the function returns `null` if provided an object created via `Object.create( null )`', function test( t ) {
 	var proto = getPrototypeOf( Object.create( null ) );
-	t.equal( proto, null, 'returns null' );
+	t.strictEqual( proto, null, 'returns null' );
 	t.end();
 });
 
@@ -92,7 +92,7 @@ tape( 'if available, the function returns the value of the (deprecated) `__proto
 	__proto = 'beep';
 	proto = getPrototypeOf( {} );
 
-	t.equal( proto, 'beep', 'returns `__proto__` value' );
+	t.strictEqual( proto, 'beep', 'returns `__proto__` value' );
 
 	t.end();
 
@@ -117,7 +117,7 @@ tape( 'if no `__proto__` property is present, the function returns the prototype
 	};
 	proto = getPrototypeOf( obj );
 
-	t.equal( proto, 'beep', 'returns constructor prototype' );
+	t.strictEqual( proto, 'beep', 'returns constructor prototype' );
 	t.end();
 
 	function getProto() {}
@@ -136,7 +136,7 @@ tape( 'if no `__proto__` property or a constructor and the value inherits from `
 	};
 	proto = getPrototypeOf( obj );
 
-	t.equal( proto, Object.prototype, 'returns `Object.prototype`' );
+	t.strictEqual( proto, Object.prototype, 'returns `Object.prototype`' );
 	t.end();
 
 	function getProto() {}
@@ -152,7 +152,7 @@ tape( 'the function returns `null` for bizarre values', function test( t ) {
 
 	proto = getPrototypeOf( '' );
 
-	t.equal( proto, null, 'returns `null`' );
+	t.strictEqual( proto, null, 'returns `null`' );
 	t.end();
 
 	function nativeClass() {
diff --git a/lib/node_modules/@stdlib/utils/identity-function/test/test.js b/lib/node_modules/@stdlib/utils/identity-function/test/test.js
index a70e6e8c3b87..3b35a9f2d281 100644
--- a/lib/node_modules/@stdlib/utils/identity-function/test/test.js
+++ b/lib/node_modules/@stdlib/utils/identity-function/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function takes a single argument', function test( t ) {
-	t.equal( identity.length, 1, 'number of parameters is equal to one' );
+	t.strictEqual( identity.length, 1, 'number of parameters is equal to one' );
 	t.end();
 });
 
@@ -53,7 +53,7 @@ tape( 'the function returns the input value', function test( t ) {
 		function noop() {}
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( identity( values[i] ), values[i], 'returns the input value' );
+		t.strictEqual( identity( values[i] ), values[i], 'returns the input value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/index-of/test/test.js b/lib/node_modules/@stdlib/utils/index-of/test/test.js
index 5c39f8cc2a39..1eb9833cd3f4 100644
--- a/lib/node_modules/@stdlib/utils/index-of/test/test.js
+++ b/lib/node_modules/@stdlib/utils/index-of/test/test.js
@@ -88,31 +88,31 @@ tape( 'if provided a `fromIndex`, which is not an integer, the function throws a
 
 tape( 'if provided an array-like object having length `0`, the function always returns `-1`', function test( t ) {
 	var idx = indexOf( [], 5 );
-	t.equal( idx, -1, 'returns -1' );
+	t.strictEqual( idx, -1, 'returns -1' );
 	t.end();
 });
 
 tape( 'if provided a `fromIndex` which exceeds the input array length, the function always returns `-1`', function test( t ) {
 	var idx = indexOf( [ 1, 2, 3 ], 2, 999999999999 );
-	t.equal( idx, -1, 'returns -1' );
+	t.strictEqual( idx, -1, 'returns -1' );
 	t.end();
 });
 
 tape( 'the function returns the first index at which a given element can be found', function test( t ) {
 	var idx = indexOf( [ 1, 1, 1, 2, 2, 3, 3 ], 2 );
-	t.equal( idx, 3, 'returns first occurrence index' );
+	t.strictEqual( idx, 3, 'returns first occurrence index' );
 	t.end();
 });
 
 tape( 'the function supports finding `NaN` elements', function test( t ) {
 	var idx = indexOf( [ 1, 1, 1, 2, NaN, 2, 3, NaN, 3 ], NaN );
-	t.equal( idx, 4, 'returns first occurrence index' );
+	t.strictEqual( idx, 4, 'returns first occurrence index' );
 	t.end();
 });
 
 tape( 'if a search element is not present, the function returns `-1`', function test( t ) {
 	var idx = indexOf( [ 1, 2, 3 ], 4 );
-	t.equal( idx, -1, 'returns -1' );
+	t.strictEqual( idx, -1, 'returns -1' );
 	t.end();
 });
 
@@ -123,19 +123,19 @@ tape( 'the function supports specifying a `fromIndex`', function test( t ) {
 	arr = [ 1, 1, 2, 1, 2, 2, 3, 2, 3 ];
 
 	idx = indexOf( arr, 2 );
-	t.equal( idx, 2, 'returns first occurrence index' );
+	t.strictEqual( idx, 2, 'returns first occurrence index' );
 
 	idx = indexOf( arr, 2, idx+1 );
-	t.equal( idx, 4, 'returns second occurrence index' );
+	t.strictEqual( idx, 4, 'returns second occurrence index' );
 
 	idx = indexOf( arr, 2, idx+1 );
-	t.equal( idx, 5, 'returns third occurrence index' );
+	t.strictEqual( idx, 5, 'returns third occurrence index' );
 
 	idx = indexOf( arr, 2, idx+1 );
-	t.equal( idx, 7, 'returns fourth occurrence index' );
+	t.strictEqual( idx, 7, 'returns fourth occurrence index' );
 
 	idx = indexOf( arr, 2, idx+1 );
-	t.equal( idx, -1, 'returns -1' );
+	t.strictEqual( idx, -1, 'returns -1' );
 
 	t.end();
 });
@@ -147,19 +147,19 @@ tape( 'if provided a `fromIndex` which is less than `0`, the function determines
 	arr = [ 1, 1, 2, 1, 2, 2, 3, 2, 3 ];
 
 	idx = indexOf( arr, 3, -1 );
-	t.equal( idx, 8, 'returns last element index' );
+	t.strictEqual( idx, 8, 'returns last element index' );
 
 	idx = indexOf( arr, 2, -1 );
-	t.equal( idx, -1, 'returns -1' );
+	t.strictEqual( idx, -1, 'returns -1' );
 
 	idx = indexOf( arr, 2, -2 );
-	t.equal( idx, 7, 'returns second to last element index' );
+	t.strictEqual( idx, 7, 'returns second to last element index' );
 
 	idx = indexOf( arr, 2, -3 );
-	t.equal( idx, 7, 'returns second to last element index' );
+	t.strictEqual( idx, 7, 'returns second to last element index' );
 
 	idx = indexOf( arr, 2, -4 );
-	t.equal( idx, 5, 'returns 5' );
+	t.strictEqual( idx, 5, 'returns 5' );
 
 	t.end();
 });
@@ -171,10 +171,10 @@ tape( 'if provided a `fromIndex` which is less than `0` and whose absolute value
 	arr = [ 1, 1, 2, 1, 2, 2, 3, 2, 3 ];
 
 	idx = indexOf( arr, 2, -99999999999999 );
-	t.equal( idx, 2, 'returns first occurrence index' );
+	t.strictEqual( idx, 2, 'returns first occurrence index' );
 
 	idx = indexOf( arr, 1, -99999999999999 );
-	t.equal( idx, 0, 'returns first occurrence index' );
+	t.strictEqual( idx, 0, 'returns first occurrence index' );
 
 	t.end();
 });
@@ -186,7 +186,7 @@ tape( 'the function supports searching `strings`', function test( t ) {
 	str = 'bebop';
 	idx = indexOf( str, 'o' );
 
-	t.equal( idx, 3, 'returns first occurrence index' );
+	t.strictEqual( idx, 3, 'returns first occurrence index' );
 	t.end();
 });
 
@@ -204,7 +204,7 @@ tape( 'the function supports array-like `objects`', function test( t ) {
 
 	idx = indexOf( obj, 'bap' );
 
-	t.equal( idx, 2, 'returns first occurrence index' );
+	t.strictEqual( idx, 2, 'returns first occurrence index' );
 	t.end();
 });
 
@@ -225,12 +225,12 @@ tape( 'the function does not guarantee that only "own" properties are searched',
 	foo = new Foo();
 
 	idx = indexOf( foo, 'bap' );
-	t.equal( idx, -1, 'returns -1' );
+	t.strictEqual( idx, -1, 'returns -1' );
 
 	delete foo[ 2 ];
 
 	idx = indexOf( foo, 'bap' );
-	t.equal( idx, 2, 'returns property on prototype' );
+	t.strictEqual( idx, 2, 'returns property on prototype' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/keys/test/test.is_constructor_prototype.js b/lib/node_modules/@stdlib/utils/keys/test/test.is_constructor_prototype.js
index c0674828c8f7..70aa15c40d3b 100644
--- a/lib/node_modules/@stdlib/utils/keys/test/test.is_constructor_prototype.js
+++ b/lib/node_modules/@stdlib/utils/keys/test/test.is_constructor_prototype.js
@@ -49,7 +49,7 @@ tape( 'the function returns `true` if a value equals the prototype of its constr
 	t.end();
 });
 
-tape( 'the function returns `false` if value does not equal the prototype of its constructor', function test( t ) {
+tape( 'the function returns `false` if value does not.strictEqual the prototype of its constructor', function test( t ) {
 	var bool;
 	var obj;
 
diff --git a/lib/node_modules/@stdlib/utils/keys/test/test.is_constructor_prototype_wrapper.js b/lib/node_modules/@stdlib/utils/keys/test/test.is_constructor_prototype_wrapper.js
index 47e669fa6dfd..fcc960e538f1 100644
--- a/lib/node_modules/@stdlib/utils/keys/test/test.is_constructor_prototype_wrapper.js
+++ b/lib/node_modules/@stdlib/utils/keys/test/test.is_constructor_prototype_wrapper.js
@@ -58,7 +58,7 @@ tape( 'the function returns `true` if a value equals the prototype of its constr
 	t.end();
 });
 
-tape( 'the function returns `false` if a value does not equal the prototype of its constructor (non-buggy non-browser environments)', function test( t ) {
+tape( 'the function returns `false` if a value does not.strictEqual the prototype of its constructor (non-buggy non-browser environments)', function test( t ) {
 	var wrapper;
 	var bool;
 	var obj;
@@ -105,7 +105,7 @@ tape( 'the function returns `true` if a value equals the prototype of its constr
 	t.end();
 });
 
-tape( 'the function returns `false` if a value does not equal the prototype of its constructor (buggy non-browser environments)', function test( t ) {
+tape( 'the function returns `false` if a value does not.strictEqual the prototype of its constructor (buggy non-browser environments)', function test( t ) {
 	var wrapper;
 	var bool;
 	var obj;
@@ -151,7 +151,7 @@ tape( 'the function returns `true` if a value equals the prototype of its constr
 	t.end();
 });
 
-tape( 'the function returns `false` if a value does not equal the prototype of its constructor (non-buggy browser environments)', function test( t ) {
+tape( 'the function returns `false` if a value does not.strictEqual the prototype of its constructor (non-buggy browser environments)', function test( t ) {
 	var wrapper;
 	var bool;
 	var obj;
@@ -202,7 +202,7 @@ tape( 'the function returns `true` if a value equals the prototype of its constr
 	}
 });
 
-tape( 'the function returns `false` if a value does not equal the prototype of its constructor (buggy browser environments)', function test( t ) {
+tape( 'the function returns `false` if a value does not.strictEqual the prototype of its constructor (buggy browser environments)', function test( t ) {
 	var wrapper;
 	var bool;
 	var obj;
diff --git a/lib/node_modules/@stdlib/utils/merge/test/test.defaults.js b/lib/node_modules/@stdlib/utils/merge/test/test.defaults.js
index e477d20d3f6a..7106da6c0393 100644
--- a/lib/node_modules/@stdlib/utils/merge/test/test.defaults.js
+++ b/lib/node_modules/@stdlib/utils/merge/test/test.defaults.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof defaults(), 'object', 'returns an object' );
+	t.strictEqual( typeof defaults(), 'object', 'returns an object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/merge/test/test.factory.js b/lib/node_modules/@stdlib/utils/merge/test/test.factory.js
index 5c359f2bff7c..19dab898995d 100644
--- a/lib/node_modules/@stdlib/utils/merge/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/merge/test/test.factory.js
@@ -109,7 +109,7 @@ tape( 'the function returns a merge function', function test( t ) {
 	opts = setup();
 	merge = factory( opts );
 
-	t.equal( typeof merge, 'function', 'returns a function' );
+	t.strictEqual( typeof merge, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -225,7 +225,7 @@ tape( 'the returned function returns the target object', function test( t ) {
 
 	actual = merge( target, src );
 
-	t.equal( actual, target, 'returns target object' );
+	t.strictEqual( actual, target, 'returns target object' );
 	t.end();
 });
 
@@ -367,7 +367,7 @@ tape( 'if `copy` is `false`, the returned function will not deep copy', function
 	};
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( actual.a, src.a, 'same reference' );
+	t.strictEqual( actual.a, src.a, 'same reference' );
 
 	// Deep merge...
 	target = {
@@ -405,7 +405,7 @@ tape( 'if `copy` is `false`, the returned function will not deep copy', function
 	};
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( actual.one.two, src.one.two, 'same reference' );
+	t.strictEqual( actual.one.two, src.one.two, 'same reference' );
 
 	t.end();
 });
@@ -520,7 +520,7 @@ tape( 'the returned function supports a custom merge strategy (override)', funct
 	};
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.notEqual( actual.c, src.c, 'not equal (simple case)' );
+	t.notEqual( actual.c, src.c, 'not.strictEqual (simple case)' );
 
 	// No deep copies if provided existing value...
 	target = {
@@ -556,7 +556,7 @@ tape( 'the returned function supports a custom merge strategy (override)', funct
 	};
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( actual.e, target.e, 'existing value' );
+	t.strictEqual( actual.e, target.e, 'existing value' );
 
 	// No deep copies if copy is `false` and provided a new value...
 	target = {
@@ -588,7 +588,7 @@ tape( 'the returned function supports a custom merge strategy (override)', funct
 	};
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( actual.c, src.c, 'no deep copies of new values' );
+	t.strictEqual( actual.c, src.c, 'no deep copies of new values' );
 
 	t.end();
 });
@@ -620,7 +620,7 @@ tape( 'if `extend` and `override` options are both `false`, the returned functio
 	expected = target;
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( actual, target, 'returns target object' );
+	t.strictEqual( actual, target, 'returns target object' );
 	t.end();
 });
 
@@ -645,9 +645,9 @@ tape( 'the returned function supports merging built-in objects and class instanc
 		'time': new Date(),
 		'regex': /beep/,
 		'buffer': string2buffer( 'beep' ),
-		'Boolean': new Boolean( true ), // eslint-disable-line no-new-wrappers
-		'String': new String( 'woot' ), // eslint-disable-line no-new-wrappers
-		'Number': new Number( 5 ), // eslint-disable-line no-new-wrappers
+		'Boolean': new Boolean( true ),
+		'String': new String( 'woot' ),
+		'Number': new Number( 5 ),
 		'Uint8Array': new Uint8Array( 10 ),
 		'Foo': new Foo( 'beep' )
 	};
@@ -656,9 +656,9 @@ tape( 'the returned function supports merging built-in objects and class instanc
 		'time': new Date( target.time - 60000 ),
 		'regex': /boop/,
 		'buffer': string2buffer( 'boop' ),
-		'Boolean': new Boolean( false ), // eslint-disable-line no-new-wrappers
-		'String': new String( 'bop' ), // eslint-disable-line no-new-wrappers
-		'Number': new Number( 10 ), // eslint-disable-line no-new-wrappers
+		'Boolean': new Boolean( false ),
+		'String': new String( 'bop' ),
+		'Number': new Number( 10 ),
 		'Uint8Array': new Uint8Array( 5 ),
 		'Foo': new Foo( 'boop' )
 	};
@@ -685,7 +685,7 @@ tape( 'the returned function supports merging built-in objects and class instanc
 	len = keys.length;
 	for ( i = 0; i < len; i++ ) {
 		key = keys[ i ];
-		t.equal( actual[ key ], src[ key ], key );
+		t.strictEqual( actual[ key ], src[ key ], key );
 	}
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/merge/test/test.js b/lib/node_modules/@stdlib/utils/merge/test/test.js
index dc32da467bfb..2578c1018e48 100644
--- a/lib/node_modules/@stdlib/utils/merge/test/test.js
+++ b/lib/node_modules/@stdlib/utils/merge/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory function for generating custom merge functions', function test( t ) {
-	t.equal( typeof merge.factory, 'function', 'has `factory` method' );
+	t.strictEqual( typeof merge.factory, 'function', 'has `factory` method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/merge/test/test.main.js b/lib/node_modules/@stdlib/utils/merge/test/test.main.js
index 1cf42b6b9b11..2f0270ba58c1 100644
--- a/lib/node_modules/@stdlib/utils/merge/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/merge/test/test.main.js
@@ -136,7 +136,7 @@ tape( 'the function returns the target object', function test( t ) {
 
 	actual = merge( target, src );
 
-	t.equal( actual, target, 'returns target object' );
+	t.strictEqual( actual, target, 'returns target object' );
 	t.end();
 });
 
@@ -215,9 +215,9 @@ tape( 'the function supports merging built-in objects and class instances', func
 		'time': new Date(),
 		'regex': /beep/,
 		'buffer': string2buffer( 'beep' ),
-		'Boolean': new Boolean( true ), // eslint-disable-line no-new-wrappers
-		'String': new String( 'woot' ), // eslint-disable-line no-new-wrappers
-		'Number': new Number( 5 ), // eslint-disable-line no-new-wrappers
+		'Boolean': new Boolean( true ),
+		'String': new String( 'woot' ),
+		'Number': new Number( 5 ),
 		'Uint8Array': new Uint8Array( 10 ),
 		'Foo': new Foo( 'beep' )
 	};
@@ -226,9 +226,9 @@ tape( 'the function supports merging built-in objects and class instances', func
 		'time': new Date( target.time - 60000 ),
 		'regex': /boop/,
 		'buffer': string2buffer( 'boop' ),
-		'Boolean': new Boolean( false ), // eslint-disable-line no-new-wrappers
-		'String': new String( 'bop' ), // eslint-disable-line no-new-wrappers
-		'Number': new Number( 10 ), // eslint-disable-line no-new-wrappers
+		'Boolean': new Boolean( false ),
+		'String': new String( 'bop' ),
+		'Number': new Number( 10 ),
 		'Uint8Array': new Uint8Array( 5 ),
 		'Foo': new Foo( 'boop' )
 	};
diff --git a/lib/node_modules/@stdlib/utils/merge/test/test.validate.js b/lib/node_modules/@stdlib/utils/merge/test/test.validate.js
index 430ae884fc4d..0915ddc17c49 100644
--- a/lib/node_modules/@stdlib/utils/merge/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/merge/test/test.validate.js
@@ -93,7 +93,7 @@ tape( 'if provided a `copy` option which is not a boolean primitive, the functio
 		null,
 		NaN,
 		void 0,
-		new Boolean( true ), // eslint-disable-line no-new-wrappers
+		new Boolean( true ),
 		[],
 		{},
 		function noop() {}
@@ -118,7 +118,7 @@ tape( 'if provided an `extend` option which is not a boolean primitive, the func
 		null,
 		NaN,
 		void 0,
-		new Boolean( true ), // eslint-disable-line no-new-wrappers
+		new Boolean( true ),
 		[],
 		{},
 		function noop() {}
@@ -143,7 +143,7 @@ tape( 'if provided an `override` option which is not a boolean primitive or a fu
 		null,
 		NaN,
 		void 0,
-		new Boolean( true ), // eslint-disable-line no-new-wrappers
+		new Boolean( true ),
 		[],
 		{}
 	];
@@ -170,11 +170,11 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.level, 2, 'sets level option' );
-	t.equal( obj.copy, false, 'sets copy option' );
-	t.equal( obj.extend, false, 'sets extend option' );
-	t.equal( obj.override, false, 'sets override option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.level, 2, 'sets level option' );
+	t.strictEqual( obj.copy, false, 'sets copy option' );
+	t.strictEqual( obj.extend, false, 'sets extend option' );
+	t.strictEqual( obj.override, false, 'sets override option' );
 
 	t.end();
 });
@@ -192,7 +192,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/move-property/test/test.js b/lib/node_modules/@stdlib/utils/move-property/test/test.js
index aff4228ecdbb..4d17226be47d 100644
--- a/lib/node_modules/@stdlib/utils/move-property/test/test.js
+++ b/lib/node_modules/@stdlib/utils/move-property/test/test.js
@@ -92,7 +92,7 @@ tape( 'if unable to move a property, the function returns `false`', function tes
 });
 
 tape( 'if moving a property is successful, the function returns `true`', function test( t ) {
-	var bool = moveProperty( { 'a': 'b' }, 'a', {} );
+	var bool = moveProperty({ 'a': 'b' }, 'a', {} );
 	t.ok( bool, 'successfully moved property' );
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'the function preserves property\'s descriptors', function test( t ) {
 
 	t.ok( bool, 'successfully moved property' );
 	t.deepEqual( obj1, {}, 'deep equal' );
-	t.equal( obj2.a, 'b' );
+	t.strictEqual( obj2.a, 'b' );
 	t.deepEqual( Object.getOwnPropertyDescriptor( obj2, 'a' ), desc, 'descriptors are equal' );
 
 	t.end();
@@ -178,7 +178,7 @@ tape( 'the function does not deep copy moved properties', function test( t ) {
 	t.ok( bool, 'successfully moved property' );
 	t.deepEqual( obj2, { 'a': arr }, 'deep equal' );
 	t.deepEqual( obj1, {}, 'deep equal' );
-	t.equal( obj2.a, arr, 'same reference' );
+	t.strictEqual( obj2.a, arr, 'same reference' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/noop/test/test.js b/lib/node_modules/@stdlib/utils/noop/test/test.js
index 0ba63104c948..3aa20ca78602 100644
--- a/lib/node_modules/@stdlib/utils/noop/test/test.js
+++ b/lib/node_modules/@stdlib/utils/noop/test/test.js
@@ -33,17 +33,17 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function does not take any arguments', function test( t ) {
-	t.equal( noop.length, 0, 'number of parameters is equal to zero' );
+	t.strictEqual( noop.length, 0, 'number of parameters is equal to zero' );
 	t.end();
 });
 
 tape( 'the function returns `undefined`', function test( t ) {
-	t.equal( noop(), void 0, 'returns undefined' );
+	t.strictEqual( noop(), void 0, 'returns undefined' );
 	t.end();
 });
 
 tape( 'the function should be empty', function test( t ) {
 	// NOTE: this will fail if code is instrumented for test coverage.
-	// t.equal( noop.toString(), 'function noop(){}', 'is empty' );
+	// t.strictEqual( noop.toString(), 'function noop(){}', 'is empty' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/open-url/test/test.browser.js b/lib/node_modules/@stdlib/utils/open-url/test/test.browser.js
index f2088318b7d4..c4803a1853fc 100644
--- a/lib/node_modules/@stdlib/utils/open-url/test/test.browser.js
+++ b/lib/node_modules/@stdlib/utils/open-url/test/test.browser.js
@@ -82,7 +82,7 @@ tape( 'the function defers to the `window.open` method', function test( t ) {
 	global.window = win;
 
 	function mock( val ) {
-		t.equal( val, url, 'forwards the URL argument' );
+		t.strictEqual( val, url, 'forwards the URL argument' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/utils/open-url/test/test.js b/lib/node_modules/@stdlib/utils/open-url/test/test.js
index bd670fb1d15a..6331a7810fba 100644
--- a/lib/node_modules/@stdlib/utils/open-url/test/test.js
+++ b/lib/node_modules/@stdlib/utils/open-url/test/test.js
@@ -89,8 +89,8 @@ tape( 'if the platform is `Darwin`, the function invokes the `open` command', op
 	t.end();
 
 	function spawn( cmd, args ) {
-		t.equal( cmd, 'open', 'calls `spawn` with `open` command' );
-		t.equal( args[0], url, 'equal URL' );
+		t.strictEqual( cmd, 'open', 'calls `spawn` with `open` command' );
+		t.strictEqual( args[0], url, 'equal URL' );
 		return proc();
 	}
 	function proc() {
@@ -118,11 +118,11 @@ tape( 'if the platform is `Windows`, the function invokes the `cmd` command', op
 	t.end();
 
 	function spawn( cmd, args ) {
-		t.equal( cmd, 'cmd', 'calls `spawn` with `open` command' );
-		t.equal( args[0], '/c', 'first arg is `/c`' );
-		t.equal( args[1], 'start', 'second arg is `start`' );
-		t.equal( args[2], '""', 'empty title' );
-		t.equal( args[3], 'https://google.com?q=beep^&b=boop', 'escaped ampersands' );
+		t.strictEqual( cmd, 'cmd', 'calls `spawn` with `open` command' );
+		t.strictEqual( args[0], '/c', 'first arg is `/c`' );
+		t.strictEqual( args[1], 'start', 'second arg is `start`' );
+		t.strictEqual( args[2], '""', 'empty title' );
+		t.strictEqual( args[3], 'https://google.com?q=beep^&b=boop', 'escaped ampersands' );
 		return proc();
 	}
 	function proc() {
@@ -150,8 +150,8 @@ tape( 'if the platform is neither `Darwin` or `Windows`, the function invokes th
 	t.end();
 
 	function spawn( cmd, args ) {
-		t.equal( cmd, 'xdg-open', 'calls `spawn` with `xdg-open` command' );
-		t.equal( args[0], url, 'equal URL' );
+		t.strictEqual( cmd, 'xdg-open', 'calls `spawn` with `xdg-open` command' );
+		t.strictEqual( args[0], url, 'equal URL' );
 		return proc();
 	}
 	function proc() {
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.main.js b/lib/node_modules/@stdlib/utils/parallel/test/test.main.js
index c828e90dbe7c..97581bcab884 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.main.js
@@ -24,6 +24,7 @@ var path = require( 'path' );
 var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
 var noop = require( '@stdlib/utils/noop' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var parallel = require( './../lib/main.js' );
 
 
@@ -33,7 +34,7 @@ function files() {
 	var out;
 	var i;
 
-	out = new Array( 4 );
+	out = zeros( 4 );
 	for ( i = 0; i < out.length; i++ ) {
 		out[ i ] = path.resolve( __dirname, './fixtures/'+(i+1)+'.js' );
 	}
@@ -277,7 +278,7 @@ tape( 'if the concurrency is greater than the number of files, the function sets
 	parallel( f, opts, noop );
 
 	function exec( files, opts ) {
-		t.equal( opts.concurrency, f.length, 'lowers the concurrency' );
+		t.strictEqual( opts.concurrency, f.length, 'lowers the concurrency' );
 		t.end();
 	}
 });
@@ -299,7 +300,7 @@ tape( 'if the number of workers is greater than the concurrency, the function se
 	parallel( f, opts, noop );
 
 	function exec( files, opts ) {
-		t.equal( opts.workers, 2, 'lowers the workers' );
+		t.strictEqual( opts.workers, 2, 'lowers the workers' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.node.env.js b/lib/node_modules/@stdlib/utils/parallel/test/test.node.env.js
index 7631f624d2ca..17b30421ede3 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.node.env.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.node.env.js
@@ -47,25 +47,25 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof env( getOpts() ), 'object', 'returns an object' );
+	t.strictEqual( typeof env( getOpts() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function sets a `WORKER_CMD` environment variable', function test( t ) {
 	var out = env( getOpts() );
-	t.equal( out.WORKER_CMD, 'node', 'sets env var' );
+	t.strictEqual( out.WORKER_CMD, 'node', 'sets env var' );
 	t.end();
 });
 
 tape( 'the function sets a `WORKER_ENCODING` environment variable', function test( t ) {
 	var out = env( getOpts() );
-	t.equal( out.WORKER_ENCODING, 'buffer', 'sets env var' );
+	t.strictEqual( out.WORKER_ENCODING, 'buffer', 'sets env var' );
 	t.end();
 });
 
 tape( 'the function sets a `WORKER_MAX_BUFFER` environment variable', function test( t ) {
 	var out = env( getOpts() );
-	t.equal( out.WORKER_MAX_BUFFER, 1024, 'sets env var' );
+	t.strictEqual( out.WORKER_MAX_BUFFER, 1024, 'sets env var' );
 	t.end();
 });
 
@@ -77,7 +77,7 @@ tape( 'if `ordered` is `true`, the function sets a `WORKER_ORDERED` environment
 	opts.ordered = true;
 
 	out = env( opts );
-	t.equal( out.WORKER_ORDERED, '1', 'sets env var' );
+	t.strictEqual( out.WORKER_ORDERED, '1', 'sets env var' );
 
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'if `uid` is truthy, the function sets a `WORKER_UID` environment variable
 	opts.uid = 1234;
 
 	out = env( opts );
-	t.equal( out.WORKER_UID, 1234, 'sets env var' );
+	t.strictEqual( out.WORKER_UID, 1234, 'sets env var' );
 
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'if `gid` is truthy, the function sets a `WORKER_GID` environment variable
 	opts.gid = 12345;
 
 	out = env( opts );
-	t.equal( out.WORKER_GID, 12345, 'sets env var' );
+	t.strictEqual( out.WORKER_GID, 12345, 'sets env var' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.node.exec.js b/lib/node_modules/@stdlib/utils/parallel/test/test.node.exec.js
index e4e26d3a7be6..d44011380f4e 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.node.exec.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.node.exec.js
@@ -28,6 +28,7 @@ var objectKeys = require( '@stdlib/utils/keys' );
 var noop = require( '@stdlib/utils/noop' );
 var nextTick = require( '@stdlib/utils/next-tick' );
 var rand = require( '@stdlib/random/base/minstd' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var exec = require( './../lib/node/exec.js' );
 
 
@@ -68,7 +69,7 @@ Fork.prototype.send = noop;
 function files() {
 	var out;
 	var i;
-	out = new Array( 4 );
+	out = zeros( 4 );
 	for ( i = 0; i < out.length; i++ ) {
 		out[ i ] = path.resolve( __dirname, './fixtures/'+(i+1)+'.js' );
 	}
@@ -131,7 +132,7 @@ tape( 'the function assigns scripts to workers', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		} else {
-			t.equal( count, f.length, 'runs all scripts' );
+			t.strictEqual( count, f.length, 'runs all scripts' );
 		}
 		t.end();
 	}
@@ -186,7 +187,7 @@ tape( 'the function returns the first encountered error to a provided callback',
 
 	function done( error ) {
 		t.ok( error, 'returns an error' );
-		t.equal( error.message, 'error: 3', 'expected error message' );
+		t.strictEqual( error.message, 'error: 3', 'expected error message' );
 		t.end();
 	}
 });
@@ -226,8 +227,8 @@ tape( 'the function returns an error to a provided callback if a worker exits wi
 
 	function done( error ) {
 		t.ok( error, 'returns an error' );
-		t.equal( error.code, 1, 'sets exit code' );
-		t.equal( error.signal, null, 'sets signal' );
+		t.strictEqual( error.code, 1, 'sets exit code' );
+		t.strictEqual( error.signal, null, 'sets signal' );
 		t.end();
 	}
 });
@@ -267,8 +268,8 @@ tape( 'the function returns an error to a provided callback if a worker exits du
 
 	function done( error ) {
 		t.ok( error, 'returns an error' );
-		t.equal( error.code, null, 'sets exit code' );
-		t.equal( error.signal, 'SIGINT', 'sets signal' );
+		t.strictEqual( error.code, null, 'sets exit code' );
+		t.strictEqual( error.signal, 'SIGINT', 'sets signal' );
 		t.end();
 	}
 });
@@ -308,8 +309,8 @@ tape( 'the function returns an error to a provided callback if a worker closes w
 
 	function done( error ) {
 		t.ok( error, 'returns an error' );
-		t.equal( error.code, 1, 'sets exit code' );
-		t.equal( error.signal, null, 'sets signal' );
+		t.strictEqual( error.code, 1, 'sets exit code' );
+		t.strictEqual( error.signal, null, 'sets signal' );
 		t.end();
 	}
 });
@@ -349,8 +350,8 @@ tape( 'the function returns an error to a provided callback if a worker closes d
 
 	function done( error ) {
 		t.ok( error, 'returns an error' );
-		t.equal( error.code, null, 'sets exit code' );
-		t.equal( error.signal, 'SIGINT', 'sets signal' );
+		t.strictEqual( error.code, null, 'sets exit code' );
+		t.strictEqual( error.signal, 'SIGINT', 'sets signal' );
 		t.end();
 	}
 });
@@ -413,8 +414,8 @@ tape( 'the function does not error when a child process emits either a normal `d
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( count1, opts.workers, 'does not error when `exit` emitted' );
-		t.equal( count2, opts.workers, 'does not error when `disconnect` emitted' );
+		t.strictEqual( count1, opts.workers, 'does not error when `exit` emitted' );
+		t.strictEqual( count2, opts.workers, 'does not error when `disconnect` emitted' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.node.options.js b/lib/node_modules/@stdlib/utils/parallel/test/test.node.options.js
index e63c8e36c3c6..305031cb41ea 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.node.options.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.node.options.js
@@ -47,25 +47,25 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof getOpts( options() ), 'object', 'returns an object' );
+	t.strictEqual( typeof getOpts( options() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function sets a `cwd` property', function test( t ) {
 	var opts = getOpts( options() );
-	t.equal( typeof opts.cwd, 'string', 'sets property' );
+	t.strictEqual( typeof opts.cwd, 'string', 'sets property' );
 	t.end();
 });
 
 tape( 'the function sets an `env` property', function test( t ) {
 	var opts = getOpts( options() );
-	t.equal( typeof opts.env, 'object', 'sets property' );
+	t.strictEqual( typeof opts.env, 'object', 'sets property' );
 	t.end();
 });
 
 tape( 'the function sets a `stdio` property', function test( t ) {
 	var opts = getOpts( options() );
-	t.equal( typeof opts.stdio, 'string', 'sets property' );
+	t.strictEqual( typeof opts.stdio, 'string', 'sets property' );
 	t.end();
 });
 
@@ -77,7 +77,7 @@ tape( 'if the `uid` option is not `null`, the function sets a `uid` property', f
 	o.uid = 1234;
 
 	opts = getOpts( o );
-	t.equal( opts.uid, o.uid, 'sets property' );
+	t.strictEqual( opts.uid, o.uid, 'sets property' );
 
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'if the `gid` option is not `null`, the function sets a `gid` property', f
 	o.gid = 1234;
 
 	opts = getOpts( o );
-	t.equal( opts.gid, o.gid, 'sets property' );
+	t.strictEqual( opts.gid, o.gid, 'sets property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.close.js b/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.close.js
index c1ec3d525737..a790f8effa21 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.close.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.close.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* global global */
-
 'use strict';
 
 // MODULES //
@@ -72,7 +70,7 @@ tape( 'the function kills all child processes', function test( t ) {
 	}
 
 	function disconnect() {
-		t.equal( count, 2, 'kills child processes' );
+		t.strictEqual( count, 2, 'kills child processes' );
 		t.deepEqual( db, {}, 'removes children from database' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.exec.js b/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.exec.js
index 2563ad2d37dd..aea40c8926ec 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.exec.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.exec.js
@@ -50,7 +50,7 @@ tape( 'the function returns a child process', function test( t ) {
 	pid = 12345;
 	child = exec();
 
-	t.equal( child.pid, pid, 'returns child process' );
+	t.strictEqual( child.pid, pid, 'returns child process' );
 	t.end();
 
 	function execFile() {
@@ -98,8 +98,8 @@ tape( 'the function calls a callback when a script finishes executing', function
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( id, pid, 'returns pid' );
-		t.equal( key, script, 'returns script name' );
+		t.strictEqual( id, pid, 'returns pid' );
+		t.strictEqual( key, script, 'returns script name' );
 		t.end();
 	}
 });
@@ -156,7 +156,7 @@ tape( 'if the `WORKER_UID` environment is set, the function sets the child proce
 	t.end();
 
 	function execFile( cmd, args, opts ) {
-		t.equal( opts.uid, 123, 'sets uid' );
+		t.strictEqual( opts.uid, 123, 'sets uid' );
 		return {
 			'pid': 12345
 		};
@@ -184,7 +184,7 @@ tape( 'if the `WORKER_GID` environment is set, the function sets the child proce
 	t.end();
 
 	function execFile( cmd, args, opts ) {
-		t.equal( opts.gid, 1234, 'sets gid' );
+		t.strictEqual( opts.gid, 1234, 'sets gid' );
 		return {
 			'pid': 12345
 		};
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.spawn.js b/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.spawn.js
index f5f352b96e25..5a81bf73bfb6 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.spawn.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.spawn.js
@@ -58,7 +58,7 @@ tape( 'the function returns a child process', function test( t ) {
 
 	child = spawn();
 
-	t.equal( child.pid, 12345, 'returns child process' );
+	t.strictEqual( child.pid, 12345, 'returns child process' );
 	t.end();
 
 	function mock() {
@@ -90,8 +90,8 @@ tape( 'the function calls a callback when a script finishes executing', function
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( pid, 12345, 'returns pid' );
-		t.equal( key, script, 'returns script name' );
+		t.strictEqual( pid, 12345, 'returns pid' );
+		t.strictEqual( key, script, 'returns script name' );
 		t.end();
 	}
 });
@@ -145,8 +145,8 @@ tape( 'the function calls a callback with an error if the process exits with a n
 
 	function done( error ) {
 		t.ok( error, 'returns an error' );
-		t.equal( error.code, 1, 'sets `code` property' );
-		t.equal( error.signal, null, 'sets `signal` property' );
+		t.strictEqual( error.code, 1, 'sets `code` property' );
+		t.strictEqual( error.signal, null, 'sets `signal` property' );
 		t.end();
 	}
 });
@@ -174,8 +174,8 @@ tape( 'the function calls a callback with an error if the process exits due to a
 
 	function done( error ) {
 		t.ok( error, 'returns an error' );
-		t.equal( error.code, null, 'sets `code` property' );
-		t.equal( error.signal, 'SIGINT', 'sets `signal` property' );
+		t.strictEqual( error.code, null, 'sets `code` property' );
+		t.strictEqual( error.signal, 'SIGINT', 'sets `signal` property' );
 		t.end();
 	}
 });
@@ -202,8 +202,8 @@ tape( 'the function calls a callback with an error if the process closes with a
 
 	function done( error ) {
 		t.ok( error, 'returns an error' );
-		t.equal( error.code, 2, 'sets `code` property' );
-		t.equal( error.signal, null, 'sets `signal` property' );
+		t.strictEqual( error.code, 2, 'sets `code` property' );
+		t.strictEqual( error.signal, null, 'sets `signal` property' );
 		t.end();
 	}
 });
@@ -230,8 +230,8 @@ tape( 'the function calls a callback with an error if the process closes due to
 
 	function done( error ) {
 		t.ok( error, 'returns an error' );
-		t.equal( error.code, null, 'sets `code` property' );
-		t.equal( error.signal, 'SIGINT', 'sets `signal` property' );
+		t.strictEqual( error.code, null, 'sets `code` property' );
+		t.strictEqual( error.signal, 'SIGINT', 'sets `signal` property' );
 		t.end();
 	}
 });
@@ -259,8 +259,8 @@ tape( 'the function calls a callback with an error if the process exits/closes w
 
 	function done( error ) {
 		t.ok( error, 'returns an error' );
-		t.equal( error.code, 1, 'sets `code` property' );
-		t.equal( error.signal, null, 'sets `signal` property' );
+		t.strictEqual( error.code, 1, 'sets `code` property' );
+		t.strictEqual( error.signal, null, 'sets `signal` property' );
 		t.end();
 	}
 });
@@ -288,8 +288,8 @@ tape( 'the function calls a callback with an error if the process exits/closes d
 
 	function done( error ) {
 		t.ok( error, 'returns an error' );
-		t.equal( error.code, null, 'sets `code` property' );
-		t.equal( error.signal, 'SIGINT', 'sets `signal` property' );
+		t.strictEqual( error.code, null, 'sets `code` property' );
+		t.strictEqual( error.signal, 'SIGINT', 'sets `signal` property' );
 		t.end();
 	}
 });
@@ -315,7 +315,7 @@ tape( 'if the `WORKER_UID` environment is set, the function sets the child proce
 	t.end();
 
 	function mock( cmd, args, opts ) {
-		t.equal( opts.uid, 123, 'sets uid' );
+		t.strictEqual( opts.uid, 123, 'sets uid' );
 		return new Mock();
 	}
 });
@@ -341,7 +341,7 @@ tape( 'if the `WORKER_GID` environment is set, the function sets the child proce
 	t.end();
 
 	function mock( cmd, args, opts ) {
-		t.equal( opts.gid, 1234, 'sets gid' );
+		t.strictEqual( opts.gid, 1234, 'sets gid' );
 		return new Mock();
 	}
 });
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.worker.js b/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.worker.js
index af039d6cf347..d8d395c31b9d 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.worker.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.worker.js
@@ -237,7 +237,7 @@ tape( 'the process sends a message to the parent process containing the script f
 	}
 
 	function send( val ) {
-		t.equal( val, msg, 'sends file path to parent process' );
+		t.strictEqual( val, msg, 'sends file path to parent process' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.validate.js b/lib/node_modules/@stdlib/utils/parallel/test/test.validate.js
index 16ccf76ff236..acb4e244580f 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -78,7 +78,7 @@ tape( 'the function returns an error if provided a `concurrency` option which is
 		err = validate( {}, {
 			'concurrency': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function returns an error if provided a `workers` option which is not
 		err = validate( {}, {
 			'workers': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function returns an error if provided a `cmd` option which is not a s
 		err = validate( {}, {
 			'cmd': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -156,7 +156,7 @@ tape( 'the function returns an error if provided an `ordered` option which is no
 		err = validate( {}, {
 			'ordered': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns an error if provided a `uid` option which is not a n
 		err = validate( {}, {
 			'uid': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -210,7 +210,7 @@ tape( 'the function returns an error if provided a `gid` option which is not a n
 		err = validate( {}, {
 			'gid': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -237,7 +237,7 @@ tape( 'the function returns an error if provided a `maxBuffer` option which is n
 		err = validate( {}, {
 			'maxBuffer': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -259,7 +259,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -278,7 +278,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/parse-json/test/test.js b/lib/node_modules/@stdlib/utils/parse-json/test/test.js
index 338960e03532..3bc1b711c59a 100644
--- a/lib/node_modules/@stdlib/utils/parse-json/test/test.js
+++ b/lib/node_modules/@stdlib/utils/parse-json/test/test.js
@@ -126,22 +126,22 @@ tape( 'the function returns a JSON value if provided valid JSON', function test(
 
 	expected = null;
 	actual = parseJSON( 'null' );
-	t.equal( actual, expected, 'returns null' );
+	t.strictEqual( actual, expected, 'returns null' );
 
 	expected = true;
 	actual = parseJSON( 'true' );
-	t.equal( actual, expected, 'returns true' );
+	t.strictEqual( actual, expected, 'returns true' );
 
 	expected = 3.14;
 	actual = parseJSON( '3.14' );
-	t.equal( actual, expected, 'returns 3.14' );
+	t.strictEqual( actual, expected, 'returns 3.14' );
 
 	t.end();
 });
 
 tape( 'the function returns an error if provided invalid JSON', function test( t ) {
 	var out = parseJSON( '{"beep":"boop}' );
-	t.equal( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns an error' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/parse-ndjson/test/test.js b/lib/node_modules/@stdlib/utils/parse-ndjson/test/test.js
index 69d26301ba4b..d146e59e2cf1 100644
--- a/lib/node_modules/@stdlib/utils/parse-ndjson/test/test.js
+++ b/lib/node_modules/@stdlib/utils/parse-ndjson/test/test.js
@@ -142,7 +142,7 @@ tape( 'the function returns an array of parsed values if provided valid NDJSON',
 
 tape( 'the function returns an error if provided invalid NDJSON', function test( t ) {
 	var out = parseNDJSON( '{"beep":"boop"' );
-	t.equal( out instanceof SyntaxError, true, 'returns an error' );
+	t.strictEqual( out instanceof SyntaxError, true, 'returns an error' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/pluck/test/test.js b/lib/node_modules/@stdlib/utils/pluck/test/test.js
index a1560415be36..532be110ee41 100644
--- a/lib/node_modules/@stdlib/utils/pluck/test/test.js
+++ b/lib/node_modules/@stdlib/utils/pluck/test/test.js
@@ -29,7 +29,7 @@ var pluck = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pluck, 'function', 'main export is a function' );
+	t.strictEqual( typeof pluck, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -138,7 +138,7 @@ tape( 'the function supports mutating an input array', function test( t ) {
 		'copy': false
 	});
 
-	t.equal( actual, arr, 'returns same array reference' );
+	t.strictEqual( actual, arr, 'returns same array reference' );
 	t.deepEqual( arr, expected, 'input array is mutated' );
 	t.end();
 });
@@ -233,7 +233,7 @@ tape( 'the function does not deep copy plucked values', function test( t ) {
 	actual = pluck( arr, 'a' );
 
 	t.deepEqual( actual, expected, 'deep equal' );
-	t.equal( actual[0], arr[0].a, 'plucked values are not deep copied' );
+	t.strictEqual( actual[0], arr[0].a, 'plucked values are not deep copied' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/pluck/test/test.validate.js b/lib/node_modules/@stdlib/utils/pluck/test/test.validate.js
index 92aa38d0d5b3..523cd3be5dcc 100644
--- a/lib/node_modules/@stdlib/utils/pluck/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/pluck/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -90,8 +90,8 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.copy, opts.copy, 'sets copy option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.copy, opts.copy, 'sets copy option' );
 	t.end();
 });
 
@@ -106,7 +106,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/reduce2d/test/test.js b/lib/node_modules/@stdlib/utils/reduce2d/test/test.js
index 3f4e9712a0dc..b7fede6aed62 100644
--- a/lib/node_modules/@stdlib/utils/reduce2d/test/test.js
+++ b/lib/node_modules/@stdlib/utils/reduce2d/test/test.js
@@ -93,7 +93,7 @@ tape( 'the function throws an error if provided a second argument which is not a
 	}
 });
 
-tape( 'the function throws an error if provided a second argument whose length does not equal the size of the outermost input array dimension', function test( t ) {
+tape( 'the function throws an error if provided a second argument whose length does not.strictEqual the size of the outermost input array dimension', function test( t ) {
 	var values;
 	var i;
 
diff --git a/lib/node_modules/@stdlib/utils/regexp-from-string/test/test.js b/lib/node_modules/@stdlib/utils/regexp-from-string/test/test.js
index ad88c034909a..8c1a0fe1b723 100644
--- a/lib/node_modules/@stdlib/utils/regexp-from-string/test/test.js
+++ b/lib/node_modules/@stdlib/utils/regexp-from-string/test/test.js
@@ -88,7 +88,7 @@ tape( 'the function returns a regular expression', function test( t ) {
 
 	for ( i = 0; i < values.length; i++ ) {
 		actual = reFromString( values[ i ] );
-		t.equal( actual.toString(), expected[ i ].toString(), values[ i ] );
+		t.strictEqual( actual.toString(), expected[ i ].toString(), values[ i ] );
 	}
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function returns `null` if unable to parse an input string as a regul
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( reFromString( values[i] ), null, values[ i ] );
+		t.strictEqual( reFromString( values[i] ), null, values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/some-own-by/test/test.js b/lib/node_modules/@stdlib/utils/some-own-by/test/test.js
index 3c30bc2191b2..fa453fa2e71e 100644
--- a/lib/node_modules/@stdlib/utils/some-own-by/test/test.js
+++ b/lib/node_modules/@stdlib/utils/some-own-by/test/test.js
@@ -98,7 +98,7 @@ tape( 'the function throws an error if not provided a second argument which is a
 
 	function badValue( value ) {
 		return function badValue() {
-			someOwnBy( {
+			someOwnBy({
 				'a': 1,
 				'b': 2,
 				'c': 3
@@ -132,7 +132,7 @@ tape( 'the function throws an error if not provided a predicate function', funct
 
 	function badValue( value ) {
 		return function badValue() {
-			someOwnBy( {
+			someOwnBy({
 				'a': 1,
 				'b': 2,
 				'c': 3
@@ -245,7 +245,7 @@ tape( 'the function returns `false` if provided a regular expression or a date o
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( someOwnBy( values[ i ], 1, threshold ), false, 'returns false when provided ' + values[ i ] );
+		t.strictEqual( someOwnBy( values[ i ], 1, threshold ), false, 'returns false when provided ' + values[ i ] );
 	}
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/utils/test/test.js b/lib/node_modules/@stdlib/utils/test/test.js
index 1eb85e4ff174..e71c8a64c6a3 100644
--- a/lib/node_modules/@stdlib/utils/test/test.js
+++ b/lib/node_modules/@stdlib/utils/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains utilities', function test( t ) {
 	var keys = objectKeys( utils );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/timeit/test/test.validate.js b/lib/node_modules/@stdlib/utils/timeit/test/test.validate.js
index 68bac5ef77a0..af80ac40e915 100644
--- a/lib/node_modules/@stdlib/utils/timeit/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/timeit/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `iterations` option which is
 		err = validate( {}, {
 			'iterations': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -105,7 +105,7 @@ tape( 'the function returns an error if provided a `repeats` option which is not
 		err = validate( {}, {
 			'repeats': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function returns an error if provided a `before` option which is not
 		err = validate( {}, {
 			'before': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided an `after` option which is not
 		err = validate( {}, {
 			'after': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -180,7 +180,7 @@ tape( 'the function returns an error if provided an `asynchronous` option which
 		err = validate( {}, {
 			'asynchronous': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -200,7 +200,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -219,7 +219,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/type-of/test/test.check.js b/lib/node_modules/@stdlib/utils/type-of/test/test.check.js
index e89d8df972ef..a815b72065d4 100644
--- a/lib/node_modules/@stdlib/utils/type-of/test/test.check.js
+++ b/lib/node_modules/@stdlib/utils/type-of/test/test.check.js
@@ -43,7 +43,7 @@ tape( 'the function returns `true` if the built-in `typeof` operator returns `\'
 		'./fixtures/re.js': noop
 	});
 
-	t.equal( check(), true, 'returns true' );
+	t.strictEqual( check(), true, 'returns true' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'the function returns `true` if the built-in `typeof` operator returns `\'
 		'./fixtures/typedarray.js': {}
 	});
 
-	t.equal( check(), true, 'returns true' );
+	t.strictEqual( check(), true, 'returns true' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns `true` if the built-in `typeof` operator returns `\'
 		'./fixtures/nodelist.js': noop
 	});
 
-	t.equal( check(), true, 'returns true' );
+	t.strictEqual( check(), true, 'returns true' );
 	t.end();
 });
 
@@ -72,6 +72,6 @@ tape( 'the function returns `false` if the built-in `typeof` operator behaves ac
 		'./fixtures/nodelist.js': {} // rough proxy, as should return same result
 	});
 
-	t.equal( check(), false, 'returns false' );
+	t.strictEqual( check(), false, 'returns false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/type-of/test/test.js b/lib/node_modules/@stdlib/utils/type-of/test/test.js
index 22eb19bbd3c1..c8e9a352302a 100644
--- a/lib/node_modules/@stdlib/utils/type-of/test/test.js
+++ b/lib/node_modules/@stdlib/utils/type-of/test/test.js
@@ -61,7 +61,7 @@ tape( 'if an environment has non-standard `typeof` behavior, the main export is
 		'./check.js': check
 	});
 
-	t.equal( typeOf.toString(), polyfill.toString(), 'exports polyfill' );
+	t.strictEqual( typeOf.toString(), polyfill.toString(), 'exports polyfill' );
 	t.end();
 
 	function check() {
@@ -74,7 +74,7 @@ tape( 'if an environment has standard `typeof` behavior, the main export is a fu
 		'./check.js': check
 	});
 
-	t.equal( typeOf.toString(), getType.toString(), 'exports main implementation' );
+	t.strictEqual( typeOf.toString(), getType.toString(), 'exports main implementation' );
 	t.end();
 
 	function check() {
@@ -168,7 +168,7 @@ tape( 'the function returns a value\'s type', function test( t ) {
 
 	for ( i = 0; i < values.length; i++ ) {
 		type = typeOf( values[i] );
-		t.equal( type, expected[i], 'returns '+expected[i]+' when provided '+values[i] );
+		t.strictEqual( type, expected[i], 'returns '+expected[i]+' when provided '+values[i] );
 	}
 	t.end();
 });
@@ -177,7 +177,7 @@ tape( 'the function supports Map objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasMapSupport() ) {
 		v = typeOf( new Map() );
-		t.equal( v, 'map', 'returns map' );
+		t.strictEqual( v, 'map', 'returns map' );
 	}
 	t.end();
 });
@@ -186,7 +186,7 @@ tape( 'the function supports WeakMap objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasWeakMapSupport() ) {
 		v = typeOf( new WeakMap() );
-		t.equal( v, 'weakmap', 'returns weakmap' );
+		t.strictEqual( v, 'weakmap', 'returns weakmap' );
 	}
 	t.end();
 });
@@ -195,7 +195,7 @@ tape( 'the function supports Set objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasSetSupport() ) {
 		v = typeOf( new Set() );
-		t.equal( v, 'set', 'returns set' );
+		t.strictEqual( v, 'set', 'returns set' );
 	}
 	t.end();
 });
@@ -204,7 +204,7 @@ tape( 'the function supports WeakSet objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasWeakSetSupport() ) {
 		v = typeOf( new WeakSet() );
-		t.equal( v, 'weakset', 'returns weakset' );
+		t.strictEqual( v, 'weakset', 'returns weakset' );
 	}
 	t.end();
 });
@@ -213,7 +213,7 @@ tape( 'the function supports Symbol objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasSymbolSupport() ) {
 		v = typeOf( Symbol( 'beep' ) );
-		t.equal( v, 'symbol', 'returns symbol' );
+		t.strictEqual( v, 'symbol', 'returns symbol' );
 	}
 	t.end();
 });
@@ -222,14 +222,14 @@ tape( 'the function supports custom objects', function test( t ) {
 	var v;
 	function Person() {}
 	v = typeOf( new Person() );
-	t.equal( v, 'person', 'returns person' );
+	t.strictEqual( v, 'person', 'returns person' );
 	t.end();
 });
 
 tape( 'if a value\'s constructor is an anonymous function, the function returns an empty string', function test( t ) {
 	// eslint-disable-next-line func-names, no-extra-parens, space-before-function-paren
 	var v = typeOf( new ( function() {} )() );
-	t.equal( v, '', 'returns empty string' );
+	t.strictEqual( v, '', 'returns empty string' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/type-of/test/test.main.js b/lib/node_modules/@stdlib/utils/type-of/test/test.main.js
index 5b22825f7068..3e13f0d3299d 100644
--- a/lib/node_modules/@stdlib/utils/type-of/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/type-of/test/test.main.js
@@ -139,7 +139,7 @@ tape( 'the function returns a value\'s type', function test( t ) {
 
 	for ( i = 0; i < values.length; i++ ) {
 		type = typeOf( values[i] );
-		t.equal( type, expected[i], 'returns '+expected[i]+' when provided '+values[i] );
+		t.strictEqual( type, expected[i], 'returns '+expected[i]+' when provided '+values[i] );
 	}
 	t.end();
 });
@@ -148,7 +148,7 @@ tape( 'the function supports Map objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasMapSupport() ) {
 		v = typeOf( new Map() );
-		t.equal( v, 'map', 'returns map' );
+		t.strictEqual( v, 'map', 'returns map' );
 	}
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'the function supports WeakMap objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasWeakMapSupport() ) {
 		v = typeOf( new WeakMap() );
-		t.equal( v, 'weakmap', 'returns weakmap' );
+		t.strictEqual( v, 'weakmap', 'returns weakmap' );
 	}
 	t.end();
 });
@@ -166,7 +166,7 @@ tape( 'the function supports Set objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasSetSupport() ) {
 		v = typeOf( new Set() );
-		t.equal( v, 'set', 'returns set' );
+		t.strictEqual( v, 'set', 'returns set' );
 	}
 	t.end();
 });
@@ -175,7 +175,7 @@ tape( 'the function supports WeakSet objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasWeakSetSupport() ) {
 		v = typeOf( new WeakSet() );
-		t.equal( v, 'weakset', 'returns weakset' );
+		t.strictEqual( v, 'weakset', 'returns weakset' );
 	}
 	t.end();
 });
@@ -184,7 +184,7 @@ tape( 'the function supports Symbol objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasSymbolSupport() ) {
 		v = typeOf( Symbol( 'beep' ) );
-		t.equal( v, 'symbol', 'returns symbol' );
+		t.strictEqual( v, 'symbol', 'returns symbol' );
 	}
 	t.end();
 });
@@ -193,14 +193,14 @@ tape( 'the function supports custom objects', function test( t ) {
 	var v;
 	function Person() {}
 	v = typeOf( new Person() );
-	t.equal( v, 'person', 'returns person' );
+	t.strictEqual( v, 'person', 'returns person' );
 	t.end();
 });
 
 tape( 'if a value\'s constructor is an anonymous function, the function returns an empty string', function test( t ) {
 	// eslint-disable-next-line func-names, no-extra-parens, space-before-function-paren
 	var v = typeOf( new ( function() {} )() );
-	t.equal( v, '', 'returns empty string' );
+	t.strictEqual( v, '', 'returns empty string' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/type-of/test/test.polyfill.js b/lib/node_modules/@stdlib/utils/type-of/test/test.polyfill.js
index 11dfa5c0cb8a..9eae32f9e654 100644
--- a/lib/node_modules/@stdlib/utils/type-of/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/utils/type-of/test/test.polyfill.js
@@ -139,7 +139,7 @@ tape( 'the function returns a value\'s type', function test( t ) {
 
 	for ( i = 0; i < values.length; i++ ) {
 		type = typeOf( values[i] );
-		t.equal( type, expected[i], 'returns '+expected[i]+' when provided '+values[i] );
+		t.strictEqual( type, expected[i], 'returns '+expected[i]+' when provided '+values[i] );
 	}
 	t.end();
 });
@@ -148,7 +148,7 @@ tape( 'the function supports Map objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasMapSupport() ) {
 		v = typeOf( new Map() );
-		t.equal( v, 'map', 'returns map' );
+		t.strictEqual( v, 'map', 'returns map' );
 	}
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'the function supports WeakMap objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasWeakMapSupport() ) {
 		v = typeOf( new WeakMap() );
-		t.equal( v, 'weakmap', 'returns weakmap' );
+		t.strictEqual( v, 'weakmap', 'returns weakmap' );
 	}
 	t.end();
 });
@@ -166,7 +166,7 @@ tape( 'the function supports Set objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasSetSupport() ) {
 		v = typeOf( new Set() );
-		t.equal( v, 'set', 'returns set' );
+		t.strictEqual( v, 'set', 'returns set' );
 	}
 	t.end();
 });
@@ -175,7 +175,7 @@ tape( 'the function supports WeakSet objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasWeakSetSupport() ) {
 		v = typeOf( new WeakSet() );
-		t.equal( v, 'weakset', 'returns weakset' );
+		t.strictEqual( v, 'weakset', 'returns weakset' );
 	}
 	t.end();
 });
@@ -184,7 +184,7 @@ tape( 'the function supports Symbol objects (ES2015)', function test( t ) {
 	var v;
 	if ( hasSymbolSupport() ) {
 		v = typeOf( Symbol( 'beep' ) );
-		t.equal( v, 'symbol', 'returns symbol' );
+		t.strictEqual( v, 'symbol', 'returns symbol' );
 	}
 	t.end();
 });
@@ -193,14 +193,14 @@ tape( 'the function supports custom objects', function test( t ) {
 	var v;
 	function Person() {}
 	v = typeOf( new Person() );
-	t.equal( v, 'person', 'returns person' );
+	t.strictEqual( v, 'person', 'returns person' );
 	t.end();
 });
 
 tape( 'if a value\'s constructor is an anonymous function, the function returns an empty string', function test( t ) {
 	// eslint-disable-next-line func-names, no-extra-parens, space-before-function-paren
 	var v = typeOf( new ( function() {} )() );
-	t.equal( v, '', 'returns empty string' );
+	t.strictEqual( v, '', 'returns empty string' );
 
 	t.end();
 });

From 9c21fd20ef8b8a6a88abb96d80ea6d8e4c5434eb Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Wed, 13 Aug 2025 19:19:35 -0500
Subject: [PATCH 05/32] test: use .strictEqual() instead of .equal()

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../dists/arcsine/cdf/test/test.factory.js    | 34 +++----
 .../stats/base/dists/arcsine/cdf/test/test.js |  2 +-
 .../base/dists/arcsine/cdf/test/test.main.js  | 24 ++---
 .../dists/arcsine/cdf/test/test.native.js     | 24 ++---
 .../base/dists/arcsine/entropy/test/test.js   | 14 +--
 .../dists/arcsine/entropy/test/test.native.js | 14 +--
 .../base/dists/arcsine/kurtosis/test/test.js  | 14 +--
 .../arcsine/kurtosis/test/test.native.js      | 14 +--
 .../dists/arcsine/logcdf/test/test.factory.js | 34 +++----
 .../base/dists/arcsine/logcdf/test/test.js    |  2 +-
 .../dists/arcsine/logcdf/test/test.logcdf.js  | 24 ++---
 .../dists/arcsine/logpdf/test/test.factory.js | 34 +++----
 .../base/dists/arcsine/logpdf/test/test.js    |  2 +-
 .../dists/arcsine/logpdf/test/test.logpdf.js  | 24 ++---
 .../dists/arcsine/logpdf/test/test.native.js  | 24 ++---
 .../base/dists/arcsine/mean/test/test.js      | 14 +--
 .../dists/arcsine/mean/test/test.native.js    | 14 +--
 .../base/dists/arcsine/median/test/test.js    | 14 +--
 .../dists/arcsine/median/test/test.native.js  | 14 +--
 .../base/dists/arcsine/mode/test/test.js      | 14 +--
 .../dists/arcsine/mode/test/test.native.js    | 14 +--
 .../dists/arcsine/pdf/test/test.factory.js    | 34 +++----
 .../stats/base/dists/arcsine/pdf/test/test.js |  2 +-
 .../dists/arcsine/pdf/test/test.native.js     | 24 ++---
 .../base/dists/arcsine/pdf/test/test.pdf.js   | 24 ++---
 .../arcsine/quantile/test/test.factory.js     | 30 +++---
 .../base/dists/arcsine/quantile/test/test.js  |  2 +-
 .../arcsine/quantile/test/test.native.js      | 24 ++---
 .../arcsine/quantile/test/test.quantile.js    | 24 ++---
 .../base/dists/arcsine/skewness/test/test.js  | 14 +--
 .../arcsine/skewness/test/test.native.js      | 14 +--
 .../base/dists/arcsine/stdev/test/test.js     | 14 +--
 .../dists/arcsine/stdev/test/test.native.js   | 14 +--
 .../stats/base/dists/arcsine/test/test.js     |  2 +-
 .../base/dists/arcsine/variance/test/test.js  | 14 +--
 .../arcsine/variance/test/test.native.js      | 14 +--
 .../base/dists/bernoulli/cdf/test/test.cdf.js | 24 ++---
 .../dists/bernoulli/cdf/test/test.factory.js  | 32 +++----
 .../base/dists/bernoulli/cdf/test/test.js     |  2 +-
 .../dists/bernoulli/cdf/test/test.native.js   | 24 ++---
 .../base/dists/bernoulli/entropy/test/test.js | 12 +--
 .../bernoulli/entropy/test/test.native.js     | 12 +--
 .../dists/bernoulli/kurtosis/test/test.js     | 12 +--
 .../bernoulli/kurtosis/test/test.native.js    | 12 +--
 .../base/dists/bernoulli/mean/test/test.js    | 12 +--
 .../dists/bernoulli/mean/test/test.native.js  | 12 +--
 .../base/dists/bernoulli/median/test/test.js  | 12 +--
 .../bernoulli/median/test/test.native.js      | 12 +--
 .../dists/bernoulli/mgf/test/test.factory.js  | 26 ++---
 .../base/dists/bernoulli/mgf/test/test.js     |  2 +-
 .../base/dists/bernoulli/mgf/test/test.mgf.js | 12 +--
 .../dists/bernoulli/mgf/test/test.native.js   | 16 ++--
 .../base/dists/bernoulli/mode/test/test.js    | 12 +--
 .../dists/bernoulli/mode/test/test.native.js  | 12 +--
 .../dists/bernoulli/pmf/test/test.factory.js  | 34 +++----
 .../base/dists/bernoulli/pmf/test/test.js     |  2 +-
 .../dists/bernoulli/pmf/test/test.native.js   | 26 ++---
 .../base/dists/bernoulli/pmf/test/test.pmf.js | 26 ++---
 .../bernoulli/quantile/test/test.factory.js   | 22 ++---
 .../dists/bernoulli/quantile/test/test.js     |  2 +-
 .../bernoulli/quantile/test/test.native.js    | 18 ++--
 .../bernoulli/quantile/test/test.quantile.js  | 18 ++--
 .../dists/bernoulli/skewness/test/test.js     | 12 +--
 .../bernoulli/skewness/test/test.native.js    | 12 +--
 .../base/dists/bernoulli/stdev/test/test.js   | 16 ++--
 .../dists/bernoulli/stdev/test/test.native.js | 16 ++--
 .../stats/base/dists/bernoulli/test/test.js   |  2 +-
 .../dists/bernoulli/variance/test/test.js     | 12 +--
 .../bernoulli/variance/test/test.native.js    | 12 +--
 .../base/dists/beta/cdf/test/test.cdf.js      | 56 +++++------
 .../base/dists/beta/cdf/test/test.factory.js  | 64 ++++++-------
 .../stats/base/dists/beta/cdf/test/test.js    |  2 +-
 .../base/dists/beta/entropy/test/test.js      | 26 ++---
 .../dists/beta/entropy/test/test.native.js    | 26 ++---
 .../base/dists/beta/kurtosis/test/test.js     | 26 ++---
 .../dists/beta/kurtosis/test/test.native.js   | 26 ++---
 .../dists/beta/logcdf/test/test.factory.js    | 60 ++++++------
 .../stats/base/dists/beta/logcdf/test/test.js |  2 +-
 .../dists/beta/logcdf/test/test.logcdf.js     | 52 +++++-----
 .../dists/beta/logpdf/test/test.factory.js    | 66 ++++++-------
 .../stats/base/dists/beta/logpdf/test/test.js |  2 +-
 .../dists/beta/logpdf/test/test.logpdf.js     | 60 ++++++------
 .../dists/beta/logpdf/test/test.native.js     | 60 ++++++------
 .../stats/base/dists/beta/mean/test/test.js   | 26 ++---
 .../base/dists/beta/mean/test/test.native.js  | 26 ++---
 .../stats/base/dists/beta/median/test/test.js | 26 ++---
 .../base/dists/beta/mgf/test/test.factory.js  | 40 ++++----
 .../stats/base/dists/beta/mgf/test/test.js    |  2 +-
 .../base/dists/beta/mgf/test/test.mgf.js      | 34 +++----
 .../base/dists/beta/mgf/test/test.native.js   | 34 +++----
 .../stats/base/dists/beta/mode/test/test.js   | 26 ++---
 .../base/dists/beta/mode/test/test.native.js  | 26 ++---
 .../base/dists/beta/pdf/test/test.factory.js  | 66 ++++++-------
 .../stats/base/dists/beta/pdf/test/test.js    |  2 +-
 .../base/dists/beta/pdf/test/test.native.js   | 60 ++++++------
 .../base/dists/beta/pdf/test/test.pdf.js      | 60 ++++++------
 .../dists/beta/quantile/test/test.factory.js  | 48 +++++-----
 .../base/dists/beta/quantile/test/test.js     |  2 +-
 .../dists/beta/quantile/test/test.quantile.js | 44 ++++-----
 .../base/dists/beta/skewness/test/test.js     | 26 ++---
 .../dists/beta/skewness/test/test.native.js   | 26 ++---
 .../stats/base/dists/beta/stdev/test/test.js  | 26 ++---
 .../base/dists/beta/stdev/test/test.native.js | 26 ++---
 .../stats/base/dists/beta/test/test.js        |  2 +-
 .../base/dists/beta/variance/test/test.js     | 26 ++---
 .../dists/beta/variance/test/test.native.js   | 26 ++---
 .../base/dists/betaprime/cdf/test/test.cdf.js | 50 +++++-----
 .../dists/betaprime/cdf/test/test.factory.js  | 58 ++++++------
 .../base/dists/betaprime/cdf/test/test.js     |  2 +-
 .../dists/betaprime/kurtosis/test/test.js     | 36 +++----
 .../betaprime/kurtosis/test/test.native.js    | 36 +++----
 .../betaprime/logcdf/test/test.factory.js     | 58 ++++++------
 .../base/dists/betaprime/logcdf/test/test.js  |  2 +-
 .../betaprime/logcdf/test/test.logcdf.js      | 50 +++++-----
 .../betaprime/logpdf/test/test.factory.js     | 48 +++++-----
 .../base/dists/betaprime/logpdf/test/test.js  |  2 +-
 .../betaprime/logpdf/test/test.logpdf.js      | 42 ++++-----
 .../betaprime/logpdf/test/test.native.js      | 42 ++++-----
 .../base/dists/betaprime/mean/test/test.js    | 30 +++---
 .../dists/betaprime/mean/test/test.native.js  | 30 +++---
 .../base/dists/betaprime/mode/test/test.js    | 26 ++---
 .../dists/betaprime/mode/test/test.native.js  | 26 ++---
 .../dists/betaprime/pdf/test/test.factory.js  | 50 +++++-----
 .../base/dists/betaprime/pdf/test/test.js     |  2 +-
 .../dists/betaprime/pdf/test/test.native.js   | 44 ++++-----
 .../base/dists/betaprime/pdf/test/test.pdf.js | 44 ++++-----
 .../betaprime/quantile/test/test.factory.js   | 48 +++++-----
 .../dists/betaprime/quantile/test/test.js     |  2 +-
 .../betaprime/quantile/test/test.quantile.js  | 44 ++++-----
 .../dists/betaprime/skewness/test/test.js     | 34 +++----
 .../betaprime/skewness/test/test.native.js    | 34 +++----
 .../base/dists/betaprime/stdev/test/test.js   | 32 +++----
 .../dists/betaprime/stdev/test/test.native.js | 32 +++----
 .../stats/base/dists/betaprime/test/test.js   |  2 +-
 .../dists/betaprime/variance/test/test.js     | 32 +++----
 .../betaprime/variance/test/test.native.js    | 32 +++----
 .../base/dists/binomial/cdf/test/test.cdf.js  | 44 ++++-----
 .../dists/binomial/cdf/test/test.factory.js   | 54 +++++------
 .../base/dists/binomial/cdf/test/test.js      |  2 +-
 .../base/dists/binomial/entropy/test/test.js  | 32 +++----
 .../binomial/entropy/test/test.native.js      | 38 ++++----
 .../base/dists/binomial/kurtosis/test/test.js | 26 ++---
 .../binomial/kurtosis/test/test.native.js     | 18 ++--
 .../binomial/logpmf/test/test.factory.js      | 94 +++++++++----------
 .../base/dists/binomial/logpmf/test/test.js   |  2 +-
 .../dists/binomial/logpmf/test/test.logpmf.js | 76 +++++++--------
 .../base/dists/binomial/mean/test/test.js     | 26 ++---
 .../dists/binomial/mean/test/test.native.js   | 10 +-
 .../base/dists/binomial/median/test/test.js   | 26 ++---
 .../dists/binomial/median/test/test.native.js | 16 ++--
 .../dists/binomial/mgf/test/test.factory.js   | 40 ++++----
 .../base/dists/binomial/mgf/test/test.js      |  2 +-
 .../base/dists/binomial/mgf/test/test.mgf.js  | 32 +++----
 .../dists/binomial/mgf/test/test.native.js    | 24 ++---
 .../base/dists/binomial/mode/test/test.js     | 26 ++---
 .../dists/binomial/mode/test/test.native.js   | 12 +--
 .../dists/binomial/pmf/test/test.factory.js   | 94 +++++++++----------
 .../base/dists/binomial/pmf/test/test.js      |  2 +-
 .../dists/binomial/pmf/test/test.native.js    | 66 ++++++-------
 .../base/dists/binomial/pmf/test/test.pmf.js  | 76 +++++++--------
 .../binomial/quantile/test/test.factory.js    | 72 +++++++-------
 .../base/dists/binomial/quantile/test/test.js |  2 +-
 .../binomial/quantile/test/test.quantile.js   | 66 ++++++-------
 .../base/dists/binomial/skewness/test/test.js | 26 ++---
 .../binomial/skewness/test/test.native.js     | 16 ++--
 .../base/dists/binomial/stdev/test/test.js    | 26 ++---
 .../dists/binomial/stdev/test/test.native.js  | 18 ++--
 .../stats/base/dists/binomial/test/test.js    |  2 +-
 .../base/dists/binomial/variance/test/test.js | 26 ++---
 .../binomial/variance/test/test.native.js     | 12 +--
 .../base/dists/bradford/cdf/test/test.cdf.js  | 32 +++----
 .../dists/bradford/cdf/test/test.factory.js   | 38 ++++----
 .../base/dists/bradford/cdf/test/test.js      |  2 +-
 .../dists/bradford/cdf/test/test.native.js    | 32 +++----
 .../base/dists/bradford/entropy/test/test.js  | 12 +--
 .../bradford/entropy/test/test.native.js      | 14 +--
 .../base/dists/bradford/mean/test/test.js     | 10 +-
 .../dists/bradford/mean/test/test.native.js   | 10 +-
 .../base/dists/bradford/median/test/test.js   | 10 +-
 .../dists/bradford/median/test/test.native.js | 16 ++--
 .../base/dists/bradford/mode/test/test.js     | 10 +-
 .../dists/bradford/mode/test/test.native.js   | 10 +-
 .../dists/bradford/pdf/test/test.factory.js   | 28 +++---
 .../base/dists/bradford/pdf/test/test.js      |  2 +-
 .../dists/bradford/pdf/test/test.native.js    | 24 ++---
 .../base/dists/bradford/pdf/test/test.pdf.js  | 24 ++---
 .../bradford/quantile/test/test.factory.js    | 28 +++---
 .../base/dists/bradford/quantile/test/test.js |  2 +-
 .../bradford/quantile/test/test.native.js     | 24 ++---
 .../bradford/quantile/test/test.quantile.js   | 24 ++---
 .../base/dists/bradford/skewness/test/test.js | 10 +-
 .../bradford/skewness/test/test.native.js     | 10 +-
 .../base/dists/bradford/stdev/test/test.js    | 12 +--
 .../dists/bradford/stdev/test/test.native.js  | 12 +--
 .../base/dists/bradford/variance/test/test.js | 12 +--
 .../bradford/variance/test/test.native.js     | 12 +--
 .../base/dists/cauchy/cdf/test/test.cdf.js    | 30 +++---
 .../dists/cauchy/cdf/test/test.factory.js     | 38 ++++----
 .../stats/base/dists/cauchy/cdf/test/test.js  |  2 +-
 .../base/dists/cauchy/cdf/test/test.native.js | 30 +++---
 .../base/dists/cauchy/entropy/test/test.js    | 16 ++--
 .../dists/cauchy/entropy/test/test.native.js  | 16 ++--
 .../dists/cauchy/logcdf/test/test.factory.js  | 38 ++++----
 .../base/dists/cauchy/logcdf/test/test.js     |  2 +-
 .../dists/cauchy/logcdf/test/test.logcdf.js   | 30 +++---
 .../dists/cauchy/logcdf/test/test.native.js   | 30 +++---
 .../dists/cauchy/logpdf/test/test.factory.js  | 38 ++++----
 .../base/dists/cauchy/logpdf/test/test.js     |  2 +-
 .../dists/cauchy/logpdf/test/test.logpdf.js   | 38 ++++----
 .../dists/cauchy/logpdf/test/test.native.js   | 38 ++++----
 .../base/dists/cauchy/median/test/test.js     | 16 ++--
 .../dists/cauchy/median/test/test.native.js   | 16 ++--
 .../stats/base/dists/cauchy/mode/test/test.js | 16 ++--
 .../dists/cauchy/mode/test/test.native.js     | 16 ++--
 .../dists/cauchy/pdf/test/test.factory.js     | 38 ++++----
 .../stats/base/dists/cauchy/pdf/test/test.js  |  2 +-
 .../base/dists/cauchy/pdf/test/test.native.js | 38 ++++----
 .../base/dists/cauchy/pdf/test/test.pdf.js    | 38 ++++----
 .../cauchy/quantile/test/test.factory.js      | 38 ++++----
 .../base/dists/cauchy/quantile/test/test.js   |  2 +-
 .../dists/cauchy/quantile/test/test.native.js | 32 +++----
 .../cauchy/quantile/test/test.quantile.js     | 32 +++----
 .../stats/base/dists/cauchy/test/test.js      |  2 +-
 .../stats/base/dists/chi/cdf/test/test.cdf.js | 28 +++---
 .../base/dists/chi/cdf/test/test.factory.js   | 28 +++---
 .../stats/base/dists/chi/cdf/test/test.js     |  2 +-
 .../base/dists/chi/cdf/test/test.native.js    | 28 +++---
 .../stats/base/dists/chi/entropy/test/test.js | 10 +-
 .../dists/chi/entropy/test/test.native.js     | 10 +-
 .../base/dists/chi/kurtosis/test/test.js      | 10 +-
 .../dists/chi/kurtosis/test/test.native.js    |  8 +-
 .../dists/chi/logpdf/test/test.factory.js     | 30 +++---
 .../stats/base/dists/chi/logpdf/test/test.js  |  2 +-
 .../base/dists/chi/logpdf/test/test.logpdf.js | 30 +++---
 .../base/dists/chi/logpdf/test/test.native.js | 18 ++--
 .../stats/base/dists/chi/mean/test/test.js    |  8 +-
 .../base/dists/chi/mean/test/test.native.js   |  8 +-
 .../stats/base/dists/chi/mode/test/test.js    | 12 +--
 .../base/dists/chi/mode/test/test.native.js   | 12 +--
 .../base/dists/chi/pdf/test/test.factory.js   | 30 +++---
 .../stats/base/dists/chi/pdf/test/test.js     |  2 +-
 .../base/dists/chi/pdf/test/test.native.js    | 16 ++--
 .../stats/base/dists/chi/pdf/test/test.pdf.js | 30 +++---
 .../dists/chi/quantile/test/test.factory.js   | 24 ++---
 .../base/dists/chi/quantile/test/test.js      |  2 +-
 .../dists/chi/quantile/test/test.quantile.js  | 24 ++---
 .../base/dists/chi/skewness/test/test.js      | 10 +-
 .../dists/chi/skewness/test/test.native.js    |  8 +-
 .../stats/base/dists/chi/stdev/test/test.js   |  8 +-
 .../base/dists/chi/stdev/test/test.native.js  |  8 +-
 .../@stdlib/stats/base/dists/chi/test/test.js |  2 +-
 .../base/dists/chi/variance/test/test.js      |  8 +-
 .../dists/chi/variance/test/test.native.js    |  8 +-
 .../base/dists/chisquare/cdf/test/test.cdf.js | 28 +++---
 .../dists/chisquare/cdf/test/test.factory.js  | 28 +++---
 .../base/dists/chisquare/cdf/test/test.js     |  2 +-
 .../dists/chisquare/cdf/test/test.native.js   | 18 ++--
 .../base/dists/chisquare/entropy/test/test.js | 10 +-
 .../chisquare/entropy/test/test.native.js     | 10 +-
 .../dists/chisquare/kurtosis/test/test.js     | 10 +-
 .../chisquare/kurtosis/test/test.native.js    | 10 +-
 .../chisquare/logpdf/test/test.factory.js     | 30 +++---
 .../base/dists/chisquare/logpdf/test/test.js  |  2 +-
 .../chisquare/logpdf/test/test.logpdf.js      | 30 +++---
 .../base/dists/chisquare/mean/test/test.js    |  8 +-
 .../dists/chisquare/mean/test/test.native.js  |  8 +-
 .../base/dists/chisquare/median/test/test.js  |  8 +-
 .../dists/chisquare/mgf/test/test.factory.js  | 16 ++--
 .../base/dists/chisquare/mgf/test/test.js     |  2 +-
 .../base/dists/chisquare/mgf/test/test.mgf.js | 18 ++--
 .../dists/chisquare/mgf/test/test.native.js   | 18 ++--
 .../base/dists/chisquare/mode/test/test.js    |  8 +-
 .../dists/chisquare/mode/test/test.native.js  |  8 +-
 .../dists/chisquare/pdf/test/test.factory.js  | 30 +++---
 .../base/dists/chisquare/pdf/test/test.js     |  2 +-
 .../base/dists/chisquare/pdf/test/test.pdf.js | 30 +++---
 .../chisquare/quantile/test/test.factory.js   | 24 ++---
 .../dists/chisquare/quantile/test/test.js     |  2 +-
 .../chisquare/quantile/test/test.quantile.js  | 24 ++---
 .../dists/chisquare/skewness/test/test.js     | 10 +-
 .../chisquare/skewness/test/test.native.js    | 10 +-
 .../base/dists/chisquare/stdev/test/test.js   |  8 +-
 .../dists/chisquare/stdev/test/test.native.js |  8 +-
 .../stats/base/dists/chisquare/test/test.js   |  2 +-
 .../dists/chisquare/variance/test/test.js     |  8 +-
 .../chisquare/variance/test/test.native.js    |  8 +-
 .../base/dists/cosine/cdf/test/test.cdf.js    | 34 +++----
 .../dists/cosine/cdf/test/test.factory.js     | 40 ++++----
 .../stats/base/dists/cosine/cdf/test/test.js  |  2 +-
 .../base/dists/cosine/cdf/test/test.native.js | 34 +++----
 .../base/dists/cosine/kurtosis/test/test.js   | 20 ++--
 .../dists/cosine/kurtosis/test/test.native.js | 20 ++--
 .../dists/cosine/logcdf/test/test.factory.js  | 40 ++++----
 .../base/dists/cosine/logcdf/test/test.js     |  2 +-
 .../dists/cosine/logcdf/test/test.logcdf.js   | 34 +++----
 .../dists/cosine/logcdf/test/test.native.js   | 34 +++----
 .../dists/cosine/logpdf/test/test.factory.js  | 52 +++++-----
 .../base/dists/cosine/logpdf/test/test.js     |  2 +-
 .../dists/cosine/logpdf/test/test.logpdf.js   | 46 ++++-----
 .../dists/cosine/logpdf/test/test.native.js   | 46 ++++-----
 .../stats/base/dists/cosine/mean/test/test.js | 20 ++--
 .../dists/cosine/mean/test/test.native.js     | 16 ++--
 .../base/dists/cosine/median/test/test.js     | 20 ++--
 .../dists/cosine/median/test/test.native.js   | 20 ++--
 .../dists/cosine/mgf/test/test.factory.js     | 24 ++---
 .../stats/base/dists/cosine/mgf/test/test.js  |  2 +-
 .../base/dists/cosine/mgf/test/test.mgf.js    | 18 ++--
 .../base/dists/cosine/mgf/test/test.native.js | 18 ++--
 .../stats/base/dists/cosine/mode/test/test.js | 20 ++--
 .../dists/cosine/mode/test/test.native.js     | 20 ++--
 .../dists/cosine/pdf/test/test.factory.js     | 52 +++++-----
 .../stats/base/dists/cosine/pdf/test/test.js  |  2 +-
 .../base/dists/cosine/pdf/test/test.native.js | 46 ++++-----
 .../base/dists/cosine/pdf/test/test.pdf.js    | 46 ++++-----
 .../cosine/quantile/test/test.factory.js      | 42 ++++-----
 .../base/dists/cosine/quantile/test/test.js   |  2 +-
 .../dists/cosine/quantile/test/test.native.js | 36 +++----
 .../cosine/quantile/test/test.quantile.js     | 36 +++----
 .../base/dists/cosine/skewness/test/test.js   | 20 ++--
 .../dists/cosine/skewness/test/test.native.js | 20 ++--
 .../base/dists/cosine/stdev/test/test.js      | 20 ++--
 .../dists/cosine/stdev/test/test.native.js    | 20 ++--
 .../stats/base/dists/cosine/test/test.js      |  2 +-
 .../base/dists/cosine/variance/test/test.js   | 20 ++--
 .../dists/cosine/variance/test/test.native.js | 20 ++--
 .../dists/degenerate/cdf/test/test.cdf.js     | 12 +--
 .../dists/degenerate/cdf/test/test.factory.js | 14 +--
 .../base/dists/degenerate/cdf/test/test.js    |  2 +-
 .../dists/degenerate/cdf/test/test.native.js  | 12 +--
 .../dists/degenerate/entropy/test/test.js     |  8 +-
 .../degenerate/entropy/test/test.native.js    |  8 +-
 .../degenerate/logcdf/test/test.factory.js    | 14 +--
 .../base/dists/degenerate/logcdf/test/test.js |  2 +-
 .../degenerate/logcdf/test/test.logcdf.js     | 14 +--
 .../degenerate/logcdf/test/test.native.js     | 14 +--
 .../degenerate/logpdf/test/test.factory.js    | 16 ++--
 .../base/dists/degenerate/logpdf/test/test.js |  2 +-
 .../degenerate/logpdf/test/test.logpdf.js     | 16 ++--
 .../degenerate/logpdf/test/test.native.js     | 16 ++--
 .../degenerate/logpmf/test/test.factory.js    | 16 ++--
 .../base/dists/degenerate/logpmf/test/test.js |  2 +-
 .../degenerate/logpmf/test/test.logpmf.js     | 16 ++--
 .../degenerate/logpmf/test/test.native.js     | 16 ++--
 .../base/dists/degenerate/mean/test/test.js   |  8 +-
 .../dists/degenerate/mean/test/test.native.js |  8 +-
 .../base/dists/degenerate/median/test/test.js |  8 +-
 .../degenerate/median/test/test.native.js     |  8 +-
 .../dists/degenerate/mgf/test/test.factory.js | 12 +--
 .../base/dists/degenerate/mgf/test/test.js    |  2 +-
 .../dists/degenerate/mgf/test/test.mgf.js     | 12 +--
 .../dists/degenerate/mgf/test/test.native.js  | 12 +--
 .../base/dists/degenerate/mode/test/test.js   |  8 +-
 .../dists/degenerate/mode/test/test.native.js |  8 +-
 .../dists/degenerate/pdf/test/test.factory.js | 16 ++--
 .../base/dists/degenerate/pdf/test/test.js    |  2 +-
 .../dists/degenerate/pdf/test/test.native.js  | 16 ++--
 .../dists/degenerate/pdf/test/test.pdf.js     | 16 ++--
 .../dists/degenerate/pmf/test/test.factory.js | 16 ++--
 .../base/dists/degenerate/pmf/test/test.js    |  2 +-
 .../dists/degenerate/pmf/test/test.native.js  | 16 ++--
 .../dists/degenerate/pmf/test/test.pmf.js     | 16 ++--
 .../degenerate/quantile/test/test.factory.js  | 14 +--
 .../dists/degenerate/quantile/test/test.js    |  2 +-
 .../degenerate/quantile/test/test.native.js   | 14 +--
 .../degenerate/quantile/test/test.quantile.js | 14 +--
 .../base/dists/degenerate/stdev/test/test.js  |  8 +-
 .../degenerate/stdev/test/test.native.js      |  8 +-
 .../stats/base/dists/degenerate/test/test.js  |  2 +-
 .../dists/degenerate/variance/test/test.js    |  8 +-
 .../degenerate/variance/test/test.native.js   |  8 +-
 .../discrete-uniform/cdf/test/test.cdf.js     | 24 ++---
 .../discrete-uniform/cdf/test/test.factory.js | 36 +++----
 .../dists/discrete-uniform/cdf/test/test.js   |  2 +-
 .../discrete-uniform/cdf/test/test.native.js  | 14 +--
 .../discrete-uniform/entropy/test/test.js     | 14 +--
 .../entropy/test/test.native.js               |  4 +-
 .../discrete-uniform/kurtosis/test/test.js    | 14 +--
 .../kurtosis/test/test.native.js              |  4 +-
 .../logcdf/test/test.factory.js               | 36 +++----
 .../discrete-uniform/logcdf/test/test.js      |  2 +-
 .../logcdf/test/test.logcdf.js                | 24 ++---
 .../logcdf/test/test.native.js                | 14 +--
 .../logpmf/test/test.factory.js               | 36 +++----
 .../discrete-uniform/logpmf/test/test.js      |  2 +-
 .../logpmf/test/test.logpmf.js                | 24 ++---
 .../logpmf/test/test.native.js                | 14 +--
 .../dists/discrete-uniform/mean/test/test.js  | 14 +--
 .../discrete-uniform/mean/test/test.native.js |  4 +-
 .../discrete-uniform/median/test/test.js      | 14 +--
 .../median/test/test.native.js                |  4 +-
 .../discrete-uniform/mgf/test/test.factory.js | 36 +++----
 .../dists/discrete-uniform/mgf/test/test.js   |  2 +-
 .../discrete-uniform/mgf/test/test.mgf.js     | 26 ++---
 .../discrete-uniform/mgf/test/test.native.js  | 16 ++--
 .../discrete-uniform/pmf/test/test.factory.js | 36 +++----
 .../dists/discrete-uniform/pmf/test/test.js   |  2 +-
 .../discrete-uniform/pmf/test/test.native.js  | 14 +--
 .../discrete-uniform/pmf/test/test.pmf.js     | 24 ++---
 .../quantile/test/test.factory.js             | 34 +++----
 .../discrete-uniform/quantile/test/test.js    |  2 +-
 .../quantile/test/test.native.js              | 16 ++--
 .../quantile/test/test.quantile.js            | 26 ++---
 .../discrete-uniform/skewness/test/test.js    | 14 +--
 .../skewness/test/test.native.js              |  4 +-
 .../dists/discrete-uniform/stdev/test/test.js | 14 +--
 .../stdev/test/test.native.js                 |  4 +-
 .../base/dists/discrete-uniform/test/test.js  |  2 +-
 .../discrete-uniform/variance/test/test.js    | 14 +--
 .../variance/test/test.native.js              |  4 +-
 .../base/dists/erlang/cdf/test/test.cdf.js    | 40 ++++----
 .../dists/erlang/cdf/test/test.factory.js     | 46 ++++-----
 .../stats/base/dists/erlang/cdf/test/test.js  |  2 +-
 .../base/dists/erlang/entropy/test/test.js    | 32 +++----
 .../dists/erlang/entropy/test/test.native.js  | 28 +++---
 .../base/dists/erlang/kurtosis/test/test.js   | 32 +++----
 .../dists/erlang/kurtosis/test/test.native.js | 20 ++--
 .../dists/erlang/logpdf/test/test.factory.js  | 50 +++++-----
 .../base/dists/erlang/logpdf/test/test.js     |  2 +-
 .../dists/erlang/logpdf/test/test.logpdf.js   | 40 ++++----
 .../stats/base/dists/erlang/mean/test/test.js | 32 +++----
 .../dists/erlang/mean/test/test.native.js     | 28 +++---
 .../dists/erlang/mgf/test/test.factory.js     | 46 ++++-----
 .../stats/base/dists/erlang/mgf/test/test.js  |  2 +-
 .../base/dists/erlang/mgf/test/test.mgf.js    | 40 ++++----
 .../stats/base/dists/erlang/mode/test/test.js | 32 +++----
 .../dists/erlang/mode/test/test.native.js     | 28 +++---
 .../dists/erlang/pdf/test/test.factory.js     | 50 +++++-----
 .../stats/base/dists/erlang/pdf/test/test.js  |  2 +-
 .../base/dists/erlang/pdf/test/test.pdf.js    | 40 ++++----
 .../erlang/quantile/test/test.factory.js      | 46 ++++-----
 .../base/dists/erlang/quantile/test/test.js   |  2 +-
 .../erlang/quantile/test/test.quantile.js     | 44 ++++-----
 .../base/dists/erlang/skewness/test/test.js   | 32 +++----
 .../dists/erlang/skewness/test/test.native.js | 28 +++---
 .../base/dists/erlang/stdev/test/test.js      | 32 +++----
 .../dists/erlang/stdev/test/test.native.js    | 28 +++---
 .../stats/base/dists/erlang/test/test.js      |  2 +-
 .../base/dists/erlang/variance/test/test.js   | 32 +++----
 .../dists/erlang/variance/test/test.native.js | 28 +++---
 .../dists/exponential/cdf/test/test.cdf.js    | 22 ++---
 .../exponential/cdf/test/test.factory.js      | 24 ++---
 .../base/dists/exponential/cdf/test/test.js   |  2 +-
 .../dists/exponential/cdf/test/test.native.js | 22 ++---
 .../dists/exponential/entropy/test/test.js    |  8 +-
 .../exponential/entropy/test/test.native.js   |  8 +-
 .../dists/exponential/kurtosis/test/test.js   |  8 +-
 .../exponential/kurtosis/test/test.native.js  |  8 +-
 .../exponential/logcdf/test/test.factory.js   | 24 ++---
 .../dists/exponential/logcdf/test/test.js     |  2 +-
 .../exponential/logcdf/test/test.logcdf.js    | 24 ++---
 .../exponential/logcdf/test/test.native.js    | 24 ++---
 .../exponential/logpdf/test/test.factory.js   | 30 +++---
 .../dists/exponential/logpdf/test/test.js     |  2 +-
 .../exponential/logpdf/test/test.logpdf.js    | 30 +++---
 .../exponential/logpdf/test/test.native.js    | 30 +++---
 .../base/dists/exponential/mean/test/test.js  |  8 +-
 .../exponential/mean/test/test.native.js      |  8 +-
 .../dists/exponential/median/test/test.js     |  8 +-
 .../exponential/median/test/test.native.js    |  8 +-
 .../exponential/mgf/test/test.factory.js      | 32 +++----
 .../base/dists/exponential/mgf/test/test.js   |  2 +-
 .../dists/exponential/mgf/test/test.mgf.js    | 32 +++----
 .../dists/exponential/mgf/test/test.native.js | 32 +++----
 .../base/dists/exponential/mode/test/test.js  |  8 +-
 .../exponential/mode/test/test.native.js      |  8 +-
 .../exponential/pdf/test/test.factory.js      | 30 +++---
 .../base/dists/exponential/pdf/test/test.js   |  2 +-
 .../dists/exponential/pdf/test/test.native.js | 26 ++---
 .../dists/exponential/pdf/test/test.pdf.js    | 30 +++---
 .../exponential/quantile/test/test.factory.js | 24 ++---
 .../dists/exponential/quantile/test/test.js   |  2 +-
 .../exponential/quantile/test/test.native.js  | 24 ++---
 .../quantile/test/test.quantile.js            | 24 ++---
 .../dists/exponential/skewness/test/test.js   |  8 +-
 .../exponential/skewness/test/test.native.js  |  8 +-
 .../base/dists/exponential/stdev/test/test.js |  8 +-
 .../exponential/stdev/test/test.native.js     |  8 +-
 .../stats/base/dists/exponential/test/test.js |  2 +-
 .../dists/exponential/variance/test/test.js   |  8 +-
 .../exponential/variance/test/test.native.js  |  8 +-
 .../stats/base/dists/f/cdf/test/test.cdf.js   | 40 ++++----
 .../base/dists/f/cdf/test/test.factory.js     | 46 ++++-----
 .../stats/base/dists/f/cdf/test/test.js       |  2 +-
 .../stats/base/dists/f/entropy/test/test.js   | 26 ++---
 .../base/dists/f/entropy/test/test.native.js  | 26 ++---
 .../stats/base/dists/f/kurtosis/test/test.js  | 42 ++++-----
 .../base/dists/f/kurtosis/test/test.native.js | 42 ++++-----
 .../stats/base/dists/f/mean/test/test.js      | 30 +++---
 .../base/dists/f/mean/test/test.native.js     | 30 +++---
 .../stats/base/dists/f/mode/test/test.js      | 30 +++---
 .../base/dists/f/mode/test/test.native.js     | 30 +++---
 .../base/dists/f/pdf/test/test.factory.js     | 68 +++++++-------
 .../stats/base/dists/f/pdf/test/test.js       |  2 +-
 .../stats/base/dists/f/pdf/test/test.pdf.js   | 58 ++++++------
 .../dists/f/quantile/test/test.factory.js     | 50 +++++-----
 .../stats/base/dists/f/quantile/test/test.js  |  2 +-
 .../dists/f/quantile/test/test.quantile.js    | 44 ++++-----
 .../stats/base/dists/f/skewness/test/test.js  | 38 ++++----
 .../base/dists/f/skewness/test/test.native.js | 38 ++++----
 .../stats/base/dists/f/stdev/test/test.js     | 34 +++----
 .../base/dists/f/stdev/test/test.native.js    | 34 +++----
 .../@stdlib/stats/base/dists/f/test/test.js   |  2 +-
 .../stats/base/dists/f/variance/test/test.js  | 34 +++----
 .../base/dists/f/variance/test/test.native.js | 34 +++----
 .../base/dists/frechet/cdf/test/test.cdf.js   | 52 +++++-----
 .../dists/frechet/cdf/test/test.factory.js    | 46 ++++-----
 .../stats/base/dists/frechet/cdf/test/test.js |  2 +-
 .../dists/frechet/cdf/test/test.native.js     | 52 +++++-----
 .../base/dists/frechet/entropy/test/test.js   | 32 +++----
 .../dists/frechet/entropy/test/test.native.js | 32 +++----
 .../base/dists/frechet/kurtosis/test/test.js  | 32 +++----
 .../frechet/kurtosis/test/test.native.js      | 32 +++----
 .../dists/frechet/logcdf/test/test.factory.js | 46 ++++-----
 .../base/dists/frechet/logcdf/test/test.js    |  2 +-
 .../dists/frechet/logcdf/test/test.logcdf.js  | 52 +++++-----
 .../dists/frechet/logcdf/test/test.native.js  | 52 +++++-----
 .../dists/frechet/logpdf/test/test.factory.js | 44 ++++-----
 .../base/dists/frechet/logpdf/test/test.js    |  2 +-
 .../dists/frechet/logpdf/test/test.logpdf.js  | 50 +++++-----
 .../dists/frechet/logpdf/test/test.native.js  | 50 +++++-----
 .../base/dists/frechet/mean/test/test.js      | 32 +++----
 .../dists/frechet/mean/test/test.native.js    | 32 +++----
 .../base/dists/frechet/median/test/test.js    | 32 +++----
 .../dists/frechet/median/test/test.native.js  | 32 +++----
 .../base/dists/frechet/mode/test/test.js      | 32 +++----
 .../dists/frechet/mode/test/test.native.js    | 32 +++----
 .../dists/frechet/pdf/test/test.factory.js    | 44 ++++-----
 .../stats/base/dists/frechet/pdf/test/test.js |  2 +-
 .../base/dists/frechet/pdf/test/test.pdf.js   | 50 +++++-----
 .../frechet/quantile/test/test.factory.js     | 38 ++++----
 .../base/dists/frechet/quantile/test/test.js  |  2 +-
 .../frechet/quantile/test/test.native.js      | 46 ++++-----
 .../frechet/quantile/test/test.quantile.js    | 46 ++++-----
 .../base/dists/frechet/skewness/test/test.js  | 32 +++----
 .../frechet/skewness/test/test.native.js      | 32 +++----
 .../base/dists/frechet/stdev/test/test.js     | 32 +++----
 .../dists/frechet/stdev/test/test.native.js   | 32 +++----
 .../stats/base/dists/frechet/test/test.js     |  2 +-
 .../base/dists/frechet/variance/test/test.js  | 32 +++----
 .../frechet/variance/test/test.native.js      | 32 +++----
 .../base/dists/gamma/cdf/test/test.cdf.js     | 54 +++++------
 .../base/dists/gamma/cdf/test/test.factory.js | 62 ++++++------
 .../stats/base/dists/gamma/cdf/test/test.js   |  2 +-
 .../base/dists/gamma/cdf/test/test.native.js  | 40 ++++----
 .../base/dists/gamma/entropy/test/test.js     | 26 ++---
 .../dists/gamma/entropy/test/test.native.js   | 26 ++---
 .../base/dists/gamma/kurtosis/test/test.js    | 26 ++---
 .../dists/gamma/kurtosis/test/test.native.js  | 26 ++---
 .../dists/gamma/logcdf/test/test.factory.js   | 58 ++++++------
 .../base/dists/gamma/logcdf/test/test.js      |  2 +-
 .../dists/gamma/logcdf/test/test.logcdf.js    | 50 +++++-----
 .../dists/gamma/logcdf/test/test.native.js    | 52 +++++-----
 .../dists/gamma/logpdf/test/test.factory.js   | 62 ++++++------
 .../base/dists/gamma/logpdf/test/test.js      |  2 +-
 .../dists/gamma/logpdf/test/test.logpdf.js    | 54 +++++------
 .../dists/gamma/logpdf/test/test.native.js    | 54 +++++------
 .../stats/base/dists/gamma/mean/test/test.js  | 26 ++---
 .../base/dists/gamma/mean/test/test.native.js | 26 ++---
 .../base/dists/gamma/mgf/test/test.factory.js | 42 ++++-----
 .../stats/base/dists/gamma/mgf/test/test.js   |  2 +-
 .../base/dists/gamma/mgf/test/test.mgf.js     | 36 +++----
 .../base/dists/gamma/mgf/test/test.native.js  | 36 +++----
 .../stats/base/dists/gamma/mode/test/test.js  | 26 ++---
 .../base/dists/gamma/mode/test/test.native.js | 26 ++---
 .../base/dists/gamma/pdf/test/test.factory.js | 62 ++++++------
 .../stats/base/dists/gamma/pdf/test/test.js   |  2 +-
 .../base/dists/gamma/pdf/test/test.native.js  | 54 +++++------
 .../base/dists/gamma/pdf/test/test.pdf.js     | 54 +++++------
 .../dists/gamma/quantile/test/test.factory.js | 58 ++++++------
 .../base/dists/gamma/quantile/test/test.js    |  2 +-
 .../gamma/quantile/test/test.quantile.js      | 50 +++++-----
 .../base/dists/gamma/skewness/test/test.js    | 26 ++---
 .../dists/gamma/skewness/test/test.native.js  | 26 ++---
 .../stats/base/dists/gamma/stdev/test/test.js | 26 ++---
 .../dists/gamma/stdev/test/test.native.js     | 26 ++---
 .../stats/base/dists/gamma/test/test.js       |  2 +-
 .../base/dists/gamma/variance/test/test.js    | 26 ++---
 .../dists/gamma/variance/test/test.native.js  | 26 ++---
 .../base/dists/geometric/cdf/test/test.cdf.js | 24 ++---
 .../dists/geometric/cdf/test/test.factory.js  | 32 +++----
 .../base/dists/geometric/cdf/test/test.js     |  2 +-
 .../dists/geometric/cdf/test/test.native.js   | 24 ++---
 .../base/dists/geometric/entropy/test/test.js | 12 +--
 .../geometric/entropy/test/test.native.js     | 12 +--
 .../dists/geometric/kurtosis/test/test.js     | 12 +--
 .../geometric/kurtosis/test/test.native.js    | 12 +--
 .../geometric/logcdf/test/test.factory.js     | 32 +++----
 .../base/dists/geometric/logcdf/test/test.js  |  2 +-
 .../geometric/logcdf/test/test.logcdf.js      | 24 ++---
 .../geometric/logcdf/test/test.native.js      | 24 ++---
 .../geometric/logpmf/test/test.factory.js     | 34 +++----
 .../base/dists/geometric/logpmf/test/test.js  |  2 +-
 .../geometric/logpmf/test/test.logpmf.js      | 26 ++---
 .../geometric/logpmf/test/test.native.js      | 26 ++---
 .../base/dists/geometric/mean/test/test.js    | 12 +--
 .../dists/geometric/mean/test/test.native.js  | 12 +--
 .../base/dists/geometric/median/test/test.js  | 12 +--
 .../geometric/median/test/test.native.js      | 12 +--
 .../dists/geometric/mgf/test/test.factory.js  | 26 ++---
 .../base/dists/geometric/mgf/test/test.js     |  2 +-
 .../base/dists/geometric/mgf/test/test.mgf.js | 16 ++--
 .../dists/geometric/mgf/test/test.native.js   | 16 ++--
 .../base/dists/geometric/mode/test/test.js    | 12 +--
 .../dists/geometric/mode/test/test.native.js  | 12 +--
 .../dists/geometric/pmf/test/test.factory.js  | 34 +++----
 .../base/dists/geometric/pmf/test/test.js     |  2 +-
 .../dists/geometric/pmf/test/test.native.js   | 26 ++---
 .../base/dists/geometric/pmf/test/test.pmf.js | 26 ++---
 .../geometric/quantile/test/test.factory.js   | 24 ++---
 .../dists/geometric/quantile/test/test.js     |  2 +-
 .../geometric/quantile/test/test.native.js    | 22 ++---
 .../geometric/quantile/test/test.quantile.js  | 22 ++---
 .../dists/geometric/skewness/test/test.js     | 12 +--
 .../geometric/skewness/test/test.native.js    | 12 +--
 .../base/dists/geometric/stdev/test/test.js   | 12 +--
 .../dists/geometric/stdev/test/test.native.js | 12 +--
 .../stats/base/dists/geometric/test/test.js   |  2 +-
 .../dists/geometric/variance/test/test.js     | 12 +--
 .../geometric/variance/test/test.native.js    | 12 +--
 .../base/dists/gumbel/cdf/test/test.cdf.js    | 32 +++----
 .../dists/gumbel/cdf/test/test.factory.js     | 38 ++++----
 .../stats/base/dists/gumbel/cdf/test/test.js  |  2 +-
 .../base/dists/gumbel/cdf/test/test.native.js | 32 +++----
 .../base/dists/gumbel/entropy/test/test.js    | 20 ++--
 .../dists/gumbel/entropy/test/test.native.js  | 20 ++--
 .../base/dists/gumbel/kurtosis/test/test.js   | 20 ++--
 .../dists/gumbel/kurtosis/test/test.native.js | 20 ++--
 .../dists/gumbel/logcdf/test/test.factory.js  | 38 ++++----
 .../base/dists/gumbel/logcdf/test/test.js     |  2 +-
 .../dists/gumbel/logcdf/test/test.logcdf.js   | 32 +++----
 .../dists/gumbel/logcdf/test/test.native.js   | 32 +++----
 .../dists/gumbel/logpdf/test/test.factory.js  | 38 ++++----
 .../base/dists/gumbel/logpdf/test/test.js     |  2 +-
 .../dists/gumbel/logpdf/test/test.logpdf.js   | 32 +++----
 .../dists/gumbel/logpdf/test/test.native.js   | 32 +++----
 .../stats/base/dists/gumbel/mean/test/test.js | 20 ++--
 .../dists/gumbel/mean/test/test.native.js     | 20 ++--
 .../base/dists/gumbel/median/test/test.js     | 20 ++--
 .../dists/gumbel/median/test/test.native.js   | 18 ++--
 .../dists/gumbel/mgf/test/test.factory.js     | 30 +++---
 .../stats/base/dists/gumbel/mgf/test/test.js  |  2 +-
 .../base/dists/gumbel/mgf/test/test.mgf.js    | 24 ++---
 .../base/dists/gumbel/mgf/test/test.native.js | 24 ++---
 .../stats/base/dists/gumbel/mode/test/test.js | 20 ++--
 .../dists/gumbel/mode/test/test.native.js     | 20 ++--
 .../dists/gumbel/pdf/test/test.factory.js     | 38 ++++----
 .../stats/base/dists/gumbel/pdf/test/test.js  |  2 +-
 .../base/dists/gumbel/pdf/test/test.native.js | 32 +++----
 .../base/dists/gumbel/pdf/test/test.pdf.js    | 32 +++----
 .../gumbel/quantile/test/test.factory.js      | 38 ++++----
 .../base/dists/gumbel/quantile/test/test.js   |  2 +-
 .../dists/gumbel/quantile/test/test.native.js | 32 +++----
 .../gumbel/quantile/test/test.quantile.js     | 32 +++----
 .../base/dists/gumbel/skewness/test/test.js   | 20 ++--
 .../dists/gumbel/skewness/test/test.native.js | 20 ++--
 .../base/dists/gumbel/stdev/test/test.js      | 20 ++--
 .../dists/gumbel/stdev/test/test.native.js    | 20 ++--
 .../stats/base/dists/gumbel/test/test.js      |  2 +-
 .../base/dists/gumbel/variance/test/test.js   | 20 ++--
 .../dists/gumbel/variance/test/test.native.js | 20 ++--
 .../dists/hypergeometric/cdf/test/test.cdf.js | 54 +++++------
 .../hypergeometric/cdf/test/test.factory.js   | 72 +++++++-------
 .../dists/hypergeometric/cdf/test/test.js     |  2 +-
 .../hypergeometric/kurtosis/test/test.js      | 38 ++++----
 .../logpmf/test/test.factory.js               | 60 ++++++------
 .../dists/hypergeometric/logpmf/test/test.js  |  2 +-
 .../hypergeometric/logpmf/test/test.logpmf.js | 52 +++++-----
 .../hypergeometric/logpmf/test/test.native.js | 24 ++---
 .../dists/hypergeometric/mean/test/test.js    | 38 ++++----
 .../hypergeometric/mean/test/test.native.js   | 14 +--
 .../dists/hypergeometric/mode/test/test.js    | 38 ++++----
 .../hypergeometric/mode/test/test.native.js   | 14 +--
 .../hypergeometric/pmf/test/test.factory.js   | 60 ++++++------
 .../dists/hypergeometric/pmf/test/test.js     |  2 +-
 .../hypergeometric/pmf/test/test.native.js    | 24 ++---
 .../dists/hypergeometric/pmf/test/test.pmf.js | 52 +++++-----
 .../quantile/test/test.factory.js             | 66 ++++++-------
 .../hypergeometric/quantile/test/test.js      |  2 +-
 .../quantile/test/test.quantile.js            | 60 ++++++------
 .../hypergeometric/skewness/test/test.js      | 38 ++++----
 .../skewness/test/test.native.js              | 14 +--
 .../dists/hypergeometric/stdev/test/test.js   | 38 ++++----
 .../hypergeometric/stdev/test/test.native.js  | 14 +--
 .../base/dists/hypergeometric/test/test.js    |  2 +-
 .../hypergeometric/variance/test/test.js      | 38 ++++----
 .../variance/test/test.native.js              | 14 +--
 .../base/dists/invgamma/cdf/test/test.cdf.js  | 32 +++----
 .../dists/invgamma/cdf/test/test.factory.js   | 46 ++++-----
 .../base/dists/invgamma/cdf/test/test.js      |  2 +-
 .../dists/invgamma/cdf/test/test.native.js    | 34 +++----
 .../base/dists/invgamma/entropy/test/test.js  | 26 ++---
 .../invgamma/entropy/test/test.native.js      | 26 ++---
 .../base/dists/invgamma/kurtosis/test/test.js | 32 +++----
 .../invgamma/kurtosis/test/test.native.js     | 32 +++----
 .../invgamma/logpdf/test/test.factory.js      | 46 ++++-----
 .../base/dists/invgamma/logpdf/test/test.js   |  2 +-
 .../dists/invgamma/logpdf/test/test.logpdf.js | 40 ++++----
 .../dists/invgamma/logpdf/test/test.nativs.js | 40 ++++----
 .../base/dists/invgamma/mean/test/test.js     | 26 ++---
 .../dists/invgamma/mean/test/test.native.js   | 26 ++---
 .../base/dists/invgamma/mode/test/test.js     | 26 ++---
 .../dists/invgamma/mode/test/test.native.js   | 26 ++---
 .../dists/invgamma/pdf/test/test.factory.js   | 46 ++++-----
 .../base/dists/invgamma/pdf/test/test.js      |  2 +-
 .../dists/invgamma/pdf/test/test.native.js    | 40 ++++----
 .../base/dists/invgamma/pdf/test/test.pdf.js  | 40 ++++----
 .../invgamma/quantile/test/test.factory.js    | 46 ++++-----
 .../base/dists/invgamma/quantile/test/test.js |  2 +-
 .../invgamma/quantile/test/test.quantile.js   | 40 ++++----
 .../base/dists/invgamma/skewness/test/test.js | 26 ++---
 .../invgamma/skewness/test/test.native.js     | 26 ++---
 .../base/dists/invgamma/stdev/test/test.js    | 30 +++---
 .../dists/invgamma/stdev/test/test.native.js  | 30 +++---
 .../stats/base/dists/invgamma/test/test.js    |  2 +-
 .../base/dists/invgamma/variance/test/test.js | 30 +++---
 .../invgamma/variance/test/test.native.js     | 30 +++---
 .../dists/kumaraswamy/cdf/test/test.cdf.js    | 52 +++++-----
 .../kumaraswamy/cdf/test/test.factory.js      | 60 ++++++------
 .../base/dists/kumaraswamy/cdf/test/test.js   |  2 +-
 .../dists/kumaraswamy/cdf/test/test.native.js | 52 +++++-----
 .../dists/kumaraswamy/kurtosis/test/test.js   | 34 +++----
 .../kumaraswamy/kurtosis/test/test.native.js  | 34 +++----
 .../kumaraswamy/logcdf/test/test.factory.js   | 60 ++++++------
 .../dists/kumaraswamy/logcdf/test/test.js     |  2 +-
 .../kumaraswamy/logcdf/test/test.logcdf.js    | 52 +++++-----
 .../kumaraswamy/logcdf/test/test.native.js    | 52 +++++-----
 .../kumaraswamy/logpdf/test/test.factory.js   | 60 ++++++------
 .../dists/kumaraswamy/logpdf/test/test.js     |  2 +-
 .../kumaraswamy/logpdf/test/test.logpdf.js    | 52 +++++-----
 .../kumaraswamy/logpdf/test/test.native.js    | 52 +++++-----
 .../base/dists/kumaraswamy/mean/test/test.js  | 34 +++----
 .../kumaraswamy/mean/test/test.native.js      | 34 +++----
 .../dists/kumaraswamy/median/test/test.js     | 34 +++----
 .../kumaraswamy/median/test/test.native.js    | 34 +++----
 .../base/dists/kumaraswamy/mode/test/test.js  | 40 ++++----
 .../kumaraswamy/mode/test/test.native.js      | 40 ++++----
 .../kumaraswamy/pdf/test/test.factory.js      | 60 ++++++------
 .../base/dists/kumaraswamy/pdf/test/test.js   |  2 +-
 .../dists/kumaraswamy/pdf/test/test.pdf.js    | 52 +++++-----
 .../kumaraswamy/quantile/test/test.factory.js | 42 ++++-----
 .../dists/kumaraswamy/quantile/test/test.js   |  2 +-
 .../kumaraswamy/quantile/test/test.native.js  | 40 ++++----
 .../quantile/test/test.quantile.js            | 40 ++++----
 .../dists/kumaraswamy/skewness/test/test.js   | 34 +++----
 .../kumaraswamy/skewness/test/test.native.js  | 34 +++----
 .../base/dists/kumaraswamy/stdev/test/test.js | 34 +++----
 .../kumaraswamy/stdev/test/test.native.js     | 34 +++----
 .../stats/base/dists/kumaraswamy/test/test.js |  2 +-
 .../dists/kumaraswamy/variance/test/test.js   | 34 +++----
 .../kumaraswamy/variance/test/test.native.js  | 34 +++----
 .../base/dists/laplace/cdf/test/test.cdf.js   | 28 +++---
 .../dists/laplace/cdf/test/test.factory.js    | 38 ++++----
 .../stats/base/dists/laplace/cdf/test/test.js |  2 +-
 .../dists/laplace/cdf/test/test.native.js     | 28 +++---
 .../base/dists/laplace/entropy/test/test.js   | 20 ++--
 .../dists/laplace/entropy/test/test.native.js | 20 ++--
 .../base/dists/laplace/kurtosis/test/test.js  | 20 ++--
 .../laplace/kurtosis/test/test.native.js      | 20 ++--
 .../dists/laplace/logcdf/test/test.factory.js | 38 ++++----
 .../base/dists/laplace/logcdf/test/test.js    |  2 +-
 .../dists/laplace/logcdf/test/test.logcdf.js  | 28 +++---
 .../dists/laplace/logcdf/test/test.native.js  | 28 +++---
 .../dists/laplace/logpdf/test/test.factory.js | 38 ++++----
 .../base/dists/laplace/logpdf/test/test.js    |  2 +-
 .../dists/laplace/logpdf/test/test.logpdf.js  | 32 +++----
 .../dists/laplace/logpdf/test/test.native.js  | 32 +++----
 .../base/dists/laplace/mean/test/test.js      | 20 ++--
 .../dists/laplace/mean/test/test.native.js    | 20 ++--
 .../base/dists/laplace/median/test/test.js    | 20 ++--
 .../dists/laplace/median/test/test.native.js  | 20 ++--
 .../dists/laplace/mgf/test/test.factory.js    | 50 +++++-----
 .../stats/base/dists/laplace/mgf/test/test.js |  2 +-
 .../base/dists/laplace/mgf/test/test.mgf.js   | 44 ++++-----
 .../dists/laplace/mgf/test/test.native.js     | 44 ++++-----
 .../base/dists/laplace/mode/test/test.js      | 20 ++--
 .../dists/laplace/mode/test/test.native.js    | 20 ++--
 .../dists/laplace/pdf/test/test.factory.js    | 38 ++++----
 .../stats/base/dists/laplace/pdf/test/test.js |  2 +-
 .../dists/laplace/pdf/test/test.native.js     | 32 +++----
 .../base/dists/laplace/pdf/test/test.pdf.js   | 32 +++----
 .../laplace/quantile/test/test.factory.js     | 38 ++++----
 .../base/dists/laplace/quantile/test/test.js  |  2 +-
 .../laplace/quantile/test/test.native.js      | 32 +++----
 .../laplace/quantile/test/test.quantile.js    | 32 +++----
 .../base/dists/laplace/skewness/test/test.js  | 20 ++--
 .../laplace/skewness/test/test.native.js      | 20 ++--
 .../base/dists/laplace/stdev/test/test.js     | 20 ++--
 .../dists/laplace/stdev/test/test.native.js   | 20 ++--
 .../stats/base/dists/laplace/test/test.js     |  2 +-
 .../base/dists/laplace/variance/test/test.js  | 20 ++--
 .../laplace/variance/test/test.native.js      | 20 ++--
 .../base/dists/levy/cdf/test/test.cdf.js      | 34 +++----
 .../base/dists/levy/cdf/test/test.factory.js  | 42 ++++-----
 .../stats/base/dists/levy/cdf/test/test.js    |  2 +-
 .../base/dists/levy/cdf/test/test.native.js   | 34 +++----
 .../base/dists/levy/entropy/test/test.js      | 20 ++--
 .../dists/levy/entropy/test/test.native.js    | 20 ++--
 .../dists/levy/logcdf/test/test.factory.js    | 42 ++++-----
 .../stats/base/dists/levy/logcdf/test/test.js |  2 +-
 .../dists/levy/logcdf/test/test.logcdf.js     | 34 +++----
 .../dists/levy/logcdf/test/test.native.js     | 34 +++----
 .../dists/levy/logpdf/test/test.factory.js    | 40 ++++----
 .../stats/base/dists/levy/logpdf/test/test.js |  2 +-
 .../dists/levy/logpdf/test/test.logpdf.js     | 34 +++----
 .../dists/levy/logpdf/test/test.native.js     | 30 +++---
 .../stats/base/dists/levy/mean/test/test.js   | 20 ++--
 .../base/dists/levy/mean/test/test.native.js  | 20 ++--
 .../stats/base/dists/levy/median/test/test.js | 20 ++--
 .../dists/levy/median/test/test.native.js     | 20 ++--
 .../stats/base/dists/levy/mode/test/test.js   | 20 ++--
 .../base/dists/levy/mode/test/test.native.js  | 20 ++--
 .../base/dists/levy/pdf/test/test.factory.js  | 36 +++----
 .../stats/base/dists/levy/pdf/test/test.js    |  2 +-
 .../base/dists/levy/pdf/test/test.native.js   | 30 +++---
 .../base/dists/levy/pdf/test/test.pdf.js      | 30 +++---
 .../dists/levy/quantile/test/test.factory.js  | 34 +++----
 .../base/dists/levy/quantile/test/test.js     |  2 +-
 .../dists/levy/quantile/test/test.native.js   | 28 +++---
 .../dists/levy/quantile/test/test.quantile.js | 28 +++---
 .../stats/base/dists/levy/stdev/test/test.js  | 20 ++--
 .../base/dists/levy/stdev/test/test.native.js | 20 ++--
 .../stats/base/dists/levy/test/test.js        |  2 +-
 .../base/dists/levy/variance/test/test.js     | 20 ++--
 .../dists/levy/variance/test/test.native.js   | 20 ++--
 .../base/dists/logistic/cdf/test/test.cdf.js  | 34 +++----
 .../dists/logistic/cdf/test/test.factory.js   | 40 ++++----
 .../base/dists/logistic/cdf/test/test.js      |  2 +-
 .../dists/logistic/cdf/test/test.native.js    | 34 +++----
 .../base/dists/logistic/entropy/test/test.js  | 20 ++--
 .../logistic/entropy/test/test.native.js      | 20 ++--
 .../base/dists/logistic/kurtosis/test/test.js | 20 ++--
 .../logistic/kurtosis/test/test.native.js     | 18 ++--
 .../logistic/logcdf/test/test.factory.js      | 40 ++++----
 .../base/dists/logistic/logcdf/test/test.js   |  2 +-
 .../dists/logistic/logcdf/test/test.logcdf.js | 34 +++----
 .../dists/logistic/logcdf/test/test.native.js | 34 +++----
 .../logistic/logpdf/test/test.factory.js      | 44 ++++-----
 .../base/dists/logistic/logpdf/test/test.js   |  2 +-
 .../dists/logistic/logpdf/test/test.logpdf.js | 38 ++++----
 .../dists/logistic/logpdf/test/test.native.js | 38 ++++----
 .../base/dists/logistic/mean/test/test.js     | 20 ++--
 .../dists/logistic/mean/test/test.native.js   | 18 ++--
 .../base/dists/logistic/median/test/test.js   | 20 ++--
 .../dists/logistic/median/test/test.native.js | 18 ++--
 .../dists/logistic/mgf/test/test.factory.js   | 36 +++----
 .../base/dists/logistic/mgf/test/test.js      |  2 +-
 .../base/dists/logistic/mgf/test/test.mgf.js  | 24 ++---
 .../dists/logistic/mgf/test/test.native.js    | 24 ++---
 .../base/dists/logistic/mode/test/test.js     | 20 ++--
 .../dists/logistic/mode/test/test.native.js   | 18 ++--
 .../dists/logistic/pdf/test/test.factory.js   | 44 ++++-----
 .../base/dists/logistic/pdf/test/test.js      |  2 +-
 .../dists/logistic/pdf/test/test.native.js    | 38 ++++----
 .../base/dists/logistic/pdf/test/test.pdf.js  | 38 ++++----
 .../logistic/quantile/test/test.factory.js    | 42 ++++-----
 .../base/dists/logistic/quantile/test/test.js |  2 +-
 .../logistic/quantile/test/test.native.js     | 36 +++----
 .../logistic/quantile/test/test.quantile.js   | 36 +++----
 .../base/dists/logistic/skewness/test/test.js | 20 ++--
 .../logistic/skewness/test/test.native.js     | 18 ++--
 .../base/dists/logistic/stdev/test/test.js    | 20 ++--
 .../dists/logistic/stdev/test/test.native.js  | 20 ++--
 .../stats/base/dists/logistic/test/test.js    |  2 +-
 .../base/dists/logistic/variance/test/test.js | 20 ++--
 .../logistic/variance/test/test.native.js     | 20 ++--
 .../base/dists/lognormal/cdf/test/test.cdf.js | 30 +++---
 .../dists/lognormal/cdf/test/test.factory.js  | 34 +++----
 .../base/dists/lognormal/cdf/test/test.js     |  2 +-
 .../base/dists/lognormal/entropy/test/test.js | 20 ++--
 .../lognormal/entropy/test/test.native.js     | 20 ++--
 .../dists/lognormal/kurtosis/test/test.js     | 20 ++--
 .../lognormal/kurtosis/test/test.native.js    | 20 ++--
 .../lognormal/logcdf/test/test.factory.js     | 40 ++++----
 .../base/dists/lognormal/logcdf/test/test.js  |  2 +-
 .../lognormal/logcdf/test/test.logcdf.js      | 42 ++++-----
 .../lognormal/logpdf/test/test.factory.js     | 36 +++----
 .../base/dists/lognormal/logpdf/test/test.js  |  2 +-
 .../lognormal/logpdf/test/test.logpdf.js      | 30 +++---
 .../base/dists/lognormal/mean/test/test.js    | 20 ++--
 .../dists/lognormal/mean/test/test.native.js  | 20 ++--
 .../base/dists/lognormal/median/test/test.js  | 20 ++--
 .../lognormal/median/test/test.native.js      | 20 ++--
 .../base/dists/lognormal/mode/test/test.js    | 20 ++--
 .../dists/lognormal/mode/test/test.native.js  | 20 ++--
 .../dists/lognormal/pdf/test/test.factory.js  | 36 +++----
 .../base/dists/lognormal/pdf/test/test.js     |  2 +-
 .../dists/lognormal/pdf/test/test.native.js   | 30 +++---
 .../base/dists/lognormal/pdf/test/test.pdf.js | 30 +++---
 .../lognormal/quantile/test/test.factory.js   | 36 +++----
 .../dists/lognormal/quantile/test/test.js     |  2 +-
 .../lognormal/quantile/test/test.quantile.js  | 30 +++---
 .../dists/lognormal/skewness/test/test.js     | 20 ++--
 .../lognormal/skewness/test/test.native.js    | 20 ++--
 .../base/dists/lognormal/stdev/test/test.js   | 20 ++--
 .../dists/lognormal/stdev/test/test.native.js | 20 ++--
 .../stats/base/dists/lognormal/test/test.js   |  2 +-
 .../dists/lognormal/variance/test/test.js     | 20 ++--
 .../lognormal/variance/test/test.native.js    | 20 ++--
 .../negative-binomial/cdf/test/test.cdf.js    | 38 ++++----
 .../cdf/test/test.factory.js                  | 48 +++++-----
 .../dists/negative-binomial/cdf/test/test.js  |  2 +-
 .../negative-binomial/kurtosis/test/test.js   | 20 ++--
 .../kurtosis/test/test.native.js              | 20 ++--
 .../logpmf/test/test.factory.js               | 56 +++++------
 .../negative-binomial/logpmf/test/test.js     |  2 +-
 .../logpmf/test/test.logpmf.js                | 44 ++++-----
 .../dists/negative-binomial/mean/test/test.js | 20 ++--
 .../mean/test/test.native.js                  | 20 ++--
 .../mgf/test/test.factory.js                  | 34 +++----
 .../dists/negative-binomial/mgf/test/test.js  |  2 +-
 .../negative-binomial/mgf/test/test.mgf.js    | 26 ++---
 .../negative-binomial/mgf/test/test.native.js | 26 ++---
 .../dists/negative-binomial/mode/test/test.js | 20 ++--
 .../mode/test/test.native.js                  | 20 ++--
 .../pmf/test/test.factory.js                  | 56 +++++------
 .../dists/negative-binomial/pmf/test/test.js  |  2 +-
 .../negative-binomial/pmf/test/test.pmf.js    | 44 ++++-----
 .../quantile/test/test.factory.js             | 46 ++++-----
 .../negative-binomial/quantile/test/test.js   |  2 +-
 .../quantile/test/test.quantile.js            | 36 +++----
 .../negative-binomial/skewness/test/test.js   | 20 ++--
 .../skewness/test/test.native.js              | 20 ++--
 .../negative-binomial/stdev/test/test.js      | 20 ++--
 .../stdev/test/test.native.js                 | 20 ++--
 .../base/dists/negative-binomial/test/test.js |  2 +-
 .../negative-binomial/variance/test/test.js   | 20 ++--
 .../variance/test/test.native.js              | 14 +--
 .../base/dists/normal/cdf/test/test.cdf.js    | 34 +++----
 .../dists/normal/cdf/test/test.factory.js     | 40 ++++----
 .../stats/base/dists/normal/cdf/test/test.js  |  2 +-
 .../base/dists/normal/cdf/test/test.native.js | 34 +++----
 .../base/dists/normal/entropy/test/test.js    | 20 ++--
 .../dists/normal/entropy/test/test.native.js  | 20 ++--
 .../base/dists/normal/kurtosis/test/test.js   | 20 ++--
 .../dists/normal/kurtosis/test/test.native.js | 20 ++--
 .../dists/normal/logcdf/test/test.factory.js  | 40 ++++----
 .../base/dists/normal/logcdf/test/test.js     |  2 +-
 .../dists/normal/logcdf/test/test.logcdf.js   | 42 ++++-----
 .../dists/normal/logcdf/test/test.native.js   | 42 ++++-----
 .../dists/normal/logpdf/test/test.factory.js  | 40 ++++----
 .../base/dists/normal/logpdf/test/test.js     |  2 +-
 .../dists/normal/logpdf/test/test.logpdf.js   | 42 ++++-----
 .../dists/normal/logpdf/test/test.native.js   | 42 ++++-----
 .../stats/base/dists/normal/mean/test/test.js | 20 ++--
 .../dists/normal/mean/test/test.native.js     | 20 ++--
 .../base/dists/normal/median/test/test.js     | 20 ++--
 .../dists/normal/median/test/test.native.js   | 20 ++--
 .../dists/normal/mgf/test/test.factory.js     | 32 +++----
 .../stats/base/dists/normal/mgf/test/test.js  |  2 +-
 .../base/dists/normal/mgf/test/test.mgf.js    | 26 ++---
 .../base/dists/normal/mgf/test/test.native.js | 26 ++---
 .../stats/base/dists/normal/mode/test/test.js | 20 ++--
 .../dists/normal/mode/test/test.native.js     | 20 ++--
 .../dists/normal/pdf/test/test.factory.js     | 40 ++++----
 .../stats/base/dists/normal/pdf/test/test.js  |  2 +-
 .../base/dists/normal/pdf/test/test.native.js | 42 ++++-----
 .../base/dists/normal/pdf/test/test.pdf.js    | 42 ++++-----
 .../normal/quantile/test/test.factory.js      | 38 ++++----
 .../base/dists/normal/quantile/test/test.js   |  2 +-
 .../dists/normal/quantile/test/test.native.js | 32 +++----
 .../normal/quantile/test/test.quantile.js     | 32 +++----
 .../base/dists/normal/skewness/test/test.js   | 20 ++--
 .../dists/normal/skewness/test/test.native.js | 20 ++--
 .../base/dists/normal/stdev/test/test.js      | 18 ++--
 .../dists/normal/stdev/test/test.native.js    | 20 ++--
 .../stats/base/dists/normal/test/test.js      |  2 +-
 .../base/dists/normal/variance/test/test.js   | 20 ++--
 .../dists/normal/variance/test/test.native.js | 20 ++--
 .../dists/pareto-type1/cdf/test/test.cdf.js   | 48 +++++-----
 .../pareto-type1/cdf/test/test.factory.js     | 60 ++++++------
 .../base/dists/pareto-type1/cdf/test/test.js  |  2 +-
 .../pareto-type1/cdf/test/test.native.js      | 48 +++++-----
 .../dists/pareto-type1/entropy/test/test.js   | 26 ++---
 .../pareto-type1/entropy/test/test.native.js  | 26 ++---
 .../dists/pareto-type1/kurtosis/test/test.js  | 32 +++----
 .../pareto-type1/kurtosis/test/test.native.js | 32 +++----
 .../pareto-type1/logcdf/test/test.factory.js  | 60 ++++++------
 .../dists/pareto-type1/logcdf/test/test.js    |  2 +-
 .../pareto-type1/logcdf/test/test.logcdf.js   | 48 +++++-----
 .../pareto-type1/logcdf/test/test.native.js   | 48 +++++-----
 .../pareto-type1/logpdf/test/test.factory.js  | 52 +++++-----
 .../dists/pareto-type1/logpdf/test/test.js    |  2 +-
 .../pareto-type1/logpdf/test/test.logpdf.js   | 46 ++++-----
 .../pareto-type1/logpdf/test/test.native.js   | 46 ++++-----
 .../base/dists/pareto-type1/mean/test/test.js | 32 +++----
 .../pareto-type1/mean/test/test.native.js     | 38 ++++----
 .../dists/pareto-type1/median/test/test.js    | 26 ++---
 .../base/dists/pareto-type1/mode/test/test.js | 26 ++---
 .../pareto-type1/mode/test/test.native.js     | 26 ++---
 .../pareto-type1/pdf/test/test.factory.js     | 52 +++++-----
 .../base/dists/pareto-type1/pdf/test/test.js  |  2 +-
 .../pareto-type1/pdf/test/test.native.js      | 46 ++++-----
 .../dists/pareto-type1/pdf/test/test.pdf.js   | 46 ++++-----
 .../quantile/test/test.factory.js             | 48 +++++-----
 .../dists/pareto-type1/quantile/test/test.js  |  2 +-
 .../pareto-type1/quantile/test/test.native.js | 44 ++++-----
 .../quantile/test/test.quantile.js            | 44 ++++-----
 .../dists/pareto-type1/skewness/test/test.js  | 32 +++----
 .../pareto-type1/skewness/test/test.native.js | 32 +++----
 .../dists/pareto-type1/stdev/test/test.js     | 32 +++----
 .../pareto-type1/stdev/test/test.native.js    | 32 +++----
 .../base/dists/pareto-type1/test/test.js      |  2 +-
 .../dists/pareto-type1/variance/test/test.js  | 32 +++----
 .../pareto-type1/variance/test/test.native.js | 32 +++----
 .../base/dists/planck/cdf/test/test.cdf.js    | 20 ++--
 .../dists/planck/cdf/test/test.factory.js     | 28 +++---
 .../stats/base/dists/planck/cdf/test/test.js  |  2 +-
 .../base/dists/planck/cdf/test/test.native.js | 20 ++--
 .../base/dists/planck/entropy/test/test.js    |  8 +-
 .../dists/planck/entropy/test/test.native.js  |  8 +-
 .../base/dists/planck/kurtosis/test/test.js   |  8 +-
 .../dists/planck/kurtosis/test/test.native.js |  8 +-
 .../dists/planck/logcdf/test/test.factory.js  | 28 +++---
 .../base/dists/planck/logcdf/test/test.js     |  2 +-
 .../dists/planck/logcdf/test/test.logcdf.js   | 20 ++--
 .../dists/planck/logcdf/test/test.native.js   | 20 ++--
 .../dists/planck/logpmf/test/test.factory.js  | 34 +++----
 .../base/dists/planck/logpmf/test/test.js     |  2 +-
 .../dists/planck/logpmf/test/test.logpmf.js   | 22 ++---
 .../dists/planck/logpmf/test/test.native.js   | 22 ++---
 .../stats/base/dists/planck/mean/test/test.js |  8 +-
 .../dists/planck/mean/test/test.native.js     |  8 +-
 .../base/dists/planck/median/test/test.js     |  8 +-
 .../dists/planck/median/test/test.native.js   |  8 +-
 .../dists/planck/mgf/test/test.factory.js     | 18 ++--
 .../stats/base/dists/planck/mgf/test/test.js  |  2 +-
 .../base/dists/planck/mgf/test/test.mgf.js    | 12 +--
 .../base/dists/planck/mgf/test/test.native.js | 12 +--
 .../stats/base/dists/planck/mode/test/test.js |  8 +-
 .../dists/planck/mode/test/test.native.js     |  8 +-
 .../dists/planck/pmf/test/test.factory.js     | 30 +++---
 .../stats/base/dists/planck/pmf/test/test.js  |  2 +-
 .../base/dists/planck/pmf/test/test.native.js | 26 ++---
 .../base/dists/planck/pmf/test/test.pmf.js    | 26 ++---
 .../planck/quantile/test/test.factory.js      | 24 ++---
 .../base/dists/planck/quantile/test/test.js   |  2 +-
 .../dists/planck/quantile/test/test.native.js | 20 ++--
 .../planck/quantile/test/test.quantile.js     | 20 ++--
 .../base/dists/planck/skewness/test/test.js   |  8 +-
 .../dists/planck/skewness/test/test.native.js |  8 +-
 .../base/dists/planck/stdev/test/test.js      |  8 +-
 .../dists/planck/stdev/test/test.native.js    |  8 +-
 .../base/dists/planck/variance/test/test.js   |  8 +-
 .../dists/planck/variance/test/test.native.js |  8 +-
 .../base/dists/poisson/cdf/test/test.cdf.js   | 32 +++----
 .../dists/poisson/cdf/test/test.factory.js    | 32 +++----
 .../stats/base/dists/poisson/cdf/test/test.js |  2 +-
 .../dists/poisson/cdf/test/test.native.js     | 34 +++----
 .../base/dists/poisson/entropy/test/test.js   | 10 +-
 .../base/dists/poisson/kurtosis/test/test.js  | 10 +-
 .../poisson/kurtosis/test/test.native.js      | 10 +-
 .../dists/poisson/logpmf/test/test.factory.js | 38 ++++----
 .../base/dists/poisson/logpmf/test/test.js    |  2 +-
 .../dists/poisson/logpmf/test/test.logpmf.js  | 36 +++----
 .../dists/poisson/logpmf/test/test.native.js  | 36 +++----
 .../base/dists/poisson/mean/test/test.js      |  8 +-
 .../dists/poisson/mean/test/test.native.js    |  8 +-
 .../base/dists/poisson/median/test/test.js    |  8 +-
 .../dists/poisson/median/test/test.native.js  |  8 +-
 .../dists/poisson/mgf/test/test.factory.js    | 20 ++--
 .../stats/base/dists/poisson/mgf/test/test.js |  2 +-
 .../base/dists/poisson/mgf/test/test.mgf.js   | 18 ++--
 .../dists/poisson/mgf/test/test.native.js     | 18 ++--
 .../base/dists/poisson/mode/test/test.js      |  8 +-
 .../dists/poisson/mode/test/test.native.js    |  8 +-
 .../dists/poisson/pmf/test/test.factory.js    | 38 ++++----
 .../stats/base/dists/poisson/pmf/test/test.js |  2 +-
 .../base/dists/poisson/pmf/test/test.pmf.js   | 36 +++----
 .../poisson/quantile/test/test.factory.js     | 28 +++---
 .../base/dists/poisson/quantile/test/test.js  |  2 +-
 .../poisson/quantile/test/test.quantile.js    | 34 +++----
 .../base/dists/poisson/skewness/test/test.js  | 10 +-
 .../poisson/skewness/test/test.native.js      | 10 +-
 .../base/dists/poisson/stdev/test/test.js     |  8 +-
 .../dists/poisson/stdev/test/test.native.js   |  8 +-
 .../stats/base/dists/poisson/test/test.js     |  2 +-
 .../base/dists/poisson/variance/test/test.js  |  8 +-
 .../poisson/variance/test/test.native.js      |  8 +-
 .../base/dists/rayleigh/cdf/test/test.cdf.js  | 24 ++---
 .../dists/rayleigh/cdf/test/test.factory.js   | 28 +++---
 .../base/dists/rayleigh/cdf/test/test.js      |  2 +-
 .../dists/rayleigh/cdf/test/test.native.js    | 24 ++---
 .../base/dists/rayleigh/entropy/test/test.js  | 10 +-
 .../rayleigh/entropy/test/test.native.js      | 10 +-
 .../base/dists/rayleigh/kurtosis/test/test.js |  8 +-
 .../rayleigh/kurtosis/test/test.native.js     |  8 +-
 .../rayleigh/logcdf/test/test.factory.js      | 28 +++---
 .../base/dists/rayleigh/logcdf/test/test.js   |  2 +-
 .../dists/rayleigh/logcdf/test/test.logcdf.js | 24 ++---
 .../dists/rayleigh/logcdf/test/test.native.js | 24 ++---
 .../rayleigh/logpdf/test/test.factory.js      | 30 +++---
 .../base/dists/rayleigh/logpdf/test/test.js   |  2 +-
 .../dists/rayleigh/logpdf/test/test.logpdf.js | 30 +++---
 .../dists/rayleigh/logpdf/test/test.native.js | 30 +++---
 .../base/dists/rayleigh/mean/test/test.js     |  8 +-
 .../dists/rayleigh/mean/test/test.native.js   |  8 +-
 .../base/dists/rayleigh/median/test/test.js   |  8 +-
 .../dists/rayleigh/median/test/test.native.js |  8 +-
 .../dists/rayleigh/mgf/test/test.factory.js   | 12 +--
 .../base/dists/rayleigh/mgf/test/test.js      |  2 +-
 .../base/dists/rayleigh/mgf/test/test.mgf.js  |  8 +-
 .../dists/rayleigh/mgf/test/test.native.js    |  8 +-
 .../base/dists/rayleigh/mode/test/test.js     |  8 +-
 .../dists/rayleigh/mode/test/test.native.js   |  8 +-
 .../dists/rayleigh/pdf/test/test.factory.js   | 30 +++---
 .../base/dists/rayleigh/pdf/test/test.js      |  2 +-
 .../dists/rayleigh/pdf/test/test.native.js    | 30 +++---
 .../base/dists/rayleigh/pdf/test/test.pdf.js  | 30 +++---
 .../rayleigh/quantile/test/test.factory.js    | 30 +++---
 .../base/dists/rayleigh/quantile/test/test.js |  2 +-
 .../rayleigh/quantile/test/test.native.js     | 28 +++---
 .../rayleigh/quantile/test/test.quantile.js   | 28 +++---
 .../base/dists/rayleigh/skewness/test/test.js |  8 +-
 .../rayleigh/skewness/test/test.native.js     |  8 +-
 .../base/dists/rayleigh/stdev/test/test.js    |  8 +-
 .../dists/rayleigh/stdev/test/test.native.js  |  8 +-
 .../stats/base/dists/rayleigh/test/test.js    |  2 +-
 .../base/dists/rayleigh/variance/test/test.js |  8 +-
 .../rayleigh/variance/test/test.native.js     |  8 +-
 .../base/dists/signrank/cdf/test/test.cdf.js  | 18 ++--
 .../dists/signrank/cdf/test/test.factory.js   | 20 ++--
 .../base/dists/signrank/cdf/test/test.js      |  2 +-
 .../dists/signrank/pdf/test/test.factory.js   | 26 ++---
 .../base/dists/signrank/pdf/test/test.js      |  2 +-
 .../dists/signrank/pdf/test/test.native.js    | 22 ++---
 .../base/dists/signrank/pdf/test/test.pdf.js  | 24 ++---
 .../signrank/quantile/test/test.factory.js    | 22 ++---
 .../base/dists/signrank/quantile/test/test.js |  2 +-
 .../signrank/quantile/test/test.quantile.js   | 20 ++--
 .../stats/base/dists/signrank/test/test.js    |  2 +-
 .../studentized-range/cdf/test/test.cdf.js    | 14 +--
 .../cdf/test/test.factory.js                  | 32 +++----
 .../dists/studentized-range/cdf/test/test.js  |  2 +-
 .../quantile/test/test.factory.js             | 30 +++---
 .../studentized-range/quantile/test/test.js   |  2 +-
 .../quantile/test/test.quantile.js            | 10 +-
 .../base/dists/studentized-range/test/test.js |  2 +-
 .../stats/base/dists/t/cdf/test/test.cdf.js   | 24 ++---
 .../base/dists/t/cdf/test/test.factory.js     | 30 +++---
 .../stats/base/dists/t/cdf/test/test.js       |  2 +-
 .../stats/base/dists/t/entropy/test/test.js   | 10 +-
 .../base/dists/t/entropy/test/test.native.js  | 10 +-
 .../stats/base/dists/t/kurtosis/test/test.js  | 20 ++--
 .../base/dists/t/kurtosis/test/test.native.js | 20 ++--
 .../base/dists/t/logcdf/test/test.factory.js  | 30 +++---
 .../stats/base/dists/t/logcdf/test/test.js    |  2 +-
 .../base/dists/t/logcdf/test/test.logcdf.js   | 30 +++---
 .../base/dists/t/logpdf/test/test.factory.js  | 32 +++----
 .../stats/base/dists/t/logpdf/test/test.js    |  2 +-
 .../base/dists/t/logpdf/test/test.logpdf.js   | 32 +++----
 .../base/dists/t/logpdf/test/test.native.js   | 32 +++----
 .../stats/base/dists/t/mean/test/test.js      |  8 +-
 .../base/dists/t/mean/test/test.native.js     | 12 +--
 .../stats/base/dists/t/median/test/test.js    |  8 +-
 .../base/dists/t/median/test/test.native.js   |  8 +-
 .../stats/base/dists/t/mode/test/test.js      |  8 +-
 .../base/dists/t/mode/test/test.native.js     |  8 +-
 .../base/dists/t/pdf/test/test.factory.js     | 32 +++----
 .../stats/base/dists/t/pdf/test/test.js       |  2 +-
 .../base/dists/t/pdf/test/test.native.js      | 32 +++----
 .../stats/base/dists/t/pdf/test/test.pdf.js   | 32 +++----
 .../dists/t/quantile/test/test.factory.js     | 20 ++--
 .../stats/base/dists/t/quantile/test/test.js  |  2 +-
 .../dists/t/quantile/test/test.quantile.js    | 20 ++--
 .../stats/base/dists/t/skewness/test/test.js  | 16 ++--
 .../base/dists/t/skewness/test/test.native.js | 16 ++--
 .../stats/base/dists/t/stdev/test/test.js     | 14 +--
 .../base/dists/t/stdev/test/test.native.js    | 14 +--
 .../@stdlib/stats/base/dists/t/test/test.js   |  2 +-
 .../stats/base/dists/t/variance/test/test.js  | 14 +--
 .../base/dists/t/variance/test/test.native.js | 16 ++--
 .../@stdlib/stats/base/dists/test/test.js     |  2 +-
 .../dists/triangular/cdf/test/test.cdf.js     | 26 ++---
 .../dists/triangular/cdf/test/test.factory.js | 46 ++++-----
 .../base/dists/triangular/cdf/test/test.js    |  2 +-
 .../dists/triangular/cdf/test/test.native.js  | 26 ++---
 .../dists/triangular/entropy/test/test.js     | 16 ++--
 .../triangular/entropy/test/test.native.js    | 16 ++--
 .../dists/triangular/kurtosis/test/test.js    | 16 ++--
 .../triangular/kurtosis/test/test.native.js   | 16 ++--
 .../triangular/logcdf/test/test.factory.js    | 46 ++++-----
 .../base/dists/triangular/logcdf/test/test.js |  2 +-
 .../triangular/logcdf/test/test.logcdf.js     | 26 ++---
 .../triangular/logcdf/test/test.native.js     | 26 ++---
 .../triangular/logpdf/test/test.factory.js    | 56 +++++------
 .../base/dists/triangular/logpdf/test/test.js |  2 +-
 .../triangular/logpdf/test/test.logpdf.js     | 38 ++++----
 .../triangular/logpdf/test/test.native.js     | 40 ++++----
 .../base/dists/triangular/mean/test/test.js   | 16 ++--
 .../dists/triangular/mean/test/test.native.js | 16 ++--
 .../base/dists/triangular/median/test/test.js | 18 ++--
 .../triangular/median/test/test.native.js     | 18 ++--
 .../dists/triangular/mgf/test/test.factory.js | 54 +++++------
 .../base/dists/triangular/mgf/test/test.js    |  2 +-
 .../dists/triangular/mgf/test/test.mgf.js     | 38 ++++----
 .../dists/triangular/mgf/test/test.native.js  | 38 ++++----
 .../base/dists/triangular/mode/test/test.js   | 16 ++--
 .../dists/triangular/mode/test/test.native.js | 16 ++--
 .../dists/triangular/pdf/test/test.factory.js | 56 +++++------
 .../base/dists/triangular/pdf/test/test.js    |  2 +-
 .../dists/triangular/pdf/test/test.native.js  | 40 ++++----
 .../dists/triangular/pdf/test/test.pdf.js     | 40 ++++----
 .../triangular/quantile/test/test.factory.js  | 38 ++++----
 .../dists/triangular/quantile/test/test.js    |  2 +-
 .../triangular/quantile/test/test.native.js   | 30 +++---
 .../triangular/quantile/test/test.quantile.js | 30 +++---
 .../dists/triangular/skewness/test/test.js    | 16 ++--
 .../triangular/skewness/test/test.native.js   | 16 ++--
 .../base/dists/triangular/stdev/test/test.js  | 16 ++--
 .../triangular/stdev/test/test.native.js      | 16 ++--
 .../stats/base/dists/triangular/test/test.js  |  2 +-
 .../dists/triangular/variance/test/test.js    | 16 ++--
 .../triangular/variance/test/test.native.js   | 16 ++--
 .../dists/truncated-normal/pdf/test/test.js   |  2 +-
 .../base/dists/truncated-normal/test/test.js  |  2 +-
 .../base/dists/uniform/cdf/test/test.cdf.js   | 24 ++---
 .../dists/uniform/cdf/test/test.factory.js    | 34 +++----
 .../stats/base/dists/uniform/cdf/test/test.js |  2 +-
 .../dists/uniform/cdf/test/test.native.js     | 24 ++---
 .../base/dists/uniform/entropy/test/test.js   | 14 +--
 .../dists/uniform/entropy/test/test.native.js | 14 +--
 .../base/dists/uniform/kurtosis/test/test.js  | 14 +--
 .../uniform/kurtosis/test/test.native.js      | 14 +--
 .../dists/uniform/logcdf/test/test.factory.js | 34 +++----
 .../base/dists/uniform/logcdf/test/test.js    |  2 +-
 .../dists/uniform/logcdf/test/test.logcdf.js  | 24 ++---
 .../dists/uniform/logcdf/test/test.native.js  | 24 ++---
 .../dists/uniform/logpdf/test/test.factory.js | 34 +++----
 .../base/dists/uniform/logpdf/test/test.js    |  2 +-
 .../dists/uniform/logpdf/test/test.logpdf.js  | 24 ++---
 .../dists/uniform/logpdf/test/test.native.js  | 24 ++---
 .../base/dists/uniform/mean/test/test.js      | 14 +--
 .../dists/uniform/mean/test/test.native.js    | 14 +--
 .../base/dists/uniform/median/test/test.js    | 14 +--
 .../dists/uniform/median/test/test.native.js  | 14 +--
 .../dists/uniform/mgf/test/test.factory.js    | 34 +++----
 .../stats/base/dists/uniform/mgf/test/test.js |  2 +-
 .../base/dists/uniform/mgf/test/test.mgf.js   | 26 ++---
 .../dists/uniform/mgf/test/test.native.js     | 26 ++---
 .../dists/uniform/pdf/test/test.factory.js    | 34 +++----
 .../stats/base/dists/uniform/pdf/test/test.js |  2 +-
 .../dists/uniform/pdf/test/test.native.js     | 24 ++---
 .../base/dists/uniform/pdf/test/test.pdf.js   | 24 ++---
 .../uniform/quantile/test/test.factory.js     | 30 +++---
 .../base/dists/uniform/quantile/test/test.js  |  2 +-
 .../uniform/quantile/test/test.native.js      | 24 ++---
 .../uniform/quantile/test/test.quantile.js    | 24 ++---
 .../base/dists/uniform/skewness/test/test.js  | 14 +--
 .../uniform/skewness/test/test.native.js      | 18 ++--
 .../base/dists/uniform/stdev/test/test.js     | 12 +--
 .../dists/uniform/stdev/test/test.native.js   | 12 +--
 .../stats/base/dists/uniform/test/test.js     |  2 +-
 .../base/dists/uniform/variance/test/test.js  | 14 +--
 .../uniform/variance/test/test.native.js      | 14 +--
 .../base/dists/weibull/cdf/test/test.cdf.js   | 44 ++++-----
 .../dists/weibull/cdf/test/test.factory.js    | 54 +++++------
 .../stats/base/dists/weibull/cdf/test/test.js |  2 +-
 .../dists/weibull/cdf/test/test.native.js     | 44 ++++-----
 .../base/dists/weibull/entropy/test/test.js   | 26 ++---
 .../dists/weibull/entropy/test/test.native.js | 26 ++---
 .../base/dists/weibull/kurtosis/test/test.js  | 26 ++---
 .../weibull/kurtosis/test/test.native.js      | 26 ++---
 .../dists/weibull/logcdf/test/test.factory.js | 54 +++++------
 .../base/dists/weibull/logcdf/test/test.js    |  2 +-
 .../dists/weibull/logcdf/test/test.logcdf.js  | 44 ++++-----
 .../dists/weibull/logcdf/test/test.native.js  | 44 ++++-----
 .../dists/weibull/logpdf/test/test.factory.js | 58 ++++++------
 .../base/dists/weibull/logpdf/test/test.js    |  2 +-
 .../dists/weibull/logpdf/test/test.logpdf.js  | 48 +++++-----
 .../dists/weibull/logpdf/test/test.native.js  | 48 +++++-----
 .../base/dists/weibull/mean/test/test.js      | 26 ++---
 .../dists/weibull/mean/test/test.native.js    | 26 ++---
 .../base/dists/weibull/median/test/test.js    | 26 ++---
 .../dists/weibull/median/test/test.native.js  | 26 ++---
 .../dists/weibull/mgf/test/test.factory.js    | 40 ++++----
 .../stats/base/dists/weibull/mgf/test/test.js |  2 +-
 .../base/dists/weibull/mgf/test/test.mgf.js   | 34 +++----
 .../dists/weibull/mgf/test/test.native.js     | 34 +++----
 .../base/dists/weibull/mode/test/test.js      | 30 +++---
 .../dists/weibull/mode/test/test.native.js    | 30 +++---
 .../dists/weibull/pdf/test/test.factory.js    | 58 ++++++------
 .../stats/base/dists/weibull/pdf/test/test.js |  2 +-
 .../dists/weibull/pdf/test/test.native.js     | 48 +++++-----
 .../base/dists/weibull/pdf/test/test.pdf.js   | 48 +++++-----
 .../weibull/quantile/test/test.factory.js     | 54 +++++------
 .../base/dists/weibull/quantile/test/test.js  |  2 +-
 .../weibull/quantile/test/test.native.js      | 24 ++---
 .../weibull/quantile/test/test.quantile.js    | 44 ++++-----
 .../base/dists/weibull/skewness/test/test.js  | 26 ++---
 .../weibull/skewness/test/test.native.js      | 26 ++---
 .../base/dists/weibull/stdev/test/test.js     | 26 ++---
 .../dists/weibull/stdev/test/test.native.js   | 26 ++---
 .../stats/base/dists/weibull/test/test.js     |  2 +-
 .../base/dists/weibull/variance/test/test.js  | 26 ++---
 .../weibull/variance/test/test.native.js      | 26 ++---
 1295 files changed, 14640 insertions(+), 14640 deletions(-)

diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.factory.js
index 4b9de324d805..bc2ac4671ac8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a `a >= b`, the created function always returns `NaN`', funct
 	cdf = factory( 2.0, 1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -1.0, -2.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the created function evaluates the cdf for `x` given a small range `b - a
 		cdf = factory( a[i], b[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -178,7 +178,7 @@ tape( 'the created function evaluates the cdf for `x` given a medium range `b -
 		cdf = factory( a[i], b[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -207,7 +207,7 @@ tape( 'the created function evaluates the cdf for `x` given a large range `b - a
 		cdf = factory( a[i], b[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.main.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.main.js
index 2a71a8bf3f07..ee6ab1c48aaa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.main.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.main.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = cdf( 2.0, -1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -101,7 +101,7 @@ tape( 'the function evaluates the cdf for `x` given a small range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -128,7 +128,7 @@ tape( 'the function evaluates the cdf for `x` given a medium range `b - a`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -155,7 +155,7 @@ tape( 'the function evaluates the cdf for `x` given a large range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.native.js
index 60915dc72552..d74177ae6b69 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = cdf( 2.0, -1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function evaluates the cdf for `x` given a small range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -137,7 +137,7 @@ tape( 'the function evaluates the cdf for `x` given a medium range `b - a`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the cdf for `x` given a large range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.js
index 4bfded15bfb9..d549c4a3ef08 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = entropy( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function returns the differential entropy of an arcsine distribution'
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 12.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.native.js
index becabea8b26f..f30598243354 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = entropy( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns the differential entropy of an arcsine distribution'
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 12.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.js
index 0f673c39f28f..4ff4961ce9e9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.js
@@ -38,10 +38,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -50,16 +50,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = kurtosis( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns `-3/2` as the excess kurtosis of an arcsine distribu
 		a = ( randu()*10.0 );
 		b = ( randu()*10.0 ) + a;
 		v = kurtosis( a, b );
-		t.equal( v, -3/2, 'returns -3/2' );
+		t.strictEqual( v, -3/2, 'returns -3/2' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.native.js
index d2358f6bb1be..9c8906de5226 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.native.js
@@ -47,10 +47,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -59,16 +59,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = kurtosis( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns `-3/2` as the excess kurtosis of an arcsine distribu
 		a = ( randu() *10.0 );
 		b = ( randu()*10.0 ) + a;
 		v = kurtosis( a, b );
-		t.equal( v, -3/2, 'returns -3/2' );
+		t.strictEqual( v, -3/2, 'returns -3/2' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.factory.js
index 40257e70a274..e71b30a9d75c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a `a >= b`, the created function always returns `NaN`', funct
 	logcdf = factory( 2.0, 1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( -1.0, -2.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the created function evaluates the logcdf for `x` given a small range `b
 		logcdf = factory( a[i], b[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -178,7 +178,7 @@ tape( 'the created function evaluates the logcdf for `x` given a medium range `b
 		logcdf = factory( a[i], b[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -207,7 +207,7 @@ tape( 'the created function evaluates the logcdf for `x` given a large range `b
 		logcdf = factory( a[i], b[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.logcdf.js
index f0d9917b5bcf..f79dfbdbed4a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `-infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logcdf( 2.0, -1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -101,7 +101,7 @@ tape( 'the function evaluates the logcdf for `x` given a small range `b - a`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -128,7 +128,7 @@ tape( 'the function evaluates the logcdf for `x` given a medium range `b - a`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -155,7 +155,7 @@ tape( 'the function evaluates the logcdf for `x` given a large range `b - a`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.factory.js
index 1db9d3159de7..c9e469f5833d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `a` and `b`, the function returns a function which re
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `a` and `b`, the function returns a function which re
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -150,7 +150,7 @@ tape( 'the created function evaluates the logpdf for `x` given small range `b -
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the created function evaluates the logpdf for `x` given a medium range `b
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -212,7 +212,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large range `b
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.logpdf.js
index 95dd2159f260..311c8740fedb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logpdf( 2.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function evaluates the logpdf for `x` given a small range `b - a`', f
 		y = logpdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -131,7 +131,7 @@ tape( 'the function evaluates the logpdf for `x` given a medium range `b - a`',
 		y = logpdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -160,7 +160,7 @@ tape( 'the function evaluates the logpdf for `x` given a large range `b - a`', f
 		y = logpdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.native.js
index 48da383bbeef..512cc0556990 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = logpdf( 2.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -111,7 +111,7 @@ tape( 'the function evaluates the logpdf for `x` given a small range `b - a`', o
 		y = logpdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -140,7 +140,7 @@ tape( 'the function evaluates the logpdf for `x` given a medium range `b - a`',
 		y = logpdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -169,7 +169,7 @@ tape( 'the function evaluates the logpdf for `x` given a large range `b - a`', o
 		y = logpdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.js
index 52e6a6c81d97..87de9ea87aa6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function returns the mean of an arcsine distribution', function test(
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.native.js
index d6bd943fd043..879f66ea3b30 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mean( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns the mean of an arcsine distribution', opts, function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.js
index c3c832fa8cb2..7437551bf4b5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -54,16 +54,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = median( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'the function returns the median of an arcsine distribution', function tes
 	b = data.b;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( a[i], b[i] );
-		t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.native.js
index d48fed990b58..b40f70994ed3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -63,16 +63,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = median( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns the median of an arcsine distribution', opts, functi
 	b = data.b;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( a[i], b[i] );
-		t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.js
index 83491462682e..650bf2f8281f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -54,16 +54,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mode( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'the function returns the mode of an arcsine distribution', function test(
 	b = data.b;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( a[i], b[i] );
-		t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.native.js
index 4cf6ad8b1565..d0fad836fc1a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -63,16 +63,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mode( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns the mode of an arcsine distribution', opts, function
 	b = data.b;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( a[i], b[i] );
-		t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.factory.js
index 82e4f5f50a7f..dcc3e007a7c4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the created function evaluates the pdf for `x` given small range `b - a`'
 		pdf = factory( a[i], b[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -178,7 +178,7 @@ tape( 'the created function evaluates the pdf for `x` given a medium range `b -
 		pdf = factory( a[i], b[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -207,7 +207,7 @@ tape( 'the created function evaluates the pdf for `x` given a large range `b - a
 		pdf = factory( a[i], b[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.native.js
index 500a23565657..78a52e14b87d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = pdf( 2.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function evaluates the pdf for `x` given a small range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -137,7 +137,7 @@ tape( 'the function evaluates the pdf for `x` given a medium range `b - a`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the pdf for `x` given a large range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.pdf.js
index 23edf347b056..dfa8e3e1900b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pdf( 2.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -101,7 +101,7 @@ tape( 'the function evaluates the pdf for `x` given a small range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -128,7 +128,7 @@ tape( 'the function evaluates the pdf for `x` given a medium range `b - a`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -155,7 +155,7 @@ tape( 'the function evaluates the pdf for `x` given a large range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.factory.js
index 1a72657548ca..317bdf42ab72 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,18 +98,18 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	quantile = factory( 1.0, 0.5 );
 
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the created function evaluates the quantile for `p` given a small range `
 		quantile = factory( a[i], b[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -162,7 +162,7 @@ tape( 'the created function evaluates the quantile for `p` given a medium range
 		quantile = factory( a[i], b[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -191,7 +191,7 @@ tape( 'the created function evaluates the quantile for `p` given a large range `
 		quantile = factory( a[i], b[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.native.js
index f200ce719196..788cf2f8b450 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.native.js
@@ -51,19 +51,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -71,16 +71,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -2.0, -3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function evaluates the quantile for `p` given a small range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -129,7 +129,7 @@ tape( 'the function evaluates the quantile for `p` given a medium range `b - a`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -156,7 +156,7 @@ tape( 'the function evaluates the quantile for `p` given a large range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.quantile.js
index d78579ad7d29..f55f148e491a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,16 +66,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -2.0, -3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function evaluates the quantile for `p` given a small range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -124,7 +124,7 @@ tape( 'the function evaluates the quantile for `p` given a medium range `b - a`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -151,7 +151,7 @@ tape( 'the function evaluates the quantile for `p` given a large range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.js
index 18234243a06c..e6f6072504d1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.js
@@ -38,10 +38,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -50,16 +50,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns `0.0` as the skewness of an arcsine distribution ',
 		a = ( randu()*10.0 );
 		b = ( randu()*10.0 ) + a;
 		v = skewness( a, b );
-		t.equal( v, 0.0, 'returns 0.0' );
+		t.strictEqual( v, 0.0, 'returns 0.0' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.native.js
index 6c188bb2ed4c..b2bed942cd61 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.native.js
@@ -47,10 +47,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -59,16 +59,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns `0.0` as the skewness of an arcsine distribution ',
 		a = ( randu()*10.0 );
 		b = ( randu()*10.0 ) + a;
 		v = skewness( a, b );
-		t.equal( v, 0.0, 'returns 0.0' );
+		t.strictEqual( v, 0.0, 'returns 0.0' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.js
index b25bce983ca0..e8c408891c5a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = stdev( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function returns the standard deviation of an arcsine distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.native.js
index d4571519c9fb..03cf30f2a0b4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = stdev( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns the standard deviation of an arcsine distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/test/test.js
index 4b0a87d848ac..b34cc8e329db 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains arcsine distribution functions', function test( t ) {
 	var keys = objectKeys( arcsine );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.js
index d0a7b181d611..ba1a7c19d79c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = variance( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function returns the variance of an arcsine distribution', function t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.native.js
index 5a002edc7219..a0566095d1c6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = variance( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns the variance of an arcsine distribution', opts, func
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.cdf.js
index 723f3aeb2f4f..e458dd6a4713 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.cdf.js
@@ -43,27 +43,27 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -4.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -0.5, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -72,16 +72,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = cdf( 3.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 3.0, -0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 3.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function evaluates the cdf for `x` given small parameter `p`', functi
 	p = smallP.p;
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], p[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -115,7 +115,7 @@ tape( 'the function evaluates the cdf for `x` given large parameter `p`', functi
 	p = largeP.p;
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], p[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.factory.js
index 5ea2080a0827..7a5012cd9acb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.5 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a valid `p`, the function returns a function which returns `1
 
 	cdf = factory( 0.5 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -81,16 +81,16 @@ tape( 'if provided a valid `p`, the function returns a function which returns `0
 
 	cdf = factory( 0.5 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -20.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -2.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -101,21 +101,21 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the created fun
 
 	cdf = factory( -1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.5 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'the created function evaluates the cdf for `x` given small parameter `p`'
 		cdf = factory( p[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -164,7 +164,7 @@ tape( 'the created function evaluates the cdf for `x` given large parameter `p`'
 		cdf = factory( p[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.native.js
index dac745710587..8269c0e5d2ab 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.native.js
@@ -52,27 +52,27 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -4.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -0.5, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -81,16 +81,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = cdf( 3.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 3.0, -0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 3.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -107,7 +107,7 @@ tape( 'the function evaluates the cdf for `x` given small parameter `p`', opts,
 	p = smallP.p;
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], p[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function evaluates the cdf for `x` given large parameter `p`', opts,
 	p = largeP.p;
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], p[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.js
index 78f4f559379e..d197ba92b1d9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -62,16 +62,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns the entropy of a Bernoulli distribution', function t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.native.js
index effb08ed3fa2..1fc927580137 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -71,16 +71,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns the entropy of a Bernoulli distribution', opts, func
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.js
index 1ef394f813cd..d5b3c597bbcb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -62,16 +62,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns the excess kurtosis of a Bernoulli distribution', fu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.native.js
index 1c186f72a7b1..9c3ebe3ca5d2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -71,16 +71,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns the excess kurtosis of a Bernoulli distribution', op
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.js
index d94eea2226e2..8daa3d726c4e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the mean of a Bernoulli distribution', function test
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.native.js
index 4c67f5afd0c9..a5cab703fa87 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the mean of a Bernoulli distribution', opts, functio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.js
index 87e82ef36cea..d51de3e856f9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -50,16 +50,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = median( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns the median of a Bernoulli distribution', function te
 	p = data.p;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( p[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.native.js
index 8a353b614aa4..6063236afc90 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -59,16 +59,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = median( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns the median of a Bernoulli distribution', opts, funct
 	p = data.p;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( p[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.factory.js
index 12d33ab4b02d..74eddb39d37b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.5 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.5 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -70,27 +70,27 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the created fun
 
 	mgf = factory( -1.0 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 1.5 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( PINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -112,7 +112,7 @@ tape( 'the created function evaluates the mgf for `x` given small parameter `p`'
 		mgf = factory( p[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -139,7 +139,7 @@ tape( 'the created function evaluates the mgf for `x` given large parameter `p`'
 		mgf = factory( p[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.mgf.js
index 7494361e18c6..e4210895705b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.mgf.js
@@ -43,9 +43,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -53,16 +53,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = mgf( 3.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 3.0, -0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 3.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.native.js
index c9060ff85e3a..64fa5893ea76 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.native.js
@@ -54,9 +54,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -64,16 +64,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = mgf( 3.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 3.0, 2.0 );
-	t.equal( isnan( y ), false, 'returns NaN' );
+	t.strictEqual( isnan( y ), false, 'returns NaN' );
 
 	y = mgf( 3.0, -0.5 );
-	t.equal( isnan( y ), false, 'returns NaN' );
+	t.strictEqual( isnan( y ), false, 'returns NaN' );
 
 	y = mgf( 3.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function evaluates the mgf for `x` given small parameter `p`', opts,
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 1.0 * EPS * abs( expected[i] );
@@ -118,7 +118,7 @@ tape( 'the function evaluates the mgf for `x` given large parameter `p`', opts,
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 1.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.js
index ff97761b1333..8aca5c1f7ebe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -50,16 +50,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns the mode of a Bernoulli distribution', function test
 	p = data.p;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( p[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.native.js
index 324f1163dd42..ea1389c3ee44 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -59,16 +59,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns the mode of a Bernoulli distribution', opts, functio
 	p = data.p;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( p[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.factory.js
index bc352c6e02f9..aee3a199cb45 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 0.5 );
-	t.equal( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 0.5 );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	pmf = factory( 1.0 );
 	y = pmf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -80,10 +80,10 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	pmf = factory( 0.4 );
 	y = pmf( -4.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,19 +94,19 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	pmf = factory( 0.4 );
 	y = pmf( 1.3 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 1.4 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 3.2 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 4.8 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.2 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -118,18 +118,18 @@ tape( 'if provided a `p` outside of `[0,1]`, the created function always returns
 	pmf = factory( -1.5 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( 1.2 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -151,7 +151,7 @@ tape( 'the created function evaluates the pmf for `x` given small `p`', function
 		pmf = factory( p[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -178,7 +178,7 @@ tape( 'the function evaluates the pmf for `x` given large `p`', function test( t
 		pmf = factory( p[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.js
index 686bb53fea47..33c536be2daf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pmf` functions', function test( t ) {
-	t.equal( typeof pmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.native.js
index 6a5c874f184d..b96bf0126cff 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.native.js
@@ -51,40 +51,40 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pmf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( PINF, 0.01 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( -20.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -4.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( -1.3, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 2.4, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 0.5, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -93,10 +93,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function al
 	var y;
 
 	y = pmf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function evaluates the pmf for `x` given small parameter `p`', opts,
 	p = smallP.p;
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], p[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+'. p:'+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+'. p:'+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function evaluates the pmf for `x` given large parameter `p`', opts,
 	p = largeP.p;
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], p[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.pmf.js
index 0d01b4560bca..dc35566998e2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.pmf.js
@@ -42,40 +42,40 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = pmf( PINF, 0.01 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = pmf( -20.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -4.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = pmf( -1.3, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 2.4, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 0.5, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -84,10 +84,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function al
 	var y;
 
 	y = pmf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function evaluates the pmf for `x` given small parameter `p`', functi
 	p = smallP.p;
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], p[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+'. p:'+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+'. p:'+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function evaluates the pmf for `x` given large parameter `p`', functi
 	p = largeP.p;
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], p[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.factory.js
index 2d494e43017a..6b04ad449078 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.factory.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -53,11 +53,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -68,10 +68,10 @@ tape( 'if provided a valid success probability `p`, the function returns a funct
 
 	quantile = factory( 0.8 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,18 +83,18 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the created functi
 	quantile = factory( -1.0 );
 
 	y = quantile( 0.4 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.5 );
 
 	y = quantile( 0.4 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the created function evaluates the quantile for `r` given small parameter
 		quantile = factory( p[i] );
 		y = quantile( r[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the created function evaluates the quantile for `r` given large parameter
 		quantile = factory( p[i] );
 		y = quantile( r[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.native.js
index 90df793f2905..8048dad0f11f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.native.js
@@ -53,17 +53,17 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `r` and a valid `p`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 2.2, 0.8 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.2, 0.8 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -71,13 +71,13 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the function retur
 	var y;
 
 	y = quantile( 0.8, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.9, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function evaluates the quantile for `r` given small parameter `p`', o
 	for ( i = 0; i < r.length; i++ ) {
 		y = quantile( r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -122,7 +122,7 @@ tape( 'the function evaluates the quantile for `r` given large parameter `p`', o
 	for ( i = 0; i < r.length; i++ ) {
 		y = quantile( r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.quantile.js
index 2f7fc13d1882..1bf95f29b2b3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.quantile.js
@@ -44,17 +44,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `r` and a valid `p`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 2.2, 0.8 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.2, 0.8 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -62,13 +62,13 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the function alway
 	var y;
 
 	y = quantile( 0.8, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.9, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function evaluates the quantile for `r` given small parameter `p`', f
 	for ( i = 0; i < r.length; i++ ) {
 		y = quantile( r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -113,7 +113,7 @@ tape( 'the function evaluates the quantile for `r` given large parameter `p`', f
 	for ( i = 0; i < r.length; i++ ) {
 		y = quantile( r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.js
index 48c89a21a30f..5beebbbf8494 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -64,16 +64,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = skewness( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -91,7 +91,7 @@ tape( 'the function returns the skewness of a Bernoulli distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.native.js
index 755087d71c90..97fd2b7014e1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -73,16 +73,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = skewness( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns the skewness of a Bernoulli distribution', opts, fun
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.js
index aaa81ed51f47..30ef668f5931 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.js
@@ -44,16 +44,16 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `0` or `1` for `p`, the function returns `0`', function test( t ) {
 	var v = stdev( 1.0 );
-	t.equal( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns 0' );
 
 	v = stdev( 0.0 );
-	t.equal( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -62,16 +62,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns the standard deviation of a Bernoulli distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.native.js
index ff3988691753..b3ed3c065f8b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.native.js
@@ -53,16 +53,16 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `0` or `1` for `p`, the function returns `0`', opts, function test( t ) {
 	var v = stdev( 1.0 );
-	t.equal( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns 0' );
 
 	v = stdev( 0.0 );
-	t.equal( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -71,16 +71,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns the standard deviation of a Bernoulli distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/test/test.js
index e002da8bba4b..f88c6126f87c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Bernoulli distribution functions', function test( t ) {
 	var keys = objectKeys( bernoulli );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.js
index ae2e7dd981f3..4947e5a18a42 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -62,16 +62,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns the variance of a Bernoulli distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.native.js
index 1d7ca66a9e2f..726449e5a5da 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -71,16 +71,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns the variance of a Bernoulli distribution', opts, fun
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.cdf.js
index ea50b94d7ba8..46e7006ffc7a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.cdf.js
@@ -46,42 +46,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `alpha` and `beta`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 100.0, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 10.0, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 1.0, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -100.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -90,25 +90,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -117,25 +117,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha` and `beta`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 140.0 * EPS * abs( expected[ i ] );
@@ -184,7 +184,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
@@ -211,7 +211,7 @@ tape( 'the function evaluates the cdf for `x` given large `beta`', function test
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.factory.js
index 1ead0e6b735f..423abd669f4b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,16 +83,16 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 100.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 10.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -103,19 +103,19 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -100.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -10.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -127,31 +127,31 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	cdf = factory( 1.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -163,31 +163,31 @@ tape( 'if provided a nonpositive `alpha`, the created function always returns `N
 	cdf = factory( 0.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -211,7 +211,7 @@ tape( 'the created function evaluates the cdf for `x` given large `alpha` and `b
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 140.0 * EPS * abs( expected[ i ] );
@@ -240,7 +240,7 @@ tape( 'the created function evaluates the cdf for `x` given large `alpha`', func
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
@@ -269,7 +269,7 @@ tape( 'the created function evaluates the cdf for `x` given large `beta`', funct
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/entropy/test/test.js
index 472fcf7a6c06..bd179f9aff69 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/entropy/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the differential entropy of a beta distribution', fu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/beta/entropy/test/test.native.js
index 9edb0364cf79..404c34c8c4fe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/entropy/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the differential entropy of a beta distribution', op
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/kurtosis/test/test.js
index 4c73817ab04f..9a5e0a60ffc6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/kurtosis/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the excess kurtosis of a beta distribution', functio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/beta/kurtosis/test/test.native.js
index aafc7e9b680f..1c91fce582d8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/kurtosis/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the excess kurtosis of a beta distribution', opts, f
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.factory.js
index 693b15b84e51..1ffd365dc243 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.factory.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -51,23 +51,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 100.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 10.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -98,19 +98,19 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -100.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -10.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -122,31 +122,31 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	logcdf = factory( 1.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -158,31 +158,31 @@ tape( 'if provided a nonpositive `alpha`, the created function always returns `N
 	logcdf = factory( 0.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -1.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, 1.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, PINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NaN );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -203,7 +203,7 @@ tape( 'the created function evaluates the logcdf', function test( t ) {
 		logcdf = factory( alpha, beta );
 		y = logcdf( x );
 		expected = ln( cdf( x, alpha, beta ) );
-		t.equal( y, expected, 'x: '+x+', alpha: '+alpha+', beta: '+beta+', y: '+y+', expected: '+expected );
+		t.strictEqual( y, expected, 'x: '+x+', alpha: '+alpha+', beta: '+beta+', y: '+y+', expected: '+expected );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.logcdf.js
index 9a0f1ca2f967..cf6ec3f3254f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.logcdf.js
@@ -41,42 +41,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 100.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 10.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 1.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `alpha` and `beta`, the function returns `-infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -100.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -1.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -85,25 +85,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -112,25 +112,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function evaluates the logcdf', function test( t ) {
 		beta = ( randu()*100.0 ) + EPS;
 		y = logcdf( x, alpha, beta );
 		expected = ln( cdf( x, alpha, beta ) );
-		t.equal( y, expected, 'x: '+x+', alpha: '+alpha+', beta: '+beta+', y: '+y+', expected: '+expected );
+		t.strictEqual( y, expected, 'x: '+x+', alpha: '+alpha+', beta: '+beta+', y: '+y+', expected: '+expected );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.factory.js
index 64b085a3d44b..c58378158a78 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 1.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,22 +84,22 @@ tape( 'if provided a valid `alpha` and `beta`, the function returns a function w
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -100.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 100.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 1.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -111,26 +111,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -142,26 +142,26 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 	logpdf = factory( -1.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -169,42 +169,42 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 tape( 'if provided `alpha = 1`, the created function returns `ln(beta)` for `x` equal to zero', function test( t ) {
 	var logpdf = factory( 1.0, 2.0 );
 	var y = logpdf( 0.0 );
-	t.equal( y, ln(2.0), 'returns expected value' );
+	t.strictEqual( y, ln(2.0), 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `alpha > 1`, the created function returns `-Infinity` for `x` equal to zero', function test( t ) {
 	var logpdf = factory( 1.5, 2.0 );
 	var y = logpdf( 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `alpha < 1`, the created function returns `+Infinity` for `x` equal to zero', function test( t ) {
 	var logpdf = factory( 0.5, 2.0 );
 	var y = logpdf( 0.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta = 1`, the created function returns `ln(alpha)` for `x` equal to one', function test( t ) {
 	var logpdf = factory( 3.0, 1.0 );
 	var y = logpdf( 1.0 );
-	t.equal( y, ln(3.0), 'returns expected value' );
+	t.strictEqual( y, ln(3.0), 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta > 1`, the created function returns `-Infinity` for `x` equal to one', function test( t ) {
 	var logpdf = factory( 1.5, 2.0 );
 	var y = logpdf( 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta < 1`, the created function returns `+Infinity` for `x` equal to one', function test( t ) {
 	var logpdf = factory( 1.5, 0.5 );
 	var y = logpdf( 1.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -227,7 +227,7 @@ tape( 'the created function evaluates the logpdf for `x` given large `alpha` and
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 45000.0 * EPS * abs( expected[ i ] );
@@ -256,7 +256,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large `alpha`',
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20000.0 * EPS * abs( expected[ i ] );
@@ -285,7 +285,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large `beta`',
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20000.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.logpdf.js
index ac7602b674aa..71d6ff9182a5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.logpdf.js
@@ -47,32 +47,32 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside [0,1] for `x` and a valid `alpha` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 100.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -100.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 1.5, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -0.5, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -81,22 +81,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -105,59 +105,59 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `alpha = 1`, the created function returns `ln(beta)` for `x` equal to zero', function test( t ) {
 	var y = logpdf( 0.0, 1.0, 2.0 );
-	t.equal( y, ln(2.0), 'returns expected value' );
+	t.strictEqual( y, ln(2.0), 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `alpha > 1`, the created function returns `-Infinity` for `x` equal to zero', function test( t ) {
 	var y = logpdf( 0.0, 1.5, 2.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `alpha < 1`, the created function returns `+Infinity` for `x` equal to zero', function test( t ) {
 	var y = logpdf( 0.0, 0.5, 2.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta = 1`, the created function returns `ln(alpha)` for `x` equal to one', function test( t ) {
 	var y = logpdf( 1.0, 3.0, 1.0 );
-	t.equal( y, ln(3.0), 'returns expected value' );
+	t.strictEqual( y, ln(3.0), 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta > 1`, the created function returns `-Infinity` for `x` equal to one', function test( t ) {
 	var y = logpdf( 1.0, 1.5, 2.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta < 1`, the created function returns `+Infinity` for `x` equal to one', function test( t ) {
 	var y = logpdf( 1.0, 1.5, 0.5 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -178,7 +178,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha` and `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 45000.0 * EPS * abs( expected[ i ] );
@@ -205,7 +205,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20000.0 * EPS * abs( expected[ i ] );
@@ -232,7 +232,7 @@ tape( 'the function evaluates the logpdf for `x` given large `beta`', function t
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20000.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.native.js
index 7d5576ce63f5..7274b25895af 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.native.js
@@ -56,32 +56,32 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside [0,1] for `x` and a valid `alpha` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 100.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -100.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 1.5, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -0.5, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -90,22 +90,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -114,59 +114,59 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `alpha = 1`, the created function returns `ln(beta)` for `x` equal to zero', opts, function test( t ) {
 	var y = logpdf( 0.0, 1.0, 2.0 );
-	t.equal( y, ln(2.0), 'returns expected value' );
+	t.strictEqual( y, ln(2.0), 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `alpha > 1`, the created function returns `-Infinity` for `x` equal to zero', opts, function test( t ) {
 	var y = logpdf( 0.0, 1.5, 2.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `alpha < 1`, the created function returns `+Infinity` for `x` equal to zero', opts, function test( t ) {
 	var y = logpdf( 0.0, 0.5, 2.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta = 1`, the created function returns `ln(alpha)` for `x` equal to one', opts, function test( t ) {
 	var y = logpdf( 1.0, 3.0, 1.0 );
-	t.equal( y, ln(3.0), 'returns expected value' );
+	t.strictEqual( y, ln(3.0), 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta > 1`, the created function returns `-Infinity` for `x` equal to one', opts, function test( t ) {
 	var y = logpdf( 1.0, 1.5, 2.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta < 1`, the created function returns `+Infinity` for `x` equal to one', opts, function test( t ) {
 	var y = logpdf( 1.0, 1.5, 0.5 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -187,7 +187,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha` and `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 45000.0 * EPS * abs( expected[ i ] );
@@ -214,7 +214,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha`', opts, fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 22000.0 * EPS * abs( expected[ i ] );
@@ -241,7 +241,7 @@ tape( 'the function evaluates the logpdf for `x` given large `beta`', opts, func
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20000.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/mean/test/test.js
index 4e78be598815..38fba33a1a2d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the mean of a beta distribution', function test( t )
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/beta/mean/test/test.native.js
index c5fd9eb27bec..5ef901bd316f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the mean of a beta distribution', opts, function tes
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/median/test/test.js
index 0b7aa88eef95..7d1a3b496c00 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/median/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = median( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the median of a beta distribution', function test( t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 15.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.factory.js
index 8026e2825ccd..831497a64b7b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.factory.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -49,23 +49,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 1.0, 1.0 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,31 +77,31 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	mgf = factory( 1.0, 0.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.0, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -113,31 +113,31 @@ tape( 'if provided a nonpositive `alpha`, the created function always returns `N
 	mgf = factory( 0.0, 0.5 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( -1.0, 0.5 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, 1.0 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, PINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NaN );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.mgf.js
index 80681b1b53cb..741f5d9709d4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.mgf.js
@@ -40,11 +40,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = mgf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.native.js
index a9951d726768..b1097193f3b6 100755
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.native.js
@@ -49,11 +49,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mgf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,25 +88,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/mode/test/test.js
index 870773892199..ea39dc4c2c48 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 1`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( 0.5, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 1`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( 2.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the mode of a beta distribution', function test( t )
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 15.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/beta/mode/test/test.native.js
index 1962d712403e..202f74769084 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 1`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mode( 0.5, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 1`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mode( 2.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the mode of a beta distribution', opts, function tes
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 15.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.factory.js
index edc70a28890e..d6c8f0159a36 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,22 +83,22 @@ tape( 'if provided a valid `alpha` and `beta`, the function returns a function w
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -100.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 100.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 1.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -110,26 +110,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -141,26 +141,26 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 	pdf = factory( -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -168,42 +168,42 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 tape( 'if provided `alpha = 1`, the created function returns `beta` for `x` equal to zero', function test( t ) {
 	var pdf = factory( 1.0, 2.0 );
 	var y = pdf( 0.0 );
-	t.equal( y, 2.0, 'returns expected value' );
+	t.strictEqual( y, 2.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `alpha > 1`, the created function returns `0` for `x` equal to zero', function test( t ) {
 	var pdf = factory( 1.5, 2.0 );
 	var y = pdf( 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `alpha < 1`, the created function returns `+Infinity` for `x` equal to zero', function test( t ) {
 	var pdf = factory( 0.5, 2.0 );
 	var y = pdf( 0.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta = 1`, the created function returns `alpha` for `x` equal to one', function test( t ) {
 	var pdf = factory( 3.0, 1.0 );
 	var y = pdf( 1.0 );
-	t.equal( y, 3.0, 'returns expected value' );
+	t.strictEqual( y, 3.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta > 1`, the created function returns `0` for `x` equal to one', function test( t ) {
 	var pdf = factory( 1.5, 2.0 );
 	var y = pdf( 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta < 1`, the created function returns `+Infinity` for `x` equal to one', function test( t ) {
 	var pdf = factory( 1.5, 0.5 );
 	var y = pdf( 1.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -226,7 +226,7 @@ tape( 'the created function evaluates the pdf for `x` given large `alpha` and `b
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 180.0 * EPS * abs( expected[ i ] );
@@ -255,7 +255,7 @@ tape( 'the created function evaluates the pdf for `x` given a large `alpha`', fu
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
@@ -284,7 +284,7 @@ tape( 'the created function evaluates the pdf for `x` given a large `beta`', fun
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.native.js
index 458870623446..d4914ae66b79 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.native.js
@@ -55,32 +55,32 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside [0,1] for `x` and a valid `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 100.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -100.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 1.5, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -113,59 +113,59 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `alpha = 1`, the created function returns `beta` for `x` equal to zero', opts, function test( t ) {
 	var y = pdf( 0.0, 1.0, 2.0 );
-	t.equal( y, 2.0, 'returns expected value' );
+	t.strictEqual( y, 2.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `alpha > 1`, the created function returns `0` for `x` equal to zero', opts, function test( t ) {
 	var y = pdf( 0.0, 1.5, 2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `alpha < 1`, the created function returns `+Infinity` for `x` equal to zero', opts, function test( t ) {
 	var y = pdf( 0.0, 0.5, 2.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta = 1`, the created function returns `alpha` for `x` equal to one', opts, function test( t ) {
 	var y = pdf( 1.0, 3.0, 1.0 );
-	t.equal( y, 3.0, 'returns expected value' );
+	t.strictEqual( y, 3.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta > 1`, the created function returns `0` for `x` equal to one', opts, function test( t ) {
 	var y = pdf( 1.0, 1.5, 2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta < 1`, the created function returns `+Infinity` for `x` equal to one', opts, function test( t ) {
 	var y = pdf( 1.0, 1.5, 0.5 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -186,7 +186,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha` and `beta`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 180.0 * EPS * abs( expected[ i ] );
@@ -213,7 +213,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
@@ -240,7 +240,7 @@ tape( 'the function evaluates the pdf for `x` given large `beta`', opts, functio
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.pdf.js
index 18d05ff35f0c..eda8901cb42e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.pdf.js
@@ -46,32 +46,32 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside [0,1] for `x` and a valid `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 100.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -100.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 1.5, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,59 +104,59 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `alpha = 1`, the created function returns `beta` for `x` equal to zero', function test( t ) {
 	var y = pdf( 0.0, 1.0, 2.0 );
-	t.equal( y, 2.0, 'returns expected value' );
+	t.strictEqual( y, 2.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `alpha > 1`, the created function returns `0` for `x` equal to zero', function test( t ) {
 	var y = pdf( 0.0, 1.5, 2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `alpha < 1`, the created function returns `+Infinity` for `x` equal to zero', function test( t ) {
 	var y = pdf( 0.0, 0.5, 2.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 	t.end();
 });
 
 tape( 'if provided `beta = 1`, the created function returns `alpha` for `x` equal to one', function test( t ) {
 	var y = pdf( 1.0, 3.0, 1.0 );
-	t.equal( y, 3.0, 'returns expected value' );
+	t.strictEqual( y, 3.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta > 1`, the created function returns `0` for `x` equal to one', function test( t ) {
 	var y = pdf( 1.0, 1.5, 2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `beta < 1`, the created function returns `+Infinity` for `x` equal to one', function test( t ) {
 	var y = pdf( 1.0, 1.5, 0.5 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -177,7 +177,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha` and `beta`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 180.0 * EPS * abs( expected[ i ] );
@@ -204,7 +204,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
@@ -231,7 +231,7 @@ tape( 'the function evaluates the pdf for `x` given large `beta`', function test
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.factory.js
index 046caf822ba6..f4ab31b04288 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,26 +98,26 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -129,31 +129,31 @@ tape( 'if provided a nonpositive `alpha`, the created function always returns `N
 	quantile = factory( 0.0, 0.5 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -177,7 +177,7 @@ tape( 'the created function evaluates the quantile for `p` given large `alpha` a
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -206,7 +206,7 @@ tape( 'the created function evaluates the quantile for `p` given large `alpha`',
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -235,7 +235,7 @@ tape( 'the created function evaluates the quantile for `p` given large `beta`',
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.quantile.js
index 02ae9ce50ea7..584c71305003 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `alpha` and `beta`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,25 +66,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = quantile( 0.5, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,25 +93,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the function evaluates the quantile for `x` given large `alpha` and `beta
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -160,7 +160,7 @@ tape( 'the function evaluates the quantile for `x` given large `alpha`', functio
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -187,7 +187,7 @@ tape( 'the function evaluates the quantile for `x` given large `beta`', function
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/skewness/test/test.js
index 30efb3d9d788..ecacf9542f64 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/skewness/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the skewness of a beta distribution', function test(
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/beta/skewness/test/test.native.js
index 0e8adbe10419..8527cc9b09bf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the skewness of a beta distribution', opts, function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/stdev/test/test.js
index ea2578d71878..677a9a96a7c1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the standard deviation of a beta distribution', func
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/beta/stdev/test/test.native.js
index db46576d2745..25a3b4f55957 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the standard deviation of a beta distribution', opts
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/test/test.js
index f849070a5d27..07754b5354e5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains beta distribution functions', function test( t ) {
 	var keys = objectKeys( beta );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/variance/test/test.js
index cb1707895235..bff9b40cbb40 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the variance of a beta distribution', function test(
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/beta/variance/test/test.native.js
index 68d312ad3b29..9dc3a89e3529 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the variance of a beta distribution', opts, function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.cdf.js
index f5438fe81dd9..ba684f406e07 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.cdf.js
@@ -46,33 +46,33 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -100.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+Infinity` for `x` and a finite `alpha` and `beta`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
@@ -80,25 +80,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -107,25 +107,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha` and `beta`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 100.0 * EPS * abs( expected[ i ] );
@@ -174,7 +174,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
@@ -201,7 +201,7 @@ tape( 'the function evaluates the cdf for `x` given large `beta`', function test
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.factory.js
index c66289193964..5aea1721e7b9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -100.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -10.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -118,31 +118,31 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	cdf = factory( 1.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -154,31 +154,31 @@ tape( 'if provided a nonpositive `alpha`, the created function always returns `N
 	cdf = factory( 0.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -202,7 +202,7 @@ tape( 'the created function evaluates the cdf for `x` given large `alpha` and `b
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 100.0 * EPS * abs( expected[ i ] );
@@ -231,7 +231,7 @@ tape( 'the created function evaluates the cdf for `x` given large `alpha`', func
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
@@ -260,7 +260,7 @@ tape( 'the created function evaluates the cdf for `x` given large `beta`', funct
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/kurtosis/test/test.js
index 177813a50ce6..c8200ac103ba 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/kurtosis/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,34 +77,34 @@ tape( 'if provided `beta <= 4`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( 2.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns the excess kurtosis of a beta prime distribution', f
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 320.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/kurtosis/test/test.native.js
index a1be1e4dabf4..52d0a23ead30 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/kurtosis/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,34 +86,34 @@ tape( 'if provided `beta <= 4`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = kurtosis( 2.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the function returns the excess kurtosis of a beta prime distribution', o
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 320.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.factory.js
index 4a06cca3485a..b5b23d5d9b8d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -100.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -10.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -118,31 +118,31 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	logcdf = factory( 1.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -154,31 +154,31 @@ tape( 'if provided a nonpositive `alpha`, the created function always returns `N
 	logcdf = factory( 0.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -1.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, 1.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, PINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NaN );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -202,7 +202,7 @@ tape( 'the created function evaluates the logcdf for `x` given large `alpha` and
 		logcdf = factory( alpha[i], beta[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 120.0 * EPS * abs( expected[ i ] );
@@ -231,7 +231,7 @@ tape( 'the created function evaluates the logcdf for `x` given large `alpha`', f
 		logcdf = factory( alpha[i], beta[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -260,7 +260,7 @@ tape( 'the created function evaluates the logcdf for `x` given large `beta`', fu
 		logcdf = factory( alpha[i], beta[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 400.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.logcdf.js
index 9bf235214a27..1c1791ecc4f5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.logcdf.js
@@ -46,33 +46,33 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `alpha` and `beta`, the function returns `-infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -100.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -1.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+Infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -80,25 +80,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -107,25 +107,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function evaluates the logcdf for `x` given large `alpha` and `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 120.0 * EPS * abs( expected[ i ] );
@@ -174,7 +174,7 @@ tape( 'the function evaluates the logcdf for `x` given large `alpha`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 120.0 * EPS * abs( expected[ i ] );
@@ -201,7 +201,7 @@ tape( 'the function evaluates the logcdf for `x` given large `beta`', function t
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 400.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.factory.js
index 830a988f044a..1905999382c8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 1.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,13 +83,13 @@ tape( 'if provided a valid `alpha` and `beta`, the function returns a function w
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -100.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -101,26 +101,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -132,26 +132,26 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 	logpdf = factory( -1.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -175,7 +175,7 @@ tape( 'the created function evaluates the logpdf for `x` given large `alpha` and
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 45000.0 * EPS * abs( expected[ i ] );
@@ -204,7 +204,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large `alpha`',
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 300.0 * EPS * abs( expected[ i ] );
@@ -233,7 +233,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large `beta`',
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5500.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.logpdf.js
index d237196754ce..5dd308cc1843 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.logpdf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,13 +58,13 @@ tape( 'if provided a number smaller than zero for `x` and a valid `alpha` and `b
 	var y;
 
 	y = logpdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -100.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -0.5, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -73,22 +73,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,22 +97,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha` and `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 22000.0 * EPS * abs( expected[ i ] );
@@ -161,7 +161,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 300.0 * EPS * abs( expected[ i ] );
@@ -188,7 +188,7 @@ tape( 'the function evaluates the logpdf for `x` given large `beta`', function t
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5500.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.native.js
index b7e92007b612..40a28551a640 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.native.js
@@ -55,11 +55,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -67,13 +67,13 @@ tape( 'if provided a number smaller than zero for `x` and a valid `alpha` and `b
 	var y;
 
 	y = logpdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -100.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -0.5, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -82,22 +82,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,22 +106,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha` and `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 23500.0 * EPS * abs( expected[ i ] );
@@ -170,7 +170,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha`', opts, fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 300.0 * EPS * abs( expected[ i ] );
@@ -197,7 +197,7 @@ tape( 'the function evaluates the logpdf for `x` given large `beta`', opts, func
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5500.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/mean/test/test.js
index 0d870ac861f6..bdf557c2734e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/mean/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -54,19 +54,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,25 +75,25 @@ tape( 'if provided `beta <= 1`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function returns the mean of a beta prime distribution', function tes
 	beta = data.beta;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( alpha[i], beta[i] );
-		t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/mean/test/test.native.js
index 61c3cb1c6029..bcdb62b549b7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/mean/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,19 +63,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,25 +84,25 @@ tape( 'if provided `beta <= 1`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mean( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function returns the mean of a beta prime distribution', opts, functi
 	beta = data.beta;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( alpha[i], beta[i] );
-		t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/mode/test/test.js
index 4f6475dae938..5df621cd6a42 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/mode/test/test.js
@@ -39,10 +39,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -51,19 +51,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,22 +72,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/mode/test/test.native.js
index ed8c6e6d0a85..04d076980ae4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/mode/test/test.native.js
@@ -48,10 +48,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -60,19 +60,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,22 +81,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.factory.js
index 45c341a93198..bef9663d88d9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,16 +83,16 @@ tape( 'if provided a valid `alpha` and `beta`, the function returns a function w
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -100.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -104,26 +104,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -135,26 +135,26 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 	pdf = factory( -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -178,7 +178,7 @@ tape( 'the created function evaluates the pdf for `x` given large `alpha` and `b
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 290.0 * EPS * abs( expected[ i ] );
@@ -207,7 +207,7 @@ tape( 'the created function evaluates the pdf for `x` given a large `alpha`', fu
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
@@ -236,7 +236,7 @@ tape( 'the created function evaluates the pdf for `x` given a large `beta`', fun
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.native.js
index 647d05eb86de..96e5c8ab1a93 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.native.js
@@ -55,11 +55,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -67,16 +67,16 @@ tape( 'if provided a nonpositive number for `x` and a valid `alpha` and `beta`,
 	var y;
 
 	y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -100.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -85,22 +85,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,22 +109,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -146,7 +146,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha` and `beta`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 290.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
@@ -200,7 +200,7 @@ tape( 'the function evaluates the pdf for `x` given large `beta`', opts, functio
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.pdf.js
index b3c5fc8e6d56..685e61edbc63 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.pdf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,16 +58,16 @@ tape( 'if provided a nonpositive number for `x` and a valid `alpha` and `beta`,
 	var y;
 
 	y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -100.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -76,22 +76,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -100,22 +100,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha` and `beta`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 290.0 * EPS * abs( expected[ i ] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
@@ -191,7 +191,7 @@ tape( 'the function evaluates the pdf for `x` given large `beta`', function test
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.factory.js
index d9f7445ddb42..5fd1b2250436 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,26 +98,26 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -129,31 +129,31 @@ tape( 'if provided a nonpositive `alpha`, the created function always returns `N
 	quantile = factory( 0.0, 0.5 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -177,7 +177,7 @@ tape( 'the created function evaluates the quantile for `p` given large `alpha` a
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 25.0 * EPS * abs( expected[ i ] );
@@ -206,7 +206,7 @@ tape( 'the created function evaluates the quantile for `p` given large `alpha`',
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
@@ -235,7 +235,7 @@ tape( 'the created function evaluates the quantile for `p` given large `beta`',
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 25.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.quantile.js
index fb4a6ed130f0..693bbef269c3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `alpha` and `beta`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,25 +66,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = quantile( 0.5, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,25 +93,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the function evaluates the quantile for `x` given large `alpha` and `beta
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 25.0 * EPS * abs( expected[ i ] );
@@ -160,7 +160,7 @@ tape( 'the function evaluates the quantile for `x` given large `alpha`', functio
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
@@ -187,7 +187,7 @@ tape( 'the function evaluates the quantile for `x` given large `beta`', function
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 25.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/skewness/test/test.js
index 692d2a5af25d..02b4b07dacdf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/skewness/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,31 +77,31 @@ tape( 'if provided `beta <= 3`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function returns the skewness of a beta prime distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/skewness/test/test.native.js
index ab018cb16074..3ea0e10364fa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,31 +86,31 @@ tape( 'if provided `beta <= 3`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = skewness( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function returns the skewness of a beta prime distribution', opts, fu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/stdev/test/test.js
index 6335e374af8c..ea6ea8336bb4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,28 +77,28 @@ tape( 'if provided `beta <= 2`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the standard deviation of a beta prime distribution'
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 4.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/stdev/test/test.native.js
index 69c1a51222dc..d6a456c9e1f0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,28 +86,28 @@ tape( 'if provided `beta <= 2`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = stdev( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function returns the standard deviation of a beta prime distribution'
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 4.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/test/test.js
index 666a19979710..88dce7fd89a2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains betaprime distribution functions', function test( t ) {
 	var keys = objectKeys( betaprime );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/variance/test/test.js
index cc1a0f3acf83..6a12eb7f9516 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,28 +77,28 @@ tape( 'if provided `beta <= 2`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the variance of a beta prime distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/variance/test/test.native.js
index c6c1cd706361..178e0e9230cf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,28 +86,28 @@ tape( 'if provided `beta <= 2`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = variance( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function returns the variance of a beta prime distribution', opts, fu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.cdf.js
index d78e6917825f..e2b6d5d4565c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.cdf.js
@@ -47,36 +47,36 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 10, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 10, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided an `x` greater than or equal to `n`, the function returns `1` (provided `n` and `p` are valid)', function test( t ) {
 	var y = cdf( PINF, 20, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 200, 20, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 21, 20, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `n` and `p`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 20, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -10.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -85,19 +85,19 @@ tape( 'if provided a `n` which is not a nonnegative integer, the function return
 	var y;
 
 	y = cdf( 2.0, 1.5, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -2, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.5, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, PINF, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,16 +106,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = cdf( 2.0, 20, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 20, 1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 20, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 20, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'the function evaluates the cdf for `x` given large `n` and `p`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 250.0 * EPS * abs( expected[i] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the cdf for `x` given large `n` and small `p`', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 40.0 * EPS * abs( expected[i] );
@@ -191,7 +191,7 @@ tape( 'the function evaluates the cdf for `x` given small `n` and large `p`', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 50.0 * EPS * abs( expected[i] );
@@ -218,7 +218,7 @@ tape( 'the function evaluates the cdf for `x` given small `n` and `p`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.factory.js
index 2c2245a00620..f0de435f9626 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 20, 0.5 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 0.5 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 20, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,13 +84,13 @@ tape( 'if provided a valid `n` and `p`, the function returns a function which re
 
 	cdf = factory( 20, 0.5 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 200.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 20.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -101,16 +101,16 @@ tape( 'if provided a valid `n` and `p`, the function returns a function which re
 
 	cdf = factory( 20, 0.5 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -10.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -122,22 +122,22 @@ tape( 'if provided a `n` which is not a nonnegative integer, the created functio
 	cdf = factory( 20.5, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -10, 0.5 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, 0.5 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, 0.5 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -149,22 +149,22 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the created functi
 	cdf = factory( 20, 1.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 20, -0.5 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 20, PINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 20, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -188,7 +188,7 @@ tape( 'the created function evaluates the cdf for `x` given large `n` and `p`',
 		cdf = factory( n[i], p[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 250.0 * EPS * abs( expected[i] );
@@ -217,7 +217,7 @@ tape( 'the created function evaluates the cdf for `x` given large `n` and small
 		cdf = factory( n[i], p[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 40.0 * EPS * abs( expected[i] );
@@ -246,7 +246,7 @@ tape( 'the created function evaluates the cdf for `x` given small `n` and large
 		cdf = factory( n[i], p[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 50.0 * EPS * abs( expected[i] );
@@ -275,7 +275,7 @@ tape( 'the created function evaluates the cdf for `x` given small `n` and `p`',
 		cdf = factory( n[i], p[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/entropy/test/test.js
index fc90bf213232..91e538deb7a0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/entropy/test/test.js
@@ -44,13 +44,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -59,19 +59,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = entropy( 1.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 2.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( PINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,16 +80,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = entropy( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 20, NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 20, PINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,10 +97,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 tape( 'the function returns `0` for `p` equal to `1` or `0`', function test( t ) {
 	var y;
 	y = entropy( 3, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = entropy( 3, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -108,7 +108,7 @@ tape( 'the function returns `0` for `p` equal to `1` or `0`', function test( t )
 tape( 'the function returns `0` for `n` equal to `0`', function test( t ) {
 	var y;
 	y = entropy( 0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -127,7 +127,7 @@ tape( 'the function returns the entropy of a binomial distribution', function te
 	for ( i = 0; i < n.length; i++ ) {
 		y = entropy( n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		}
 		else {
 			delta = abs( y - expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/entropy/test/test.native.js
index d21110619a4a..4c0429177b6f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/entropy/test/test.native.js
@@ -53,26 +53,26 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,19 +81,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = entropy( 1.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 2.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( PINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,16 +102,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = entropy( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 20, NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 20, PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -119,10 +119,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 tape( 'the function returns `0` for `p` equal to `1` or `0`', opts, function test( t ) {
 	var y;
 	y = entropy( 3, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = entropy( 3, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function returns `0` for `p` equal to `1` or `0`', opts, function tes
 tape( 'the function returns `0` for `n` equal to `0`', opts, function test( t ) {
 	var y;
 	y = entropy( 0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -149,7 +149,7 @@ tape( 'the function returns the entropy of a binomial distribution', opts, funct
 	for ( i = 0; i < n.length; i++ ) {
 		y = entropy( n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		}
 		else {
 			delta = abs( y - expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/kurtosis/test/test.js
index 7f7fa1e1f364..8bfd42d441c9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/kurtosis/test/test.js
@@ -44,13 +44,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -59,19 +59,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = kurtosis( 1.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 2.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( PINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,16 +80,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = kurtosis( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, PINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the excess kurtosis of a binomial distribution', fun
 	for ( i = 0; i < n.length; i++ ) {
 		y = kurtosis( n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		}
 		else {
 			delta = abs( y - expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/kurtosis/test/test.native.js
index 38bef7822c9d..b61618a1beb3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/kurtosis/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = kurtosis( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,16 +77,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = kurtosis( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, PINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function returns the excess kurtosis of a binomial distribution', opt
 	for ( i = 0; i < n.length; i++ ) {
 		y = kurtosis( n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		}
 		else {
 			delta = abs( y - expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.factory.js
index 456bf8f04eeb..da8eb599e364 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 20, 0.5 );
-	t.equal( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpmf = factory( 20, 0.5 );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, 0.5 );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 20, NaN );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, NaN );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, NaN );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,16 +84,16 @@ tape( 'if provided a valid `n` and `p`, the function returns a function which re
 
 	logpmf = factory( 20, 0.5 );
 	y = logpmf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -20.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -10.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -104,16 +104,16 @@ tape( 'if provided a valid `n` and `p`, the function returns a function which re
 
 	logpmf = factory( 20, 0.5 );
 	y = logpmf( -2.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 1.2 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -124,16 +124,16 @@ tape( 'if provided a valid `n` and `p`, the function returns a function which re
 
 	logpmf = factory( 20, 0.5 );
 	y = logpmf( 21.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 22.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 50.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -145,22 +145,22 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the created functi
 	logpmf = factory( 20, 1.2 );
 
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 20, -0.1 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 20, NINF );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 20, PINF );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -172,22 +172,22 @@ tape( 'if provided a `n` which is not a nonnegative integer, the created functio
 	logpmf = factory( -1.0, 0.5 );
 
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 1.5, 0.5 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NINF, 0.5 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( PINF, 0.5 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -199,36 +199,36 @@ tape( 'if `p` or `n` equals `0`, the created function evaluates a degenerate dis
 	logpmf = factory( 8, 0.0 );
 
 	y = logpmf( 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x equal to 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x equal to 0' );
 
 	y = logpmf( 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 0.0, 0.5 );
 
 	y = logpmf( 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logpmf( 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -240,19 +240,19 @@ tape( 'if `p` equals `1.0`, the created function evaluates a degenerate distribu
 	logpmf = factory( 8, 1.0 );
 
 	y = logpmf( 8.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logpmf( 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -276,7 +276,7 @@ tape( 'the created function evaluates the logpmf for `x` given large `n` and `p`
 		logpmf = factory( n[i], p[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 30.0 * EPS * abs( expected[i] );
@@ -305,7 +305,7 @@ tape( 'the created function evaluates the logpmf for `x` given a large `n` and s
 		logpmf = factory( n[i], p[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 20.0 * EPS * abs( expected[i] );
@@ -334,7 +334,7 @@ tape( 'the created function evaluates the logpmf for `x` given small `n` and lar
 		logpmf = factory( n[i], p[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 20.0 * EPS * abs( expected[i] );
@@ -363,7 +363,7 @@ tape( 'the created function evaluates the logpmf for `x` given small `n` and `p`
 		logpmf = factory( n[i], p[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.js
index 373f96b89f76..bb8d4629a397 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpmf` functions', function test( t ) {
-	t.equal( typeof logpmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.logpmf.js
index 715b2a2d4734..f90fa59d48a7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.logpmf.js
@@ -47,42 +47,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpmf( NaN, 20, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, 20, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `n` and `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( NINF, 20, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -20.0, 20, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -100.0, 20, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.0, 20, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `n` and `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( -1.5, 20, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -0.5, 20, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 1.5, 20, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 2.5, 20, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -91,16 +91,16 @@ tape( 'if provided `n` which is not a nonnegative integer, the function returns
 	var y;
 
 	y = logpmf( 2.0, 1.5, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, -1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, NINF, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, PINF, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,16 +109,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = logpmf( 2.0, 20, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, 20, 1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, 20, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, 20, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -128,35 +128,35 @@ tape( 'if `p` or `n` equals `0`, the function evaluates a degenerate distributio
 
 	// Case: n = 8, p = 0.0
 	y = logpmf( 0.0, 8, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logpmf( 1.0, 8, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( PINF, 8, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( NINF, 8, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( NaN, 8, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	// Case: n = 0, p = 0.5
 	y = logpmf( 0.0, 0, 0.5 );
-	t.equal( y, 0.0, 'returns 0 for x equal to 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x equal to 0' );
 
 	y = logpmf( 1.0, 0, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( PINF, 0, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( NINF, 0, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( NaN, 0, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -165,19 +165,19 @@ tape( 'if `p` equals `1.0`, the function evaluates a degenerate distribution cen
 	var y;
 
 	y = logpmf( 8.0, 8, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logpmf( 1.0, 8, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( PINF, 8, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( NINF, 8, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( NaN, 8, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function evaluates the logpmf for `x` given large `n` and `p`', funct
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 30.0 * EPS * abs( expected[i] );
@@ -226,7 +226,7 @@ tape( 'the function evaluates the logpmf for `x` given large `n` and small `p`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 20.0 * EPS * abs( expected[i] );
@@ -253,7 +253,7 @@ tape( 'the function evaluates the logpmf for `x` given small `n` and large `p`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 20.0 * EPS * abs( expected[i] );
@@ -280,7 +280,7 @@ tape( 'the function evaluates the logpmf for `x` given small `n` and `p`', funct
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/mean/test/test.js
index dce56f099621..4472793161cb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/mean/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,19 +57,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = mean( 1.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 2.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( PINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mean( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 20, NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 20, PINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns the mean of a binomial distribution', function test(
 	p = data.p;
 	for ( i = 0; i < n.length; i++ ) {
 		y = mean( n[i], p[i] );
-		t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/mean/test/test.native.js
index f6cf9ab47447..9b51de4de49b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/mean/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function te
 	var v;
 
 	v = mean( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -60,13 +60,13 @@ tape( 'if provided `n < 0` or success probability `p` outside of `[0,1]`, the fu
 	var v;
 
 	v = mean( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10, -0.1 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns the mean of a binomial distribution', opts, function
 	p = data.p;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( n[i], p[i] );
-		t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/median/test/test.js
index dfcf37c8c6ea..d0361af1807b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/median/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,19 +57,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = median( 1.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 2.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( PINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = median( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 20, NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 20, PINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns the median of a binomial distribution', function tes
 	p = data.p;
 	for ( i = 0; i < n.length; i++ ) {
 		y = median( n[i], p[i] );
-		t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/median/test/test.native.js
index 5661ba70812d..7ac685ab49fd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/median/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for either `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = median( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -60,10 +60,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = median( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,16 +72,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = median( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 20, NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 20, PINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns the median of a binomial distribution', opts, functi
 	p = data.p;
 	for ( i = 0; i < n.length; i++ ) {
 		y = median( n[i], p[i] );
-		t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.factory.js
index f739a1ca435d..34b7b260c5f4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 20, 0.5 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 0.5 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 20, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -85,22 +85,22 @@ tape( 'if provided an `n` which is not a nonnegative integer, the created functi
 	mgf = factory( 20.5, 0.5 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( -10, 0.5 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF, 0.5 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, 0.5 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -112,22 +112,22 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the created functi
 	mgf = factory( 20, 1.5 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 20, -0.5 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 20, PINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 20, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -151,7 +151,7 @@ tape( 'the created function evaluates the mgf for `x` given large `n` and `p`',
 		mgf = factory( n[i], p[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 15.0 * EPS * abs( expected[i] );
@@ -180,7 +180,7 @@ tape( 'the created function evaluates the mgf for `x` given large `n` and small
 		mgf = factory( n[i], p[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 15.0 * EPS * abs( expected[i] );
@@ -209,7 +209,7 @@ tape( 'the created function evaluates the mgf for `x` given small `n` and large
 		mgf = factory( n[i], p[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 6.0 * EPS * abs( expected[i] );
@@ -238,7 +238,7 @@ tape( 'the created function evaluates the mgf for `x` given small `n` and `p`',
 		mgf = factory( n[i], p[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 7.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.mgf.js
index 663f4d49caef..f83fbe865716 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.mgf.js
@@ -47,11 +47,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 10, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 4.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 4.0, 10, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,19 +59,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mgf( 2.0, 1.5, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, -2, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, -1, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.5, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, PINF, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,16 +80,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = mgf( 2.0, 20, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 20, 1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 20, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 20, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -111,7 +111,7 @@ tape( 'the function evaluates the mgf for `x` given large `n` and `p`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 15.0 * EPS * abs( expected[i] );
@@ -138,7 +138,7 @@ tape( 'the function evaluates the mgf for `x` given large `n` and small `p`', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 15.0 * EPS * abs( expected[i] );
@@ -165,7 +165,7 @@ tape( 'the function evaluates the mgf for `x` given small `n` and large `p`', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 6.0 * EPS * abs( expected[i] );
@@ -192,7 +192,7 @@ tape( 'the function evaluates the mgf for `x` given small `n` and `p`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 7.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.native.js
index e4266b5bb1b1..077b391ddb80 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.native.js
@@ -56,9 +56,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 10, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 4.0, 10, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -66,10 +66,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mgf( 2.0, -2, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, -1, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = mgf( 2.0, 20, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 20, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 20, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function evaluates the mgf for `x` given large `n` and `p`', opts, fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 1000.0 * EPS * abs( expected[i] );
@@ -136,7 +136,7 @@ tape( 'the function evaluates the mgf for `x` given large `n` and small `p`', op
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 100.0 * EPS * abs( expected[i] );
@@ -163,7 +163,7 @@ tape( 'the function evaluates the mgf for `x` given small `n` and large `p`', op
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 100.0 * EPS * abs( expected[i] );
@@ -190,7 +190,7 @@ tape( 'the function evaluates the mgf for `x` given small `n` and `p`', opts, fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 100.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/mode/test/test.js
index 74cfe695336e..cd7c75b4af33 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/mode/test/test.js
@@ -39,13 +39,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -54,19 +54,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = mode( 1.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 2.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( PINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,16 +75,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mode( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 20, NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 20, PINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'the function returns the mode of a binomial distribution', function test(
 		n = floor( randu() * 100.0 );
 		p = randu();
 		y = mode( n, p );
-		t.equal( y, floor( ( n+1 ) * p ), 'returns mode' );
+		t.strictEqual( y, floor( ( n+1 ) * p ), 'returns mode' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/mode/test/test.native.js
index 16306640eb09..9729eef7334c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/mode/test/test.native.js
@@ -48,7 +48,7 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var v;
 
 	v = mode( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,10 +57,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = mode( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,10 +69,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mode( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'the function returns the mode of a binomial distribution', opts, function
 		n = floor( randu() * 100.0 );
 		p = randu();
 		y = mode( n, p );
-		t.equal( y, floor( ( n+1 ) * p ), 'returns mode' );
+		t.strictEqual( y, floor( ( n+1 ) * p ), 'returns mode' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.factory.js
index 600b03f8d9b4..e2c7db36a4f9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 20, 0.5 );
-	t.equal( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 20, 0.5 );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, 0.5 );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 20, NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, NaN );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,16 +84,16 @@ tape( 'if provided a valid `n` and `p`, the function returns a function which re
 
 	pmf = factory( 20, 0.5 );
 	y = pmf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -20.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -10.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -104,16 +104,16 @@ tape( 'if provided a valid `n` and `p`, the function returns a function which re
 
 	pmf = factory( 20, 0.5 );
 	y = pmf( -2.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 1.2 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -124,16 +124,16 @@ tape( 'if provided a valid `n` and `p`, the function returns a function which re
 
 	pmf = factory( 20, 0.5 );
 	y = pmf( 21.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 22.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 50.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -145,22 +145,22 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the created functi
 	pmf = factory( 20, 1.2 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 20, -0.1 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 20, NINF );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 20, PINF );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -172,22 +172,22 @@ tape( 'if provided a `n` which is not a nonnegative integer, the created functio
 	pmf = factory( -1.0, 0.5 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 1.5, 0.5 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NINF, 0.5 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( PINF, 0.5 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -199,36 +199,36 @@ tape( 'if `p` or `n` equals `0`, the created function evaluates a degenerate dis
 	pmf = factory( 8, 0.0 );
 
 	y = pmf( 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = pmf( 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 0.0, 0.5 );
 
 	y = pmf( 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = pmf( 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -240,19 +240,19 @@ tape( 'if `p` equals `1.0`, the created function evaluates a degenerate distribu
 	pmf = factory( 8, 1.0 );
 
 	y = pmf( 8.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = pmf( 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -276,7 +276,7 @@ tape( 'the created function evaluates the pmf for `x` given large `n` and `p`',
 		pmf = factory( n[i], p[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 260.0 * EPS * abs( expected[i] );
@@ -305,7 +305,7 @@ tape( 'the created function evaluates the pmf for `x` given a large `n` and smal
 		pmf = factory( n[i], p[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 270.0 * EPS * abs( expected[i] );
@@ -334,7 +334,7 @@ tape( 'the created function evaluates the pmf for `x` given small `n` and large
 		pmf = factory( n[i], p[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 80.0 * EPS * abs( expected[i] );
@@ -363,7 +363,7 @@ tape( 'the created function evaluates the pmf for `x` given small `n` and `p`',
 		pmf = factory( n[i], p[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 100.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.js
index 686bb53fea47..33c536be2daf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pmf` functions', function test( t ) {
-	t.equal( typeof pmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.native.js
index c82df8b8914a..8ceef2b4809d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.native.js
@@ -56,40 +56,40 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `x` or `p`, the function returns `NaN`', opts, function test( t ) {
 	var y = pmf( NaN, 20, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pmf( 0.0, 20, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `n` and `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( NINF, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -20.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -100.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `n` and `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( -1.5, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -0.5, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 1.5, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 2.5, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -98,16 +98,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = pmf( 2.0, 20, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0, 20, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 2.0, 20, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 2.0, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -117,35 +117,35 @@ tape( 'if `p` or `n` equals `0`, the function evaluates a degenerate distributio
 
 	// Case: n = 8, p = 0.0
 	y = pmf( 0.0, 8, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = pmf( 1.0, 8, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( PINF, 8, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( NINF, 8, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( NaN, 8, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	// Case: n = 0, p = 0.5
 	y = pmf( 0.0, 0, 0.5 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = pmf( 1.0, 0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( PINF, 0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( NINF, 0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( NaN, 0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -154,19 +154,19 @@ tape( 'if `p` equals `1.0`, the function evaluates a degenerate distribution cen
 	var y;
 
 	y = pmf( 8.0, 8, 1.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 8' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 8' );
 
 	y = pmf( 1.0, 8, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( PINF, 8, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( NINF, 8, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( NaN, 8, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -188,7 +188,7 @@ tape( 'the function evaluates the pmf for `x` given large `n` and `p`', opts, fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[ i ], n[ i ], p[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: ' + x[ i ] + ', n: ' + n[ i ] + ', p: ' + p[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: ' + x[ i ] + ', n: ' + n[ i ] + ', p: ' + p[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 260.0 * EPS * abs( expected[ i ] );
@@ -215,7 +215,7 @@ tape( 'the function evaluates the pmf for `x` given large `n` and small `p`', op
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[ i ], n[ i ], p[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: ' + x[ i ] + ', n: ' + n[ i ] + ', p: ' + p[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: ' + x[ i ] + ', n: ' + n[ i ] + ', p: ' + p[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 270.0 * EPS * abs( expected[ i ] );
@@ -242,7 +242,7 @@ tape( 'the function evaluates the pmf for `x` given small `n` and large `p`', op
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[ i ], n[ i ], p[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: ' + x[ i ] + ', n: ' + n[ i ] + ', p: ' + p[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: ' + x[ i ] + ', n: ' + n[ i ] + ', p: ' + p[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
@@ -269,7 +269,7 @@ tape( 'the function evaluates the pmf for `x` given small `n` and `p`', opts, fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[ i ], n[ i ], p[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: ' + x[ i ] + ', n: ' + n[ i ] + ', p: ' + p[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: ' + x[ i ] + ', n: ' + n[ i ] + ', p: ' + p[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 120.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.pmf.js
index 8bb27440e2bb..03731d242508 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.pmf.js
@@ -47,42 +47,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( NaN, 20, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, 20, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `n` and `p`, the function returns `0`', function test( t ) {
 	var y = pmf( NINF, 20, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -20.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -100.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `n` and `p`, the function returns `0`', function test( t ) {
 	var y = pmf( -1.5, 20, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -0.5, 20, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 1.5, 20, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 2.5, 20, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -91,16 +91,16 @@ tape( 'if provided `n` which is not a nonnegative integer, the function returns
 	var y;
 
 	y = pmf( 2.0, 1.5, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, -1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, NINF, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, PINF, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,16 +109,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = pmf( 2.0, 20, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, 20, 1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, 20, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, 20, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -128,35 +128,35 @@ tape( 'if `p` or `n` equals `0`, the function evaluates a degenerate distributio
 
 	// Case: n = 8, p = 0.0
 	y = pmf( 0.0, 8, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = pmf( 1.0, 8, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( PINF, 8, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NINF, 8, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NaN, 8, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	// Case: n = 0, p = 0.5
 	y = pmf( 0.0, 0, 0.5 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = pmf( 1.0, 0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( PINF, 0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NINF, 0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NaN, 0, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -165,19 +165,19 @@ tape( 'if `p` equals `1.0`, the function evaluates a degenerate distribution cen
 	var y;
 
 	y = pmf( 8.0, 8, 1.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 8' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 8' );
 
 	y = pmf( 1.0, 8, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( PINF, 8, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NINF, 8, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NaN, 8, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function evaluates the pmf for `x` given large `n` and `p`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 260.0 * EPS * abs( expected[i] );
@@ -226,7 +226,7 @@ tape( 'the function evaluates the pmf for `x` given large `n` and small `p`', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 270.0 * EPS * abs( expected[i] );
@@ -253,7 +253,7 @@ tape( 'the function evaluates the pmf for `x` given small `n` and large `p`', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 80.0 * EPS * abs( expected[i] );
@@ -280,7 +280,7 @@ tape( 'the function evaluates the pmf for `x` given small `n` and `p`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 100.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.factory.js
index a6127858a795..f1f3af8ebd63 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,23 +55,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 20, 0.5 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 0.5 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 20, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,10 +82,10 @@ tape( 'if provided a valid `n` and `p`, the function returns a function which re
 
 	quantile = factory( 20, 0.5 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,22 +97,22 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the created fun
 	quantile = factory( 20, -1.0 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 20, NINF );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 20, PINF );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 20, 1.5 );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -124,23 +124,23 @@ tape( 'if provided a `n` which is not a nonnegative integer, the created functio
 	quantile = factory( 20.5, 0.5 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, 0.5 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, 0.5 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -152,30 +152,30 @@ tape( 'if `p` or `n` equals `0`, the created function evaluates a degenerate dis
 	quantile = factory( 0, 0.5 );
 
 	y = quantile( 0.3 );
-	t.equal( y, 0, 'returns expected value' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = quantile( 0.9 );
-	t.equal( y, 0, 'returns expected value' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 8, 0.0 );
 
 	y = quantile( 0.3 );
-	t.equal( y, 0, 'returns expected value' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = quantile( 0.9 );
-	t.equal( y, 0, 'returns expected value' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -187,16 +187,16 @@ tape( 'if `p` equals `1.0`, the created function evaluates a degenerate distribu
 	quantile = factory( 8, 1.0 );
 
 	y = quantile( 0.3 );
-	t.equal( y, 8, 'returns 8 for r inside [0,1]' );
+	t.strictEqual( y, 8, 'returns 8 for r inside [0,1]' );
 
 	y = quantile( 0.9 );
-	t.equal( y, 8, 'returns 8 for r inside [0,1]' );
+	t.strictEqual( y, 8, 'returns 8 for r inside [0,1]' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -208,10 +208,10 @@ tape( 'given valid parameters, the created function evaluates the 0% and 100% as
 	quantile = factory( 8, 0.5 );
 
 	y = quantile( 0.0 );
-	t.equal( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns 0' );
 
 	y = quantile( 1.0 );
-	t.equal( y, 8, 'returns 8' );
+	t.strictEqual( y, 8, 'returns 8' );
 
 	t.end();
 });
@@ -232,7 +232,7 @@ tape( 'the created function evaluates the quantile for `r` given large `n` and `
 	for ( i = 0; i < r.length; i++ ) {
 		quantile = factory( n[i], p[i] );
 		y = quantile( r[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -253,7 +253,7 @@ tape( 'the created function evaluates the quantile for `r` given large `n` and s
 	for ( i = 0; i < r.length; i++ ) {
 		quantile = factory( n[i], p[i] );
 		y = quantile( r[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -274,7 +274,7 @@ tape( 'the created function evaluates the quantile for `r` given small `n` and l
 	for ( i = 0; i < r.length; i++ ) {
 		quantile = factory( n[i], p[i] );
 		y = quantile( r[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -295,7 +295,7 @@ tape( 'the created function evaluates the quantile for `r` given small `n` and `
 	for ( i = 0; i < r.length; i++ ) {
 		quantile = factory( n[i], p[i] );
 		y = quantile( r[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.quantile.js
index 14bf2d154792..ad546f67d7c3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.quantile.js
@@ -45,19 +45,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 20, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 20, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `r` and a valid `n` and `p`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 20, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 20, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a `n` which is not a nonnegative integer, the function return
 	var y;
 
 	y = quantile( 0.5, 10.5, 0.8 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 1.5, 0.8 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, PINF, 0.8 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, 0.8 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -2.0, 0.8 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -0.5, 0.8 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,16 +89,16 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the function retur
 	var y;
 
 	y = quantile( 0.5, 20, 1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -107,29 +107,29 @@ tape( 'if `p` equals `1.0`, the function evaluates a degenerate distribution cen
 	var y;
 
 	y = quantile( 0.3, 8, 1.0 );
-	t.equal( y, 8, 'returns expected value' );
+	t.strictEqual( y, 8, 'returns expected value' );
 
 	y = quantile( 0.9, 8, 1.0 );
-	t.equal( y, 8, 'returns expected value' );
+	t.strictEqual( y, 8, 'returns expected value' );
 
 	y = quantile( 1.1, 8, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1, 8, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'given valid parameters, the function returns 0 as the 0% quantile', function test( t ) {
 	var y = quantile( 0.0, 8, 0.5 );
-	t.equal( y, 0, 'returns expected value' );
+	t.strictEqual( y, 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'given valid parameters, the function returns n as the 100% quantile', function test( t ) {
 	var y = quantile( 1.0, 8, 0.5 );
-	t.equal( y, 8, 'returns expected value' );
+	t.strictEqual( y, 8, 'returns expected value' );
 	t.end();
 });
 
@@ -137,28 +137,28 @@ tape( 'if `p` or `n` equals `0`, the function evaluates a degenerate distributio
 	var y;
 
 	y = quantile( 0.3, 8, 0.0 );
-	t.equal( y, 0, 'returns expected value' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = quantile( 0.9, 8, 0.0 );
-	t.equal( y, 0, 'returns expected value' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = quantile( 1.1, 8, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1, 8, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.3, 0, 0.5 );
-	t.equal( y, 0, 'returns expected value' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = quantile( 0.9, 0, 0.5 );
-	t.equal( y, 0, 'returns expected value' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = quantile( 1.1, 0, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1, 0, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -177,7 +177,7 @@ tape( 'the function evaluates the quantile for `r` given large `n` and `p`', fun
 	p = highHigh.p;
 	for ( i = 0; i < r.length; i++ ) {
 		y = quantile( r[i], n[i], p[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -196,7 +196,7 @@ tape( 'the function evaluates the quantile for `r` given large `n` and small `p`
 	p = highSmall.p;
 	for ( i = 0; i < r.length; i++ ) {
 		y = quantile( r[i], n[i], p[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the function evaluates the quantile for `r` given small `n` and large `p`
 	p = smallHigh.p;
 	for ( i = 0; i < r.length; i++ ) {
 		y = quantile( r[i], n[i], p[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -234,7 +234,7 @@ tape( 'the function evaluates the quantile for `r` given small `n` and `p`', fun
 	p = smallSmall.p;
 	for ( i = 0; i < r.length; i++ ) {
 		y = quantile( r[i], n[i], p[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/skewness/test/test.js
index 069499a88674..e270e0a8b209 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/skewness/test/test.js
@@ -44,13 +44,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -59,19 +59,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = skewness( 1.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 2.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( PINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,16 +80,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = skewness( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, PINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the skewness of a binomial distribution', function t
 	for ( i = 0; i < n.length; i++ ) {
 		y = skewness( n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		}
 		else {
 			delta = abs( y - expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/skewness/test/test.native.js
index 481d37a34a94..0ac960a98756 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/skewness/test/test.native.js
@@ -55,7 +55,7 @@ tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function te
 	var v;
 
 	v = skewness( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -64,10 +64,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = skewness( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,16 +76,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = skewness( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, PINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -105,7 +105,7 @@ tape( 'the function returns the skewness of a binomial distribution', opts, func
 	for ( i = 0; i < n.length; i++ ) {
 		y = skewness( n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		}
 		else {
 			delta = abs( y - expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/stdev/test/test.js
index 5dfda1aec814..df010c3b8ac5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/stdev/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,19 +57,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = stdev( 1.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 2.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( PINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = stdev( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, PINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns the standard deviation of a binomial distribution',
 	p = data.p;
 	for ( i = 0; i < n.length; i++ ) {
 		y = stdev( n[i], p[i] );
-		t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/stdev/test/test.native.js
index 47297c8eda6d..7f8c4724b127 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/stdev/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,10 +63,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = stdev( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,16 +75,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = stdev( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, PINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -101,7 +101,7 @@ tape( 'the function returns the standard deviation of a binomial distribution',
 	p = data.p;
 	for ( i = 0; i < n.length; i++ ) {
 		y = stdev( n[i], p[i] );
-		t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/test/test.js
index 44b015d0c06c..ad61e6d72b8d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains binomial distribution functions', function test( t ) {
 	var keys = objectKeys( binomial );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/variance/test/test.js
index 21ed70349b9d..3a150f9298f6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/variance/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,19 +57,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = variance( 1.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 2.5, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( PINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = variance( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 20, NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 20, PINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns the variance of a binomial distribution', function t
 	p = data.p;
 	for ( i = 0; i < n.length; i++ ) {
 		y = variance( n[i], p[i] );
-		t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/variance/test/test.native.js
index 2b3d0126cc2c..df84b7fdd516 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/variance/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -60,10 +60,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = variance( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,10 +72,10 @@ tape( 'if provided `p < 0` or `p > 1`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = variance( 10, -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 10, 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function returns the variance of a binomial distribution', opts, func
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( n[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'n: '+n[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.cdf.js
index c078f88e10cb..0145a75b989b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.cdf.js
@@ -48,10 +48,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = cdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -60,13 +60,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = cdf( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,16 +75,16 @@ tape( 'if provided a number greater than or equal to one for `x` and a finite `c
 	var y;
 
 	y = cdf( PINF, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 100.0, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 10.0, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 1.0, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -93,16 +93,16 @@ tape( 'if provided a number less than or equal to zero for `x` and a finite `c`,
 	var y;
 
 	y = cdf( NINF, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -100.0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function evaluates the cdf for `x` given small parameter `c`', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. c:'+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. c:'+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
@@ -147,7 +147,7 @@ tape( 'the function evaluates the cdf for `x` given medium parameter `c`', funct
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. c:'+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. c:'+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.2 * EPS * abs( expected[ i ] );
@@ -172,7 +172,7 @@ tape( 'the function evaluates the cdf for `x` given large parameter `c`', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.9 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.factory.js
index af5a052a44b1..02e3520245d1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,15 +56,15 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,13 +75,13 @@ tape( 'if provided `c <= 0`, the created function always returns `NaN`', functio
 
 	cdf = factory( -1.0 );
 	y = cdf( 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,16 +92,16 @@ tape( 'if provided a finite `c`, the function returns a function which returns `
 
 	cdf = factory( 0.5 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 100.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 10.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -112,19 +112,19 @@ tape( 'if provided a finite `c`, the function returns a function which returns `
 
 	cdf = factory( 0.5 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -100.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -10.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -146,7 +146,7 @@ tape( 'the created function evaluates the cdf for `x` given small `c`', function
 		cdf = factory( c[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the created function evaluates the cdf for `x` given a medium `c`', funct
 		cdf = factory( c[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.2 * EPS * abs( expected[ i ] );
@@ -200,7 +200,7 @@ tape( 'the created function evaluates the cdf for `x` given a large `c`', functi
 		cdf = factory( c[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.9 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.js
index cef508494ff6..6a0dadf01d31 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.native.js
index 8f42f6cd57b7..1da2a3aa8dbc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.native.js
@@ -57,10 +57,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = cdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,13 +69,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = cdf( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,16 +84,16 @@ tape( 'if provided a number greater than or equal to one for `x` and a finite `c
 	var y;
 
 	y = cdf( PINF, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 100.0, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 10.0, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 1.0, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -102,16 +102,16 @@ tape( 'if provided a number less than or equal to zero for `x` and a finite `c`,
 	var y;
 
 	y = cdf( NINF, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -100.0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'the function evaluates the cdf for `x` given small parameter `c`', opts,
 		y = cdf( x[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[i] );
 				tol = 3.0 * EPS * abs( expected[i] );
@@ -159,7 +159,7 @@ tape( 'the function evaluates the cdf for `x` given medium parameter `c`', opts,
 		y = cdf( x[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[i] );
 				tol = 2.2 * EPS * abs( expected[i] );
@@ -186,7 +186,7 @@ tape( 'the function evaluates the cdf for `x` given large parameter `c`', opts,
 		y = cdf( x[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[i] );
 				tol = 1.9 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/test/test.js
index fe559641c86c..efaf0be7f9ef 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,13 +52,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', function test( t ) {
 	var v;
 
 	v = entropy( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the differential entropy of a Bradford distribution
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
@@ -106,7 +106,7 @@ tape( 'the function returns the differential entropy of a Bradford distribution
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 45.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/test/test.native.js
index 7c0add73a454..05a1b27c3bf4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/entropy/test/test.native.js
@@ -47,13 +47,13 @@ var largeC = require( './fixtures/python/large_c.json' );
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof entropy, 'function', 'main export is a function' );
+	t.strictEqual( typeof entropy, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var y = entropy( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,13 +61,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t
 	var v;
 
 	v = entropy( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function returns the differential entropy of a Bradford distribution
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1523.0 * EPS * abs( expected[ i ] );
@@ -108,7 +108,7 @@ tape( 'the function returns the differential entropy of a Bradford distribution
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 45.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/test/test.js
index 3e8cf878f48e..d1f077aa6b76 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,13 +51,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', function test( t ) {
 	var v;
 
 	v = mean( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns the expected value of a Bradford distribution', func
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 4.7 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/test/test.native.js
index 572c9f91e473..d5e521eca744 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mean/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,13 +60,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mean( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'the function returns the expected value of a Bradford distribution', opts
 	for ( i = 0; i < c.length; i++ ) {
 		y = mean( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 4.7 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/median/test/test.js
index ade2cc592b55..12e7ae682ec2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/median/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,13 +51,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', function test( t ) {
 	var v;
 
 	v = median( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns the median of a Bradford distribution', function tes
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 7.2 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/median/test/test.native.js
index 3a708f32f626..7331f9d9f59f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/median/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,13 +60,13 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var v;
 
 	v = median( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -75,13 +75,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t
 	var v;
 
 	v = median( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'the function returns the median of a Bradford distribution', opts, functi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 7.2 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/test/test.js
index 7271072e5913..6e6a83f86a71 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -45,13 +45,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', function test( t ) {
 	var v;
 
 	v = mode( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,7 +65,7 @@ tape( 'the function returns `0.0` as the mode of a Bradford distribution', funct
 
 	for ( i = 0; i < c.length; i++ ) {
 		y = mode( c[ i ] );
-		t.equal( y, 0.0, 'returns expected value' );
+		t.strictEqual( y, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/test/test.native.js
index 0e2796a3a62e..37f76ffaa3a2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/mode/test/test.native.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,13 +54,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t
 	var v;
 
 	v = mode( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns `0.0` as the mode of a Bradford distribution', opts,
 
 	for ( i = 0; i < c.length; i++ ) {
 		y = mode( c[ i ] );
-		t.equal( y, 0.0, 'returns expected value' );
+		t.strictEqual( y, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.factory.js
index b8332b47e884..1f067868c0ae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,15 +54,15 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -73,13 +73,13 @@ tape( 'if provided `c <= 0`, the created function always returns `NaN`', functio
 
 	pdf = factory( -1.0 );
 	y = pdf( 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -90,16 +90,16 @@ tape( 'if provided a valid `c`, the function returns a function which returns `0
 
 	pdf = factory( 1.0 );
 	y = pdf( -1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 1.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 10.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the created function evaluates the pdf for `x` given small `c`', function
 		pdf = factory( c[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -148,7 +148,7 @@ tape( 'the created function evaluates the pdf for `x` given a medium `c`', funct
 		pdf = factory( c[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.9 * EPS * abs( expected[ i ] );
@@ -175,7 +175,7 @@ tape( 'the created function evaluates the pdf for `x` given a large `c`', functi
 		pdf = factory( c[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.js
index 6e251f419cb8..6518984d716e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.native.js
index 1bb98f9e8931..d584687f93c3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.native.js
@@ -57,10 +57,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = pdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,13 +69,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = pdf( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,16 +84,16 @@ tape( 'if provided a number outside [0,1] for `x` and a valid `c`, the function
 	var y;
 
 	y = pdf( 2.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function evaluates the pdf for `x` given small parameter `c`', opts,
 		y = pdf( x[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[i] );
 				tol = 2.2 * EPS * abs( expected[i] );
@@ -141,7 +141,7 @@ tape( 'the function evaluates the pdf for `x` given medium parameter `c`', opts,
 		y = pdf( x[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[i] );
 				tol = 2.2 * EPS * abs( expected[i] );
@@ -168,7 +168,7 @@ tape( 'the function evaluates the pdf for `x` given large parameter `c`', opts,
 		y = pdf( x[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[i] );
 				tol = 2.2 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.pdf.js
index e9daf89bebd0..9fe2eedaba66 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.pdf.js
@@ -48,10 +48,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = pdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -60,13 +60,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pdf( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,16 +75,16 @@ tape( 'if provided a number outside [0,1] for `x` and a valid `c`, the function
 	var y;
 
 	y = pdf( 2.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function evaluates the pdf for `x` given small parameter `c`', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. c:'+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. c:'+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -129,7 +129,7 @@ tape( 'the function evaluates the pdf for `x` given medium parameter `c`', funct
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. c:'+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. c:'+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.9 * EPS * abs( expected[ i ] );
@@ -154,7 +154,7 @@ tape( 'the function evaluates the pdf for `x` given large parameter `c`', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.factory.js
index 4441730808c8..5c17d8b60b75 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,15 +54,15 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -74,13 +74,13 @@ tape( 'if provided `c <= 0`, the created function always returns `NaN`', functio
 	quantile = factory( -1.0 );
 
 	y = quantile( 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,16 +92,16 @@ tape( 'if provided a finite `c`, the function returns a function which returns `
 	quantile = factory( 1.0 );
 
 	y = quantile( -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 10.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'the created function evaluates the quantile for `p` given small `c`', fun
 		quantile = factory( c[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.2 * EPS * abs( expected[ i ] );
@@ -150,7 +150,7 @@ tape( 'the created function evaluates the quantile for `p` given a medium `c`',
 		quantile = factory( c[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.2 * EPS * abs( expected[ i ] );
@@ -177,7 +177,7 @@ tape( 'the created function evaluates the quantile for `p` given a large `c`', f
 		quantile = factory( c[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 4.8 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.js
index 6ad40b0c38e2..4e43d913089e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.native.js
index a205860f761f..40a794bee972 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.native.js
@@ -57,10 +57,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,13 +69,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = quantile( 0.5, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,16 +84,16 @@ tape( 'if provided a number outside `[0,1]` for `p` and a valid `c`, the functio
 	var y;
 
 	y = quantile( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.5, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( PINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function evaluates the quantile for `p` given small parameter `c`', o
 		y = quantile( p[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[i] );
 				tol = 3.2 * EPS * abs( expected[i] );
@@ -141,7 +141,7 @@ tape( 'the function evaluates the quantile for `p` given medium parameter `c`',
 		y = quantile( p[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[i] );
 				tol = 3.2 * EPS * abs( expected[i] );
@@ -168,7 +168,7 @@ tape( 'the function evaluates the quantile for `p` given large parameter `c`', o
 		y = quantile( p[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[i] );
 				tol = 4.8 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.quantile.js
index 4867f7efe63e..830decd5f2b4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.quantile.js
@@ -48,10 +48,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -60,13 +60,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = quantile( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,16 +75,16 @@ tape( 'if provided a number outside `[0,1]` for `p` and a valid `c`, the functio
 	var y;
 
 	y = quantile( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.5, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( PINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function evaluates the quantile for `p` given small parameter `c`', f
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+'. c:'+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+'. c:'+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.2 * EPS * abs( expected[ i ] );
@@ -129,7 +129,7 @@ tape( 'the function evaluates the quantile for `p` given medium parameter `c`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+'. c:'+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+'. c:'+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.2 * EPS * abs( expected[ i ] );
@@ -154,7 +154,7 @@ tape( 'the function evaluates the quantile for `p` given large parameter `c`', f
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+'. c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 4.8 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/skewness/test/test.js
index 64e7589db92d..baf81a830279 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/skewness/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -51,13 +51,13 @@ tape( 'if provided a shape parameter `c` that is not a positive number, the func
 	var v;
 
 	v = skewness( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns the skewness of a bradford distribution', function t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x:'+x[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x:'+x[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/skewness/test/test.native.js
index b30ef8b48391..c728b74077e0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/skewness/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,13 +60,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = skewness( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'the function returns the skewness of a Bradford distribution', opts, func
 	for ( i = 0; i < c.length; i++ ) {
 		y = skewness( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/test/test.js
index e4996ca1523f..940094f25914 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,13 +52,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', function test( t ) {
 	var v;
 
 	v = stdev( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the standard deviation of a Bradford distribution gi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
@@ -106,7 +106,7 @@ tape( 'the function returns the standard deviation of a Bradford distribution gi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 8.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/test/test.native.js
index 0e71bed75222..b6374a86a57b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,13 +61,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t
 	var v;
 
 	v = stdev( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function returns the standard deviation of a Bradford distribution gi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
@@ -115,7 +115,7 @@ tape( 'the function returns the standard deviation of a Bradford distribution gi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/variance/test/test.js
index e2e75c23336b..699332b3574a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/variance/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,13 +52,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', function test( t ) {
 	var v;
 
 	v = variance( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the variance of a Bradford distribution given small
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
@@ -106,7 +106,7 @@ tape( 'the function returns the variance of a Bradford distribution given large
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 15.2 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/variance/test/test.native.js
index d1c10b3c0529..2f16368c84b9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/variance/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,13 +61,13 @@ tape( 'if provided `c <= 0`, the function returns `NaN`', opts, function test( t
 	var v;
 
 	v = variance( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function returns the variance of a Bradford distribution given small
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
@@ -115,7 +115,7 @@ tape( 'the function returns the variance of a Bradford distribution given large
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.cdf.js
index 874a5f9ae7d8..da208be61c30 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `x0` and `gamma`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `x0` and `gamma`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', fu
 	var y;
 
 	y = cdf( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function evaluates the cdf for `x` given `x0` and `gamma` (large `gam
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -137,7 +137,7 @@ tape( 'the function evaluates the cdf for `x` given `x0` and `gamma` (`x0 < 0`)'
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the cdf for `x` given `x0` and `gamma` (`x0 > 0`)'
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.factory.js
index a2081b73cc9e..ae88da43f6dd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `x0` and `gamma`, the function returns a function whi
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `x0` and `gamma`, the function returns a function whi
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -105,33 +105,33 @@ tape( 'if provided a nonpositive `gamma`, the created function always returns `N
 
 	cdf = factory( 0.0, 0.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, -1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the created function evaluates the cdf for `x` given `x0` and `gamma` (la
 		cdf = factory( x0[i], gamma[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -184,7 +184,7 @@ tape( 'the created function evaluates the cdf for `x` given `x0` and `gamma` (`x
 		cdf = factory( x0[i], gamma[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -213,7 +213,7 @@ tape( 'the created function evaluates the cdf for `x` given `x0` and `gamma` (`x
 		cdf = factory( x0[i], gamma[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.native.js
index 036ac1a378c9..e2707c8fa0bf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `x0` and `gamma`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `x0` and `gamma`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', op
 	var y;
 
 	y = cdf( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function evaluates the cdf for `x` given `x0` and `gamma` (large `gam
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -146,7 +146,7 @@ tape( 'the function evaluates the cdf for `x` given `x0` and `gamma` (`x0 < 0`)'
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 750.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the function evaluates the cdf for `x` given `x0` and `gamma` (`x0 > 0`)'
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			/*
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/entropy/test/test.js
index e8113ba818f7..12ad9c4b120b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/entropy/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', fu
 	var y;
 
 	y = entropy( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns the differential entropy of a Cauchy distribution',
 	gamma = data.gamma;
 	for ( i = 0; i < x0.length; i++ ) {
 		y = entropy( x0[i], gamma[i] );
-		t.equal( y, expected[i], 'x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/entropy/test/test.native.js
index 8e076c784bd0..3f4a74f931c7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/entropy/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', op
 	var y;
 
 	y = entropy( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'the function returns the differential entropy of a Cauchy distribution',
 	gamma = data.gamma;
 	for ( i = 0; i < x0.length; i++ ) {
 		y = entropy( x0[i], gamma[i] );
-		t.equal( y, expected[i], 'x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.factory.js
index 2a02e3b313d6..422111f3fae0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `x0` and `gamma`, the function returns a function whi
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `x0` and `gamma`, the function returns a function whi
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -105,33 +105,33 @@ tape( 'if provided a nonpositive `gamma`, the created function always returns `N
 
 	logcdf = factory( 0.0, 0.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, -1.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the created function evaluates the logcdf for `x` given `x0` and `gamma`
 		logcdf = factory( x0[i], gamma[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 7.0 * EPS * abs( expected[ i ] );
@@ -184,7 +184,7 @@ tape( 'the created function evaluates the logcdf for `x` given `x0` and `gamma`
 		logcdf = factory( x0[i], gamma[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 7.0 * EPS * abs( expected[ i ] );
@@ -213,7 +213,7 @@ tape( 'the created function evaluates the logcdf for `x` given `x0` and `gamma`
 		logcdf = factory( x0[i], gamma[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 7.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.logcdf.js
index e7a762a622a4..b20b7127d274 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `x0` and `gamma`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `x0` and `gamma`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', fu
 	var y;
 
 	y = logcdf( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function evaluates the logcdf for `x` given `x0` and `gamma` (large `
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 7.0 * EPS * abs( expected[ i ] );
@@ -137,7 +137,7 @@ tape( 'the function evaluates the logcdf for `x` given `x0` and `gamma` (`x0 < 0
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 7.0 * EPS * abs( expected[ i ] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the logcdf for `x` given `x0` and `gamma` (`x0 > 0
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 7.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.native.js
index 29fb78d2df4d..75a5f9400ce5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `x0` and `gamma`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `x0` and `gamma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', op
 	var y;
 
 	y = logcdf( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function evaluates the logcdf for `x` given `x0` and `gamma` (large `
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 7.0 * EPS * abs( expected[ i ] );
@@ -146,7 +146,7 @@ tape( 'the function evaluates the logcdf for `x` given `x0` and `gamma` (`x0 < 0
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 300.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the function evaluates the logcdf for `x` given `x0` and `gamma` (`x0 > 0
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 220.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.factory.js
index 9e08ea7d7556..b702a3d2c04c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `x0` and `gamma`, the function returns a function whi
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `x0` and `gamma`, the function returns a function whi
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -105,33 +105,33 @@ tape( 'if provided a nonpositive `gamma`, the created function always returns `N
 
 	logpdf = factory( 0.0, 0.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, -1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the created function evaluates the logpdf for `x` given `x0` and `gamma`
 		logpdf = factory( x0[i], gamma[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 6.0 * EPS * abs( expected[ i ] );
@@ -184,7 +184,7 @@ tape( 'the created function evaluates the logpdf for `x` given `x0` and `gamma`
 		logpdf = factory( x0[i], gamma[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -213,7 +213,7 @@ tape( 'the created function evaluates the logpdf for `x` given `x0` and `gamma`
 		logpdf = factory( x0[i], gamma[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.logpdf.js
index 504066eef143..07aa99ced7bb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.logpdf.js
@@ -48,38 +48,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `x0` and `gamma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `x0` and `gamma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -87,25 +87,25 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', fu
 	var y;
 
 	y = logpdf( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function evaluates the logpdf for `x` given `x0` and `gamma` (large `
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 6.0 * EPS * abs( expected[ i ] );
@@ -154,7 +154,7 @@ tape( 'the function evaluates the logpdf for `x` given `x0` and `gamma` (`x0 < 0
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the function evaluates the logpdf for `x` given `x0` and `gamma` (`x0 > 0
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.native.js
index 10e26cef51ee..c45d02f65def 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.native.js
@@ -57,38 +57,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `x0` and `gamma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `x0` and `gamma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -96,25 +96,25 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', op
 	var y;
 
 	y = logpdf( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -136,7 +136,7 @@ tape( 'the function evaluates the logpdf for `x` given `x0` and `gamma` (large `
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 6.0 * EPS * abs( expected[ i ] );
@@ -163,7 +163,7 @@ tape( 'the function evaluates the logpdf for `x` given `x0` and `gamma` (`x0 < 0
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -190,7 +190,7 @@ tape( 'the function evaluates the logpdf for `x` given `x0` and `gamma` (`x0 > 0
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/median/test/test.js
index 428fa587116c..281b41e57787 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/median/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', fu
 	var y;
 
 	y = median( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns the median of a Cauchy distribution', function test(
 	gamma = data.gamma;
 	for ( i = 0; i < x0.length; i++ ) {
 		y = median( x0[i], gamma[i] );
-		t.equal( y, expected[i], 'x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/median/test/test.native.js
index ec778890e6e3..98b2c37f3b16 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/median/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', op
 	var y;
 
 	y = median( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'the function returns the median of a Cauchy distribution', opts, function
 	gamma = data.gamma;
 	for ( i = 0; i < x0.length; i++ ) {
 		y = median( x0[i], gamma[i] );
-		t.equal( y, expected[i], 'x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/mode/test/test.js
index 0c434cf3be07..c5dd15c7ff08 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/mode/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', fu
 	var y;
 
 	y = mode( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns the mode of a Cauchy distribution', function test( t
 	gamma = data.gamma;
 	for ( i = 0; i < x0.length; i++ ) {
 		y = mode( x0[i], gamma[i] );
-		t.equal( y, expected[i], 'x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/mode/test/test.native.js
index ed674a1b744d..0eaa312e89ca 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/mode/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NaN, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', op
 	var y;
 
 	y = mode( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'the function returns the mode of a Cauchy distribution', opts, function t
 	gamma = data.gamma;
 	for ( i = 0; i < x0.length; i++ ) {
 		y = mode( x0[i], gamma[i] );
-		t.equal( y, expected[i], 'x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.factory.js
index 34b14442c7a0..5cd06f123d48 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `x0` and `gamma`, the function returns a function whi
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `x0` and `gamma`, the function returns a function whi
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -105,33 +105,33 @@ tape( 'if provided a nonpositive `gamma`, the created function always returns `N
 
 	pdf = factory( 0.0, 0.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, -1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the created function evaluates the pdf for `x` given `x0` and `gamma` (la
 		pdf = factory( x0[i], gamma[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -184,7 +184,7 @@ tape( 'the created function evaluates the pdf for `x` given `x0` and `gamma` (`x
 		pdf = factory( x0[i], gamma[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -213,7 +213,7 @@ tape( 'the created function evaluates the pdf for `x` given `x0` and `gamma` (`x
 		pdf = factory( x0[i], gamma[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.native.js
index c41300878789..d8b355e9ab90 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.native.js
@@ -55,38 +55,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `x0` and `gamma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `x0` and `gamma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -94,25 +94,25 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', op
 	var y;
 
 	y = pdf( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function evaluates the pdf for `x` given `x0` and `gamma` (large `gam
 	gamma = largeGamma.gamma;
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], x0[i], gamma[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -150,7 +150,7 @@ tape( 'the function evaluates the pdf for `x` given `x0` and `gamma` (`x0 < 0`)'
 	gamma = negativeMedian.gamma;
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], x0[i], gamma[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -169,7 +169,7 @@ tape( 'the function evaluates the pdf for `x` given `x0` and `gamma` (`x0 > 0`)'
 	gamma = positiveMedian.gamma;
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], x0[i], gamma[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.pdf.js
index cfc2a3653953..dae90e1df6ae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.pdf.js
@@ -46,38 +46,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `x0` and `gamma`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `x0` and `gamma`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -85,25 +85,25 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', fu
 	var y;
 
 	y = pdf( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function evaluates the pdf for `x` given `x0` and `gamma` (large `gam
 	gamma = largeGamma.gamma;
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], x0[i], gamma[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the function evaluates the pdf for `x` given `x0` and `gamma` (`x0 < 0`)'
 	gamma = negativeMedian.gamma;
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], x0[i], gamma[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -160,7 +160,7 @@ tape( 'the function evaluates the pdf for `x` given `x0` and `gamma` (`x0 > 0`)'
 	gamma = positiveMedian.gamma;
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], x0[i], gamma[i] );
-		t.equal( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', x0 :'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.factory.js
index 81d886936a34..aa35d8774503 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `x0` and `gamma`, the function returns a function wh
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,33 +97,33 @@ tape( 'if provided a nonpositive `gamma`, the created function always returns `N
 
 	quantile = factory( 0.0, -1.0 );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, 0.0 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -170,7 +170,7 @@ tape( 'the created function evaluates the quantile function at `p` given paramet
 		quantile = factory( x0[i], gamma[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
@@ -199,7 +199,7 @@ tape( 'the created function evaluates the quantile function at `p` given `x0` an
 		quantile = factory( x0[i], gamma[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 125.0 * EPS * abs( expected[ i ] );
@@ -228,7 +228,7 @@ tape( 'the created function evaluates the quantile function at `p` given `x0` an
 		quantile = factory( x0[i], gamma[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', x0: '+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.native.js
index 5dbc1bcec805..e01cc62502f9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `x0` and `gamma`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( PINF, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( PINF, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -75,28 +75,28 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', op
 	var y;
 
 	y = quantile( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the function evaluates the quantile function at `p` given `x0` and `gamma
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
@@ -168,7 +168,7 @@ tape( 'the function evaluates the quantile function at `p` given `x0` and `gamma
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 125.0 * EPS * abs( expected[ i ] );
@@ -195,7 +195,7 @@ tape( 'the function evaluates the quantile function at `p` given `x0` and `gamma
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 90.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.quantile.js
index ef8947fbbbbd..96e2b96e6263 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `x0` and `gamma`, the function returns `NaN`', function test( t ) {
 	var y = quantile( PINF, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( PINF, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,28 +66,28 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', fu
 	var y;
 
 	y = quantile( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'the function evaluates the quantile function at `p` given `x0` and `gamma
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
@@ -159,7 +159,7 @@ tape( 'the function evaluates the quantile function at `p` given `x0` and `gamma
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 125.0 * EPS * abs( expected[ i ] );
@@ -186,7 +186,7 @@ tape( 'the function evaluates the quantile function at `p` given `x0` and `gamma
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], x0[i], gamma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', x0:'+x0[i]+', gamma: '+gamma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/test/test.js
index df95c63c7315..8f83c122149d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Cauchy distribution functions', function test( t ) {
 	var keys = objectKeys( cauchy );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.cdf.js
index 11c565ad625c..77dbb602d1d3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.cdf.js
@@ -44,21 +44,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `k`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `k`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -66,13 +66,13 @@ tape( 'if provided a negative `k`, the function always returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,22 +81,22 @@ tape( 'if provided a `k` equal to `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = cdf( PINF, 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 2.5, 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( -2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( NINF, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function evaluates the cdf for `x` given degrees of freedom `k`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 70.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.factory.js
index a58994bd9927..9b4a79b2d762 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	cdf = factory( 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -92,10 +92,10 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	cdf = factory( -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -107,22 +107,22 @@ tape( 'if `k` equals `0`, the created function evaluates a degenerate distributi
 	cdf = factory( 0.0 );
 
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 3.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( -0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'the created function evaluates the cdf for `x` given degrees of freedom `
 		cdf = factory( k[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 70.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.native.js
index 295cf43e0f76..586a0bcf2625 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.native.js
@@ -47,7 +47,7 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof cdf, 'function', 'main export is a function' );
+	t.strictEqual( typeof cdf, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -55,10 +55,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = cdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,13 +67,13 @@ tape( 'if provided a negative `k`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -82,13 +82,13 @@ tape( 'if provided `k` equal to `0`, the function returns `0` for negative `x` a
 	var y;
 
 	y = cdf( -2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 0.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -97,20 +97,20 @@ tape( 'if provided a nonpositive `x`, the function returns `0`', opts, function
 	var y;
 
 	y = cdf( -1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite positive `k`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
@@ -129,7 +129,7 @@ tape( 'the function evaluates the cdf for `x` given parameter `k`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 70.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chi/entropy/test/test.js
index 3d86a688db79..117490834d2b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/entropy/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,13 +51,13 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a positive num
 	var v;
 
 	v = entropy( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns the differential entropy of a chi distribution', fun
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/entropy/test/test.native.js
index 389a41171862..7641ec9aa32d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/entropy/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,13 +60,13 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a positive num
 	var v;
 
 	v = entropy( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'the function returns the differential entropy of a chi distribution', opt
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chi/kurtosis/test/test.js
index c39101feb50a..062fbe2f3d97 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/kurtosis/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,13 +50,13 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a positive num
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns the excess kurtosis of a chi distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1e-8 * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/kurtosis/test/test.native.js
index 34514d4baad1..5ca82b0a697b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/kurtosis/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for the parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a non-positive `k`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = kurtosis( -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the excess kurtosis of a chi distribution', opts, fu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1e-8 * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.factory.js
index 49dc23fdf14d..04ae13e06c3e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	logpdf = factory( 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -93,10 +93,10 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	logpdf = factory( -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -108,22 +108,22 @@ tape( 'if `k` equals `0`, the created function evaluates a degenerate distributi
 	logpdf = factory( 0.0 );
 
 	y = logpdf( -2.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = logpdf( 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the returned function returns `-Infinity` for all `x < 0`', function test
 	for ( i = 0; i < 100; i++ ) {
 		x = -( randu()*100.0 ) - EPS;
 		y = logpdf( x );
-		t.equal( y, NINF, 'returns expected value' );
+		t.strictEqual( y, NINF, 'returns expected value' );
 	}
 	t.end();
 });
@@ -160,7 +160,7 @@ tape( 'the created function evaluates the logpdf for `x` given degrees of freedo
 		logpdf = factory( k[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.logpdf.js
index b1bb48ba460e..66cee1a80b35 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.logpdf.js
@@ -45,21 +45,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `k`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `k`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -67,13 +67,13 @@ tape( 'if provided a negative `k`, the function always returns `NaN`', function
 	var y;
 
 	y = logpdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,22 +82,22 @@ tape( 'if `k` equals `0`, the function evaluates a degenerate distribution cente
 	var y;
 
 	y = logpdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns Infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns Infinity for x equal to 0' );
 
 	y = logpdf( 1.0, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -1.5, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function returns `-Infinity` for all `x < 0`', function test( t ) {
 	for ( i = 0; i < 100; i++ ) {
 		x = -( randu()*100.0 ) - EPS;
 		y = logpdf( x, 1.0 );
-		t.equal( y, NINF, 'returns expected value' );
+		t.strictEqual( y, NINF, 'returns expected value' );
 	}
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function evaluates the logpdf for `x` given degrees of freedom `k`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.native.js
index 4410aa81e01a..524b8f26c6c5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,10 +63,10 @@ tape( 'if provided a non-positive `k`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = logpdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, -2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -75,23 +75,23 @@ tape( 'if provided `k` equal to 0, the function returns `+infinity` or `-infinit
 	var y;
 
 	y = logpdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns +infinity' );
 
 	y = logpdf( 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `k`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `k`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
@@ -110,7 +110,7 @@ tape( 'the function evaluates the logpdf for given `x` and `k`', opts, function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[ i ], k[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: ' + x[ i ] + ', k: ' + k[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: ' + x[ i ] + ', k: ' + k[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] ); // Higher tolerance needed due to accumulated floating-point precision differences between JS and C implementations
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chi/mean/test/test.js
index 9a8ee1414673..a3b3fbfc61af 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/mean/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a nonnegative
 	var v;
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'the function returns the expected value of a chi distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/mean/test/test.native.js
index 44bad1cb75b9..55f6ba5f110e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/mean/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for the parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,10 +59,10 @@ tape( 'if provided a non-positive `k`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = mean( -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'the function returns the expected value of a chi distribution', opts, fun
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chi/mode/test/test.js
index bb040e21c25f..f49bc7ce3244 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/mode/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,16 +49,16 @@ tape( 'if provided a degrees of freedom parameter `k` that is smaller than one,
 	var v;
 
 	v = mode( 0.8 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'the function returns the mode of a chi distribution', function test( t )
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/mode/test/test.native.js
index 436ee6096a72..a2ce9f09d815 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/mode/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,16 +58,16 @@ tape( 'if provided a degrees of freedom parameter `k` that is smaller than one,
 	var v;
 
 	v = mode( 0.8 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,7 +82,7 @@ tape( 'the function returns the mode of a chi distribution', opts, function test
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.factory.js
index da15a3d6511d..a5e4fab68114 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	pdf = factory( 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	pdf = factory( 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -93,10 +93,10 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	pdf = factory( -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -108,22 +108,22 @@ tape( 'if `k` equals `0`, the created function evaluates a degenerate distributi
 	pdf = factory( 0.0 );
 
 	y = pdf( -2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = pdf( 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the returned function returns `0` for all `x < 0`', function test( t ) {
 	for ( i = 0; i < 100; i++ ) {
 		x = -( randu()*100.0 ) - EPS;
 		y = pdf( x );
-		t.equal( y, 0.0, 'returns expected value' );
+		t.strictEqual( y, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -160,7 +160,7 @@ tape( 'the created function evaluates the pdf for `x` given degrees of freedom `
 		pdf = factory( k[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 140.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.native.js
index 307fdbb8ab2a..5f3439078ff9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,7 +63,7 @@ tape( 'if provided a negative `k`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -72,23 +72,23 @@ tape( 'if `k` equals `0`, the function evaluates a degenerate distribution cente
 	var y;
 
 	y = pdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `k`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `k`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -107,7 +107,7 @@ tape( 'the function evaluates the pdf for `x` given degrees of freedom `k`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 140.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.pdf.js
index 460ad02d3218..ff7f5c57395c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.pdf.js
@@ -45,21 +45,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `k`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `k`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -67,13 +67,13 @@ tape( 'if provided a negative `k`, the function always returns `NaN`', function
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,22 +82,22 @@ tape( 'if `k` equals `0`, the function evaluates a degenerate distribution cente
 	var y;
 
 	y = pdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 1.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -1.5, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function returns `0` for all `x < 0`', function test( t ) {
 	for ( i = 0; i < 100; i++ ) {
 		x = -( randu()*100.0 ) - EPS;
 		y = pdf( x, 1.0 );
-		t.equal( y, 0.0, 'returns expected value' );
+		t.strictEqual( y, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function evaluates the pdf for `x` given degrees of freedom `k`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 140.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.factory.js
index 53876d891da1..590471a15cbf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.factory.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -52,11 +52,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -67,10 +67,10 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	quantile = factory( 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,10 +82,10 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	quantile = factory( -1.0 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,16 +97,16 @@ tape( 'if `k` equals `0`, the created function evaluates a degenerate distributi
 	quantile = factory( 0.0 );
 
 	y = quantile( 0.3 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = quantile( 0.9 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the created function evaluates the quantile for `x` given parameter `k`',
 		quantile = factory( k[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.quantile.js
index 250a3459257b..f1866b5d8b58 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.quantile.js
@@ -43,17 +43,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `k`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 2.2, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.2, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,13 +61,13 @@ tape( 'if provided a negative `k`, the function always returns `NaN`', function
 	var y;
 
 	y = quantile( 0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,16 +76,16 @@ tape( 'if `k` equals `0`, the function evaluates a degenerate distribution cente
 	var y;
 
 	y = quantile( 0.3, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = quantile( 0.9, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = quantile( 1.1, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -105,7 +105,7 @@ tape( 'the function evaluates the quantile for `x` given degrees of freedom `k`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chi/skewness/test/test.js
index 9d96eb362238..d0de850de6ef 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/skewness/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,13 +50,13 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a positive num
 	var v;
 
 	v = skewness( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns the skewness of a chi distribution', function test(
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1e-11 * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/skewness/test/test.native.js
index ab22b9922774..2e2abe0e9b32 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/skewness/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for the parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a non-positive `k`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = skewness( -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the skewness of a chi distribution', opts, function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1e-11 * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chi/stdev/test/test.js
index fe75388c67f0..74c5ebf69721 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/stdev/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a nonnegative
 	var v;
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'the function returns the standard deviation of a chi distribution', funct
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/stdev/test/test.native.js
index 73f0f12ec691..3392dad80690 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/stdev/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a nonnegative
 	var v;
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the standard deviation of a chi distribution', opts,
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chi/test/test.js
index 0b199015f409..c64241c7ef5e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains chi distribution functions', function test( t ) {
 	var keys = objectKeys( chi );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chi/variance/test/test.js
index ce49e05885fa..f368fa8966c0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/variance/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a nonnegative
 	var v;
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'the function returns the variance of a chi distribution', function test(
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/variance/test/test.native.js
index e3a9b165493b..be5bfc8bbbd7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/variance/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a nonnegative
 	var v;
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the variance of a chi distribution', opts, function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.cdf.js
index 6064fb343c88..62123dc1b3ca 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.cdf.js
@@ -44,21 +44,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `k`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `k`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -66,13 +66,13 @@ tape( 'if provided a negative `k`, the function always returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,22 +81,22 @@ tape( 'if provided a `k` equal to `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = cdf( PINF, 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 2.5, 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( -2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( NINF, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function evaluates the cdf for `x` given degrees of freedom `k`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.factory.js
index 71c24dede44c..59c04a21d0ac 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	cdf = factory( 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -92,10 +92,10 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	cdf = factory( -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -107,22 +107,22 @@ tape( 'if `k` equals `0`, the created function evaluates a degenerate distributi
 	cdf = factory( 0.0 );
 
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 3.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( -0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'the created function evaluates the cdf for `x` given degrees of freedom `
 		cdf = factory( k[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.native.js
index b2379fbe4b01..45ea427b75e8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.native.js
@@ -47,7 +47,7 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof cdf, 'function', 'main export is a function' );
+	t.strictEqual( typeof cdf, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -55,23 +55,23 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = cdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `k`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `k`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,13 +79,13 @@ tape( 'if provided a negative `k`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -105,7 +105,7 @@ tape( 'the function evaluates the cdf for `x` given `k`', opts, function test( t
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/entropy/test/test.js
index 45c97fabc537..44ed334172d1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/entropy/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,13 +51,13 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a positive num
 	var v;
 
 	v = entropy( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns the differential entropy of a chi-squared distributi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 15.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/entropy/test/test.native.js
index a036fa491e5f..49a982cce51e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/entropy/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,13 +60,13 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a positive num
 	var v;
 
 	v = entropy( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'the function returns the differential entropy of a chi-squared distributi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/kurtosis/test/test.js
index 23fe177039e5..8e3791a88a5f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/kurtosis/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,13 +49,13 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a positive num
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'the function returns the excess kurtosis of a chi-squared distribution',
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/kurtosis/test/test.native.js
index 9d4220553b30..500bcf420b3b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/kurtosis/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,13 +58,13 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a positive num
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the excess kurtosis of a chi-squared distribution',
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.factory.js
index f046f28a10a9..678cf77c37fe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	logpdf = factory( 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -93,10 +93,10 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	logpdf = factory( -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -108,22 +108,22 @@ tape( 'if `k` equals `0`, the created function evaluates a degenerate distributi
 	logpdf = factory( 0.0 );
 
 	y = logpdf( -2.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = logpdf( 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the returned function returns `-Infinity` for all `x < 0`', function test
 	for ( i = 0; i < 100; i++ ) {
 		x = -( randu()*100.0 ) - EPS;
 		y = logpdf( x );
-		t.equal( y, NINF, 'returns expected value' );
+		t.strictEqual( y, NINF, 'returns expected value' );
 	}
 	t.end();
 });
@@ -160,7 +160,7 @@ tape( 'the created function evaluates the logpdf for `x` given degrees of freedo
 		logpdf = factory( k[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.logpdf.js
index 0bf624f080ce..d7f2ed19aa0d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.logpdf.js
@@ -45,21 +45,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `k`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `k`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -67,13 +67,13 @@ tape( 'if provided a negative `k`, the function always returns `NaN`', function
 	var y;
 
 	y = logpdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,22 +82,22 @@ tape( 'if `k` equals `0`, the function evaluates a degenerate distribution cente
 	var y;
 
 	y = logpdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = logpdf( 1.0, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -1.5, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function returns `-Infinity` for all `x < 0`', function test( t ) {
 	for ( i = 0; i < 100; i++ ) {
 		x = -( randu()*100.0 ) - EPS;
 		y = logpdf( x, 1.0 );
-		t.equal( y, NINF, 'returns expected value' );
+		t.strictEqual( y, NINF, 'returns expected value' );
 	}
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function evaluates the logpdf for `x` given degrees of freedom `k`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mean/test/test.js
index 82135e1990c8..e386ce5c4311 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mean/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a nonnegative
 	var v;
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the expected value of a chi-squared distribution', f
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mean/test/test.native.js
index 1484696d4d8f..54a2a2261da9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mean/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a nonnegative
 	var v;
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the expected value of a chi-squared distribution', o
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/median/test/test.js
index 990224a7f22a..da3146a975b3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/median/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var k = median( NaN );
-	t.equal( isnan( k ), true, 'returns expected value' );
+	t.strictEqual( isnan( k ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a degrees of freedom `k` that is not a nonnegative number, th
 	var k;
 
 	k = median( -1.0 );
-	t.equal( isnan( k ), true, 'returns expected value' );
+	t.strictEqual( isnan( k ), true, 'returns expected value' );
 
 	k = median( NINF );
-	t.equal( isnan( k ), true, 'returns expected value' );
+	t.strictEqual( isnan( k ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'the function returns the median of chi-squared distribution', function te
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 25.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.factory.js
index 12d3fe2294b7..9c996cf207cb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.factory.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -52,11 +52,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 1.0 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -68,10 +68,10 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	mgf = factory( -1.0 );
 
 	y = mgf( 0.4 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a `t >= 0.5`, the created function always returns `NaN`', fun
 	mgf = factory( 1.0 );
 
 	y = mgf( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -108,7 +108,7 @@ tape( 'the created function evaluates the MGF for `x` given degrees of freedom `
 		mgf = factory( k[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.mgf.js
index 8254846c4699..0ddbc6a0eee0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.mgf.js
@@ -43,9 +43,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -53,13 +53,13 @@ tape( 'if provided a negative `k`, the function always returns `NaN`', function
 	var y;
 
 	y = mgf( 0.4, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.4, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -68,13 +68,13 @@ tape( 'if provided `t >= 0.5`, the function always returns `NaN`', function test
 	var y;
 
 	y = mgf( 0.5, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 10.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function evaluates the MGF for `x` given degrees of freedom `k`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.native.js
index ca491b1b8173..f618cce17b88 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.native.js
@@ -52,9 +52,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -62,13 +62,13 @@ tape( 'if provided a negative `k`, the function always returns `NaN`', opts, fun
 	var y;
 
 	y = mgf( 0.4, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.4, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,13 +77,13 @@ tape( 'if provided `t >= 0.5`, the function always returns `NaN`', opts, functio
 	var y;
 
 	y = mgf( 0.5, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 10.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function evaluates the MGF for `x` given degrees of freedom `k`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mode/test/test.js
index 989d83e49557..72369f3ae705 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mode/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a nonnegative
 	var v;
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the mode of a chi-squared distribution', function te
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mode/test/test.native.js
index 96ea23f973fa..4946dfdea6ae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mode/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a nonnegative
 	var v;
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the mode of a chi-squared distribution', opts, funct
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.factory.js
index 224ca4c1628d..9515601e018b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	pdf = factory( 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	pdf = factory( 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -93,10 +93,10 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	pdf = factory( -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -108,22 +108,22 @@ tape( 'if `k` equals `0`, the created function evaluates a degenerate distributi
 	pdf = factory( 0.0 );
 
 	y = pdf( -2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = pdf( 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the returned function returns `0` for all `x < 0`', function test( t ) {
 	for ( i = 0; i < 100; i++ ) {
 		x = -( randu()*100.0 ) - EPS;
 		y = pdf( x );
-		t.equal( y, 0.0, 'returns expected value' );
+		t.strictEqual( y, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -160,7 +160,7 @@ tape( 'the created function evaluates the pdf for `x` given degrees of freedom `
 		pdf = factory( k[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.pdf.js
index 8fae16c0f10c..c574416262ca 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.pdf.js
@@ -45,21 +45,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `k`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `k`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -67,13 +67,13 @@ tape( 'if provided a negative `k`, the function always returns `NaN`', function
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,22 +82,22 @@ tape( 'if `k` equals `0`, the function evaluates a degenerate distribution cente
 	var y;
 
 	y = pdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = pdf( 1.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -1.5, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function returns `0` for all `x < 0`', function test( t ) {
 	for ( i = 0; i < 100; i++ ) {
 		x = -( randu()*100.0 ) - EPS;
 		y = pdf( x, 1.0 );
-		t.equal( y, 0.0, 'returns expected value' );
+		t.strictEqual( y, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function evaluates the pdf for `x` given degrees of freedom `k`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. k:'+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.factory.js
index 53876d891da1..590471a15cbf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.factory.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -52,11 +52,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -67,10 +67,10 @@ tape( 'if provided a finite `k`, the function returns a function which returns `
 
 	quantile = factory( 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,10 +82,10 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	quantile = factory( -1.0 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,16 +97,16 @@ tape( 'if `k` equals `0`, the created function evaluates a degenerate distributi
 	quantile = factory( 0.0 );
 
 	y = quantile( 0.3 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = quantile( 0.9 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the created function evaluates the quantile for `x` given parameter `k`',
 		quantile = factory( k[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.quantile.js
index 250a3459257b..f1866b5d8b58 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.quantile.js
@@ -43,17 +43,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `k`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 2.2, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.2, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,13 +61,13 @@ tape( 'if provided a negative `k`, the function always returns `NaN`', function
 	var y;
 
 	y = quantile( 0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,16 +76,16 @@ tape( 'if `k` equals `0`, the function evaluates a degenerate distribution cente
 	var y;
 
 	y = quantile( 0.3, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = quantile( 0.9, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = quantile( 1.1, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -105,7 +105,7 @@ tape( 'the function evaluates the quantile for `x` given degrees of freedom `k`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], k[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/skewness/test/test.js
index 85281e51f063..8f35db78ea1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/skewness/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,13 +49,13 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a positive num
 	var v;
 
 	v = skewness( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'the function returns the skewness of a chi-squared distribution', functio
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/skewness/test/test.native.js
index 817ae411cc28..f06de1e4519b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/skewness/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,13 +58,13 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a positive num
 	var v;
 
 	v = skewness( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the skewness of a chi-squared distribution', opts, f
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/stdev/test/test.js
index 4fed2caaa0c1..0ebe6323e90c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/stdev/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a nonnegative
 	var v;
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the standard deviation of a chi-squared distribution
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/stdev/test/test.native.js
index 25ab715e1b6c..8ca319cef37a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/stdev/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a nonnegative
 	var v;
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the standard deviation of a chi-squared distribution
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/test/test.js
index 4476d21f6776..293b5a7e6de3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains chi-squared distribution functions', function test( t ) {
 	var keys = objectKeys( chisquare );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/variance/test/test.js
index 1db6d938a857..90ffcd41dbc6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/variance/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a nonnegative
 	var v;
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the variance of a chi-squared distribution', functio
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/variance/test/test.native.js
index 601d615a4613..8822d43d61c5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/variance/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `k`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a degrees of freedom parameter `k` that is not a nonnegative
 	var v;
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the variance of a chi-squared distribution', opts, f
 	k = data.k;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.cdf.js
index e64aca2337b8..bf25142f39c9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,13 +94,13 @@ tape( 'if provided `s` equals `0`, the function evaluates a degenerate distribut
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function evaluates the cdf for `x` given positive `mu`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -149,7 +149,7 @@ tape( 'the function evaluates the cdf for `x` given negative `mu`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -176,7 +176,7 @@ tape( 'the function evaluates the cdf for `x` given large variance ( = large `s`
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.factory.js
index 3116f000e49d..c1dfd6080877 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `mu` and `s`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `mu` and `s`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -137,13 +137,13 @@ tape( 'if `s` equals `0`, the created function evaluates a degenerate distributi
 	cdf = factory( 2.0, 0.0 );
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -167,7 +167,7 @@ tape( 'the created function evaluates the cdf for `x` given positive `mu`', func
 		cdf = factory( mu[i], s[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -196,7 +196,7 @@ tape( 'the created function evaluates the cdf for `x` given negative `mu`', func
 		cdf = factory( mu[i], s[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -225,7 +225,7 @@ tape( 'the created function evaluates the cdf for `x` given large variance ( = l
 		cdf = factory( mu[i], s[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.native.js
index 82e0ae43a34f..9446339a6f35 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -103,13 +103,13 @@ tape( 'if provided `s` equals `0`, the function evaluates a degenerate distribut
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function evaluates the cdf for `x` given positive `mu`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the cdf for `x` given negative `mu`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the cdf for `x` given large variance ( = large `s`
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/kurtosis/test/test.js
index 8e1e585a667e..e4574d8a667e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/kurtosis/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the excess kurtosis of a raised cosine distribution'
 	for ( i = 0; i < mu.length; i++ ) {
 		y = kurtosis( mu[i], s[i] );
 		if ( expected[i] !== null ) {
-			t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/kurtosis/test/test.native.js
index 71e484e716d6..4796b124c499 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/kurtosis/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns the excess kurtosis of a raised cosine distribution'
 	for ( i = 0; i < mu.length; i++ ) {
 		y = kurtosis( mu[i], s[i] );
 		if ( expected[i] !== null ) {
-			t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.factory.js
index 50c7890268e4..b46cb94e4c99 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `mu` and `s`, the function returns a function which r
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `mu` and `s`, the function returns a function which r
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	logcdf = factory( 0.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -137,13 +137,13 @@ tape( 'if `s` equals `0`, the created function evaluates a degenerate distributi
 	logcdf = factory( 2.0, 0.0 );
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -167,7 +167,7 @@ tape( 'the created function evaluates the logcdf for `x` given positive `mu`', f
 		logcdf = factory( mu[i], s[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 600.0 * EPS * abs( expected[ i ] );
@@ -196,7 +196,7 @@ tape( 'the created function evaluates the logcdf for `x` given negative `mu`', f
 		logcdf = factory( mu[i], s[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 600.0 * EPS * abs( expected[ i ] );
@@ -225,7 +225,7 @@ tape( 'the created function evaluates the logcdf for `x` given large variance (
 		logcdf = factory( mu[i], s[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 800.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.logcdf.js
index b7b1c92d9890..bffa4337f8d4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `-infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,13 +94,13 @@ tape( 'if provided `s` equals `0`, the function evaluates a degenerate distribut
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function evaluates the logcdf for `x` given positive `mu`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 600.0 * EPS * abs( expected[ i ] );
@@ -149,7 +149,7 @@ tape( 'the function evaluates the logcdf for `x` given negative `mu`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 600.0 * EPS * abs( expected[ i ] );
@@ -176,7 +176,7 @@ tape( 'the function evaluates the logcdf for `x` given large variance ( = large
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 800.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.native.js
index cba2f2cb820e..f7d1c3900248 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -103,13 +103,13 @@ tape( 'if provided `s` equals `0`, the function evaluates a degenerate distribut
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function evaluates the logcdf for `x` given positive `mu`', opts, fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 600.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the logcdf for `x` given negative `mu`', opts, fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 600.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the logcdf for `x` given large variance ( = large
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 800.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.factory.js
index b76c9a1029ff..9eb07299a9e8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,13 +84,13 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 	logpdf = factory( 0.0, 1.0 );
 
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 2.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 20.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -101,13 +101,13 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -2.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -20.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -119,26 +119,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -150,19 +150,19 @@ tape( 'if `s` equals `0`, the created function evaluates a degenerate distributi
 	logpdf = factory( 2.0, 0.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = logpdf( 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -187,7 +187,7 @@ tape( 'the created function evaluates the logpdf for `x` given positive `mu`', f
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -218,7 +218,7 @@ tape( 'the created function evaluates the logpdf for `x` given negative `mu`', f
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -249,7 +249,7 @@ tape( 'the created function evaluates the logpdf for `x` given large variance (
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 15.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.logpdf.js
index 0ff9b30d133f..35af3e661a7b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.logpdf.js
@@ -46,36 +46,36 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `x` greater than `mu + s`, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 20.0, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 2.0, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `x` smaller than `mu - s`, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	logpdf( -20.0, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	logpdf( -2.0, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -84,22 +84,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -108,19 +108,19 @@ tape( 'if provided `s` equal to `0`, the function evaluates a degenerate distrib
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = logpdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns expected value ' );
+	t.strictEqual( y, NINF, 'returns expected value ' );
 
 	y = logpdf( PINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns expected value ' );
+	t.strictEqual( y, NINF, 'returns expected value ' );
 
 	y = logpdf( NINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns expected value ' );
+	t.strictEqual( y, NINF, 'returns expected value ' );
 
 	y = logpdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function evaluates the logpdf for `x` given positive `mu`', function
 		y = logpdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -172,7 +172,7 @@ tape( 'the function evaluates the logpdf for `x` given negative `mu`', function
 		y = logpdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -201,7 +201,7 @@ tape( 'the function evaluates the logpdf for `x` given large variance ( = large
 		y = logpdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 15.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.native.js
index a20dc4903202..8914e24d4d0b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.native.js
@@ -55,36 +55,36 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `x` greater than `mu + s`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 20.0, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 2.0, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `x` smaller than `mu - s`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	logpdf( -20.0, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	logpdf( -2.0, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -93,22 +93,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -117,19 +117,19 @@ tape( 'if provided `s` equal to `0`, the function evaluates a degenerate distrib
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = logpdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns expected value ' );
+	t.strictEqual( y, NINF, 'returns expected value ' );
 
 	y = logpdf( PINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns expected value ' );
+	t.strictEqual( y, NINF, 'returns expected value ' );
 
 	y = logpdf( NINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns expected value ' );
+	t.strictEqual( y, NINF, 'returns expected value ' );
 
 	y = logpdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function evaluates the logpdf for `x` given positive `mu`', opts, fun
 		y = logpdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the function evaluates the logpdf for `x` given negative `mu`', opts, fun
 		y = logpdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -210,7 +210,7 @@ tape( 'the function evaluates the logpdf for `x` given large variance ( = large
 		y = logpdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 15.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/mean/test/test.js
index 590b9a8aa995..0febb4989c6b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/mean/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'the function returns the expected value of a raised cosine distribution',
 	s = data.s;
 	for ( i = 0; i < mu.length; i++ ) {
 		y = mean( mu[i], s[i] );
-		t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/mean/test/test.native.js
index 6b8ddc5f6791..f4f5aa1794e3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/mean/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,19 +63,19 @@ tape( 'if provided `s <= 0.0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = mean( 3.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'the function returns the expected value of a raised cosine distribution',
 	s = data.s;
 	for ( i = 0; i < mu.length; i++ ) {
 		y = mean( mu[i], s[i] );
-		t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/median/test/test.js
index b0872b523117..95e04607aa0f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/median/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the median of a raised cosine distribution', functio
 	for ( i = 0; i < mu.length; i++ ) {
 		y = median( mu[i], s[i] );
 		if ( expected[i] !== null ) {
-			t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/median/test/test.native.js
index d8e70fa28c57..46e251a723af 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/median/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns the median of a raised cosine distribution', opts, f
 	for ( i = 0; i < mu.length; i++ ) {
 		y = median( mu[i], s[i] );
 		if ( expected[i] !== null ) {
-			t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.factory.js
index e2c590d52264..c2d549a1d36b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.factory.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -49,23 +49,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0, 1.0 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,26 +77,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	mgf = factory( 0.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.mgf.js
index bd9969d10c9b..b9976d511f95 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.mgf.js
@@ -39,11 +39,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,22 +51,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.native.js
index 2bae38f1ccbf..d98999c4d397 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.native.js
@@ -48,11 +48,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,22 +60,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/mode/test/test.js
index 43424881aef6..25b406ff3bd2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/mode/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the mode of a raised cosine distribution', function
 	for ( i = 0; i < mu.length; i++ ) {
 		y = mode( mu[i], s[i] );
 		if ( expected[i] !== null ) {
-			t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/mode/test/test.native.js
index e7c66354c5bc..f1c557764f73 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/mode/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns the mode of a raised cosine distribution', opts, fun
 	for ( i = 0; i < mu.length; i++ ) {
 		y = mode( mu[i], s[i] );
 		if ( expected[i] !== null ) {
-			t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.factory.js
index 4d17410c17fe..9950382827b4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,13 +84,13 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 	pdf = factory( 0.0, 1.0 );
 
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 20.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -101,13 +101,13 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -20.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -119,26 +119,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -150,19 +150,19 @@ tape( 'if `s` equals `0`, the created function evaluates a degenerate distributi
 	pdf = factory( 2.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = pdf( 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -187,7 +187,7 @@ tape( 'the created function evaluates the pdf for `x` given positive `mu`', func
 		y = pdf( x[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -218,7 +218,7 @@ tape( 'the created function evaluates the pdf for `x` given negative `mu`', func
 		y = pdf( x[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 4.0 * EPS * abs( expected[ i ] );
@@ -249,7 +249,7 @@ tape( 'the created function evaluates the pdf for `x` given large variance ( = l
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.native.js
index cec3a558daaa..6cb879c58b96 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.native.js
@@ -55,36 +55,36 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `x` greater than `mu + s`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 20.0, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 2.0, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `x` smaller than `mu - s`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	pdf( -20.0, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	pdf( -2.0, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -93,22 +93,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -117,19 +117,19 @@ tape( 'if provided `s` equal to `0`, the function evaluates a degenerate distrib
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = pdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function evaluates the pdf for `x` given positive `mu`', opts, functi
 		y = pdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the function evaluates the pdf for `x` given negative `mu`', opts, functi
 		y = pdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 4.0 * EPS * abs( expected[ i ] );
@@ -210,7 +210,7 @@ tape( 'the function evaluates the pdf for `x` given large variance ( = large `s`
 		y = pdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.pdf.js
index b51ea9626357..9cfcb04122fa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.pdf.js
@@ -46,36 +46,36 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `x` greater than `mu + s`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 20.0, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 2.0, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `x` smaller than `mu - s`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	pdf( -20.0, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	pdf( -2.0, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -84,22 +84,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -108,19 +108,19 @@ tape( 'if provided `s` equal to `0`, the function evaluates a degenerate distrib
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = pdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function evaluates the pdf for `x` given positive `mu`', function tes
 		y = pdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -172,7 +172,7 @@ tape( 'the function evaluates the pdf for `x` given negative `mu`', function tes
 		y = pdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 4.0 * EPS * abs( expected[ i ] );
@@ -201,7 +201,7 @@ tape( 'the function evaluates the pdf for `x` given large variance ( = large `s`
 		y = pdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.factory.js
index 56adc076965c..d36b984bdc32 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,26 +98,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -129,16 +129,16 @@ tape( 'if `s` equals `0`, the created function evaluates a degenerate distributi
 	quantile = factory( 2.0, 0.0 );
 
 	y = quantile( 0.3, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns expected value' );
+	t.strictEqual( y, 2.0, 'returns expected value' );
 
 	y = quantile( 0.9, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns expected value' );
+	t.strictEqual( y, 2.0, 'returns expected value' );
 
 	y = quantile( 1.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -163,7 +163,7 @@ tape( 'the created function evaluates the quantile function at `p` given positiv
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -194,7 +194,7 @@ tape( 'the created function evaluates the quantile function at `p` given negativ
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -225,7 +225,7 @@ tape( 'the created function evaluates the quantile function at `p` given large v
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.native.js
index e815918c7dd9..8542e7d21e3c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `mu` and `s`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -75,22 +75,22 @@ tape( 'if provided a negative `s`, the function always returns `NaN`', opts, fun
 	var y;
 
 	y = quantile( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -99,16 +99,16 @@ tape( 'if provided `s` equals `0`, the function evaluates a degenerate distribut
 	var y;
 
 	y = quantile( 0.3, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 0.9, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 1.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	y = quantile( -0.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function evaluates the quantile function at `p` given positive `mu`',
 		y = quantile( p[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -160,7 +160,7 @@ tape( 'the function evaluates the quantile function at `p` given negative `mu`',
 		y = quantile( p[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -189,7 +189,7 @@ tape( 'the function evaluates the quantile function at `p` given large variance
 		y = quantile( p[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.quantile.js
index 515626d88a4a..cac14e299967 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `s`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,22 +66,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -90,16 +90,16 @@ tape( 'if provided `s` equals `0`, the function evaluates a degenerate distribut
 	var y;
 
 	y = quantile( 0.3, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns expected value' );
+	t.strictEqual( y, 2.0, 'returns expected value' );
 
 	y = quantile( 0.9, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns expected value' );
+	t.strictEqual( y, 2.0, 'returns expected value' );
 
 	y = quantile( 1.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function evaluates the quantile function at `p` given positive `mu`',
 		y = quantile( p[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -151,7 +151,7 @@ tape( 'the function evaluates the quantile function at `p` given negative `mu`',
 		y = quantile( p[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -180,7 +180,7 @@ tape( 'the function evaluates the quantile function at `p` given large variance
 		y = quantile( p[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/skewness/test/test.js
index 0b211be72945..230418038527 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/skewness/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the skewness of a raised cosine distribution', funct
 	for ( i = 0; i < mu.length; i++ ) {
 		y = skewness( mu[i], s[i] );
 		if ( expected[i] !== null ) {
-			t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/skewness/test/test.native.js
index 35e4ba520fe2..b68ead183083 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/skewness/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns the skewness of a raised cosine distribution', opts,
 	for ( i = 0; i < mu.length; i++ ) {
 		y = skewness( mu[i], s[i] );
 		if ( expected[i] !== null ) {
-			t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/stdev/test/test.js
index 0049dd22a6a0..1241a8c97d4f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/stdev/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the standard deviation of a raised cosine distributi
 		y = stdev( mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/stdev/test/test.native.js
index b350f2a6190f..b07b25532efb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/stdev/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the standard deviation of a raised cosine distributi
 		y = stdev( mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/test/test.js
index 0869bfb1c081..538b9b1f0b71 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains raised cosine distribution functions', function test( t ) {
 	var keys = objectKeys( cosine );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/variance/test/test.js
index bb8d54288613..e55fc7db6614 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/variance/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the variance of a raised cosine distribution', funct
 		y = variance( mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/variance/test/test.native.js
index ee623e65dc57..22f9d7ddba69 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/variance/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the variance of a raised cosine distribution', opts,
 		y = variance( mu[i], s[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.cdf.js
index 2a5f5cc52c43..b2010b4810f6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.cdf.js
@@ -37,10 +37,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = cdf( NaN, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -49,10 +49,10 @@ tape( 'the function returns `1.0` if `x` is greater or equal to `mu`', function
 	var y;
 
 	y = cdf( 3.0, 3.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	y = cdf( 4.0, 3.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	t.end();
 });
@@ -61,10 +61,10 @@ tape( 'the created function returns `0.0` if `x` is smaller than `mu`', function
 	var y;
 
 	y = cdf( 2.9, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = cdf( -2.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.factory.js
index 5e39f1e1181b..2ec790549299 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.factory.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -45,11 +45,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 3.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -61,10 +61,10 @@ tape( 'the created function returns `1.0` if provided a value greater or equal t
 	cdf = factory( 3.0 );
 
 	y = cdf( 3.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	y = cdf( 4.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	t.end();
 });
@@ -76,10 +76,10 @@ tape( 'the created function returns `0.0` if provided a value smaller than `mu`'
 	cdf = factory( 3.0 );
 
 	y = cdf( 2.9 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = cdf( -2.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.native.js
index a0c5bc38de0a..e70e938f0516 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.native.js
@@ -46,10 +46,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = cdf( NaN, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -58,10 +58,10 @@ tape( 'the function returns `1.0` if `x` is greater or equal to `mu`', opts, fun
 	var y;
 
 	y = cdf( 3.0, 3.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	y = cdf( 4.0, 3.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	t.end();
 });
@@ -70,10 +70,10 @@ tape( 'the created function returns `0.0` if `x` is smaller than `mu`', opts, fu
 	var y;
 
 	y = cdf( 2.9, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = cdf( -2.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.js
index 38680f8c53eb..a4b6be06a873 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.js
@@ -35,18 +35,18 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns the entropy of a degenerate distribution', function test( t ) {
 	var v = entropy( 2.0 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 
 	v = entropy( -5.0 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 
 	v = entropy( 0.5 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.native.js
index 102bb8f66bf6..ab0ff2792890 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.native.js
@@ -44,18 +44,18 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns the entropy of a degenerate distribution', opts, function test( t ) {
 	var v = entropy( 2.0 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 
 	v = entropy( -5.0 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 
 	v = entropy( 0.5 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.factory.js
index d7bcb6c86a51..0e272162bf14 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.factory.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -46,11 +46,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 3.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -62,10 +62,10 @@ tape( 'the created function returns `0.0` if provided a value greater than or eq
 	logcdf = factory( 3.0 );
 
 	y = logcdf( 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = logcdf( 4.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'the created function returns `-Infinity` if provided a value less than `m
 	logcdf = factory( 3.0 );
 
 	y = logcdf( 2.9 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( -2.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.logcdf.js
index 7da8fd67146d..f41ebc08ef47 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.logcdf.js
@@ -38,13 +38,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logcdf( NaN, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -53,10 +53,10 @@ tape( 'the function returns `0.0` if `x` is greater than or equal to `mu`', func
 	var y;
 
 	y = logcdf( 3.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = logcdf( 4.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'the created function returns `-Infinity` if `x` is less than `mu`', funct
 	var y;
 
 	y = logcdf( 2.9, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( -2.0, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.native.js
index b46ac67f9dac..b0cfdc72b659 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.native.js
@@ -47,13 +47,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = logcdf( NaN, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -62,10 +62,10 @@ tape( 'the function returns `0.0` if `x` is greater than or equal to `mu`', opts
 	var y;
 
 	y = logcdf( 3.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = logcdf( 4.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
@@ -74,10 +74,10 @@ tape( 'the created function returns `-Infinity` if `x` is less than `mu`', opts,
 	var y;
 
 	y = logcdf( 2.9, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( -2.0, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.factory.js
index de5fe68f4245..5d1603782e71 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.factory.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -47,11 +47,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -62,15 +62,15 @@ tape( 'the created function returns `+Infinity` if provided `x` equal to `mu`',
 
 	logpdf = factory( 2.0 );
 	y = logpdf( 2.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	logpdf = factory( 0.0 );
 	y = logpdf( 0.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	logpdf = factory( -3.0 );
 	y = logpdf( -3.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	t.end();
 });
@@ -82,10 +82,10 @@ tape( 'the created function returns `-Infinity` if provided `x` not equal to `mu
 	logpdf = factory( 3.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 4.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.logpdf.js
index ab3ed47cc9a3..ffab314763c8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.logpdf.js
@@ -39,13 +39,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logpdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -54,13 +54,13 @@ tape( 'the function returns `+Infinity` if provided `x` equal to `mu`', function
 	var y;
 
 	y = logpdf( 2.0, 2.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = logpdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = logpdf( -3.0, -3.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	t.end();
 });
@@ -69,10 +69,10 @@ tape( 'the function returns `-Infinity` if provided `x` not equal to `mu`', func
 	var y;
 
 	y = logpdf( 2.0, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 4.0, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.native.js
index 127c529489d3..29f43dafbfa1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.native.js
@@ -48,13 +48,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = logpdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -63,13 +63,13 @@ tape( 'the function returns `+Infinity` if provided `x` equal to `mu`', opts, fu
 	var y;
 
 	y = logpdf( 2.0, 2.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = logpdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = logpdf( -3.0, -3.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	t.end();
 });
@@ -78,10 +78,10 @@ tape( 'the function returns `-Infinity` if provided `x` not equal to `mu`', opts
 	var y;
 
 	y = logpdf( 2.0, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 4.0, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.factory.js
index 84b21c65fc71..ef5cec7f33ad 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.factory.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 1.0 );
-	t.equal( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -46,11 +46,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpmf = factory( 0.0 );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( NaN );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -61,15 +61,15 @@ tape( 'the created function returns `0.0` if provided `x` equal to `mu`', functi
 
 	logpmf = factory( 2.0 );
 	y = logpmf( 2.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	logpmf = factory( 0.0 );
 	y = logpmf( 0.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	logpmf = factory( -3.0 );
 	y = logpmf( -3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
@@ -81,10 +81,10 @@ tape( 'the created function returns `-Infinity` if provided `x` not equal to `mu
 	logpmf = factory( 3.0 );
 
 	y = logpmf( 2.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 4.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.js
index 373f96b89f76..bb8d4629a397 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpmf` functions', function test( t ) {
-	t.equal( typeof logpmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.logpmf.js
index 369b88898a78..92fe46b48f33 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.logpmf.js
@@ -38,13 +38,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logpmf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -53,13 +53,13 @@ tape( 'the function returns `0.0` if provided `x` equal to `mu`', function test(
 	var y;
 
 	y = logpmf( 2.0, 2.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = logpmf( 0.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = logpmf( -3.0, -3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
@@ -68,10 +68,10 @@ tape( 'the function returns `-Infinity` if provided `x` not equal to `mu`', func
 	var y;
 
 	y = logpmf( 2.0, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 4.0, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.native.js
index 6b28f277edf5..37897e6f8e4f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.native.js
@@ -47,13 +47,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = logpmf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -62,13 +62,13 @@ tape( 'the function returns `0.0` if provided `x` equal to `mu`', opts, function
 	var y;
 
 	y = logpmf( 2.0, 2.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = logpmf( 0.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = logpmf( -3.0, -3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'the function returns `-Infinity` if provided `x` not equal to `mu`', opts
 	var y;
 
 	y = logpmf( 2.0, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 4.0, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.js
index 6af970bc2ddf..eaf5f105924c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.js
@@ -35,18 +35,18 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns the mean of a degenerate distribution', function test( t ) {
 	var v = mean( 2.0 );
-	t.equal( v, 2.0, 'returns 2.0' );
+	t.strictEqual( v, 2.0, 'returns 2.0' );
 
 	v = mean( -5.0 );
-	t.equal( v, -5.0, 'returns -5.0' );
+	t.strictEqual( v, -5.0, 'returns -5.0' );
 
 	v = mean( 0.5 );
-	t.equal( v, 0.5, 'returns 0.5' );
+	t.strictEqual( v, 0.5, 'returns 0.5' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.native.js
index 642a6b416737..cc8145dc5c19 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.native.js
@@ -44,18 +44,18 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns the mean of a degenerate distribution', opts, function test( t ) {
 	var v = mean( 2.0 );
-	t.equal( v, 2.0, 'returns 2.0' );
+	t.strictEqual( v, 2.0, 'returns 2.0' );
 
 	v = mean( -5.0 );
-	t.equal( v, -5.0, 'returns -5.0' );
+	t.strictEqual( v, -5.0, 'returns -5.0' );
 
 	v = mean( 0.5 );
-	t.equal( v, 0.5, 'returns 0.5' );
+	t.strictEqual( v, 0.5, 'returns 0.5' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.js
index ab9635a287e0..ee639c90845a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.js
@@ -35,18 +35,18 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns the median of a degenerate distribution', function test( t ) {
 	var v = median( 2.0 );
-	t.equal( v, 2.0, 'returns 2.0' );
+	t.strictEqual( v, 2.0, 'returns 2.0' );
 
 	v = median( -5.0 );
-	t.equal( v, -5.0, 'returns -5.0' );
+	t.strictEqual( v, -5.0, 'returns -5.0' );
 
 	v = median( 0.5 );
-	t.equal( v, 0.5, 'returns 0.5' );
+	t.strictEqual( v, 0.5, 'returns 0.5' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.native.js
index 16a92c16bc09..e87c6ff2c44b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.native.js
@@ -44,18 +44,18 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns the median of a degenerate distribution', opts, function test( t ) {
 	var v = median( 2.0 );
-	t.equal( v, 2.0, 'returns 2.0' );
+	t.strictEqual( v, 2.0, 'returns 2.0' );
 
 	v = median( -5.0 );
-	t.equal( v, -5.0, 'returns -5.0' );
+	t.strictEqual( v, -5.0, 'returns -5.0' );
 
 	v = median( 0.5 );
-	t.equal( v, 0.5, 'returns 0.5' );
+	t.strictEqual( v, 0.5, 'returns 0.5' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.factory.js
index 4ffb1e863453..0bb2314bbf51 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.factory.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -46,11 +46,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,18 +66,18 @@ tape( 'the created function evaluates the MGF of a degenerate distribution cente
 
 	x = 2.0;
 	y = mgf( x );
-	t.equal( y, exp( x*mu ), 'returns expected value' );
+	t.strictEqual( y, exp( x*mu ), 'returns expected value' );
 
 	mu = 2.0;
 	mgf = factory( mu );
 
 	x = 1.0;
 	y = mgf( x );
-	t.equal( y, exp( x*mu ), 'returns expected value' );
+	t.strictEqual( y, exp( x*mu ), 'returns expected value' );
 
 	x = 3.0;
 	y = mgf( x );
-	t.equal( y, exp( x*mu ), 'returns expected value' );
+	t.strictEqual( y, exp( x*mu ), 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.mgf.js
index d5d9ef65bfa7..b3ed9344f87b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.mgf.js
@@ -38,13 +38,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = mgf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'the function evaluates the MGF of a degenerate distribution centered at `
 	mu = 0.0;
 	x = 2.0;
 	y = mgf( x, mu );
-	t.equal( y, exp( x*mu ), 'returns expected value' );
+	t.strictEqual( y, exp( x*mu ), 'returns expected value' );
 
 	mu = 2.0;
 	x = 1.0;
 	y = mgf( x, mu );
-	t.equal( y, exp( x*mu ), 'returns expected value' );
+	t.strictEqual( y, exp( x*mu ), 'returns expected value' );
 
 	x = 3.0;
 	y = mgf( x, mu );
-	t.equal( y, exp( x*mu ), 'returns expected value' );
+	t.strictEqual( y, exp( x*mu ), 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.native.js
index 3109ade9f4da..b14dab3f383c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.native.js
@@ -47,13 +47,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = mgf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'the function evaluates the MGF of a degenerate distribution centered at `
 	mu = 0.0;
 	x = 2.0;
 	y = mgf( x, mu );
-	t.equal( y, exp( x*mu ), 'returns expected value' );
+	t.strictEqual( y, exp( x*mu ), 'returns expected value' );
 
 	mu = 2.0;
 	x = 1.0;
 	y = mgf( x, mu );
-	t.equal( y, exp( x*mu ), 'returns expected value' );
+	t.strictEqual( y, exp( x*mu ), 'returns expected value' );
 
 	x = 3.0;
 	y = mgf( x, mu );
-	t.equal( y, exp( x*mu ), 'returns expected value' );
+	t.strictEqual( y, exp( x*mu ), 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.js
index 01173d7a8cf0..7b21720c64cb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.js
@@ -35,18 +35,18 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns the mode of a degenerate distribution', function test( t ) {
 	var v = mode( 2.0 );
-	t.equal( v, 2.0, 'returns 2.0' );
+	t.strictEqual( v, 2.0, 'returns 2.0' );
 
 	v = mode( -5.0 );
-	t.equal( v, -5.0, 'returns -5.0' );
+	t.strictEqual( v, -5.0, 'returns -5.0' );
 
 	v = mode( 0.5 );
-	t.equal( v, 0.5, 'returns 0.5' );
+	t.strictEqual( v, 0.5, 'returns 0.5' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.native.js
index b23b1b19fb37..202c91e96d16 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.native.js
@@ -44,18 +44,18 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns the mode of a degenerate distribution', opts, function test( t ) {
 	var v = mode( 2.0 );
-	t.equal( v, 2.0, 'returns 2.0' );
+	t.strictEqual( v, 2.0, 'returns 2.0' );
 
 	v = mode( -5.0 );
-	t.equal( v, -5.0, 'returns -5.0' );
+	t.strictEqual( v, -5.0, 'returns -5.0' );
 
 	v = mode( 0.5 );
-	t.equal( v, 0.5, 'returns 0.5' );
+	t.strictEqual( v, 0.5, 'returns 0.5' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.factory.js
index d9534e532711..8084203757ae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.factory.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -46,11 +46,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -61,15 +61,15 @@ tape( 'the created function returns `+Infinity` if provided `x` equal to `mu`',
 
 	pdf = factory( 2.0 );
 	y = pdf( 2.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	pdf = factory( 0.0 );
 	y = pdf( 0.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	pdf = factory( -3.0 );
 	y = pdf( -3.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	t.end();
 });
@@ -81,10 +81,10 @@ tape( 'the created function returns `0.0` if provided `x` not equal to `mu`', fu
 	pdf = factory( 3.0 );
 
 	y = pdf( 2.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = pdf( 4.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.native.js
index d51beef73230..b342b274fbcd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.native.js
@@ -47,13 +47,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = pdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -62,13 +62,13 @@ tape( 'the function returns `+Infinity` if provided `x` equal to `mu`', opts, fu
 	var y;
 
 	y = pdf( 2.0, 2.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = pdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = pdf( -3.0, -3.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'the function returns `0.0` if provided `x` not equal to `mu`', opts, func
 	var y;
 
 	y = pdf( 2.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = pdf( 4.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.pdf.js
index 25bb8b021954..ec2462b3ff60 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.pdf.js
@@ -38,13 +38,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = pdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -53,13 +53,13 @@ tape( 'the function returns `+Infinity` if provided `x` equal to `mu`', function
 	var y;
 
 	y = pdf( 2.0, 2.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = pdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = pdf( -3.0, -3.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	t.end();
 });
@@ -68,10 +68,10 @@ tape( 'the function returns `0.0` if provided `x` not equal to `mu`', function t
 	var y;
 
 	y = pdf( 2.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = pdf( 4.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.factory.js
index fab009f53def..bab65c20d3c9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.factory.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 1.0 );
-	t.equal( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -45,11 +45,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 0.0 );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -60,15 +60,15 @@ tape( 'the created function returns `1.0` if provided `x` equal to `mu`', functi
 
 	pmf = factory( 2.0 );
 	y = pmf( 2.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	pmf = factory( 0.0 );
 	y = pmf( 0.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	pmf = factory( -3.0 );
 	y = pmf( -3.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	t.end();
 });
@@ -80,10 +80,10 @@ tape( 'the created function returns `0.0` if provided `x` not equal to `mu`', fu
 	pmf = factory( 3.0 );
 
 	y = pmf( 2.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = pmf( 4.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.js
index 686bb53fea47..33c536be2daf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pmf` functions', function test( t ) {
-	t.equal( typeof pmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.native.js
index a49b5831b72b..65094441d270 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.native.js
@@ -46,13 +46,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = pmf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -61,13 +61,13 @@ tape( 'the function returns `1.0` if provided `x` equal to `mu`', opts, function
 	var y;
 
 	y = pmf( 2.0, 2.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	y = pmf( 0.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	y = pmf( -3.0, -3.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	t.end();
 });
@@ -76,10 +76,10 @@ tape( 'the function returns `0.0` if provided `x` not equal to `mu`', opts, func
 	var y;
 
 	y = pmf( 2.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = pmf( 4.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.pmf.js
index c6eb249ef9e0..c25944e060f6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.pmf.js
@@ -37,13 +37,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = pmf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -52,13 +52,13 @@ tape( 'the function returns `1.0` if provided `x` equal to `mu`', function test(
 	var y;
 
 	y = pmf( 2.0, 2.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	y = pmf( 0.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	y = pmf( -3.0, -3.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 
 	t.end();
 });
@@ -67,10 +67,10 @@ tape( 'the function returns `0.0` if provided `x` not equal to `mu`', function t
 	var y;
 
 	y = pmf( 2.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	y = pmf( 4.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.factory.js
index df081903700d..085467d13359 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.factory.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -45,11 +45,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -61,10 +61,10 @@ tape( 'the created function returns `NaN` for `p` outside the interval `[0,1]`',
 	quantile = factory( 2.0 );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -78,10 +78,10 @@ tape( 'the created function returns `mu` for `p` on the interval `[0,1]`', funct
 	quantile = factory( mu );
 
 	y = quantile( 0.3 );
-	t.equal( y, mu, 'returns `mu`' );
+	t.strictEqual( y, mu, 'returns `mu`' );
 
 	y = quantile( 0.1 );
-	t.equal( y, mu, 'returns `mu`' );
+	t.strictEqual( y, mu, 'returns `mu`' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.native.js
index e191e3ae4e8b..2c87c155855b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.native.js
@@ -46,13 +46,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = quantile( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -61,10 +61,10 @@ tape( 'if provided a number outside the interval `[0,1]` for `p`, the function r
 	var y;
 
 	y = quantile( 1.1, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( -0.1, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,10 +76,10 @@ tape( 'if provided a number on the interval `[0,1]` for `p`, the function return
 	mu = 2.0;
 
 	y = quantile( 0.3, mu );
-	t.equal( y, mu, 'returns `mu`' );
+	t.strictEqual( y, mu, 'returns `mu`' );
 
 	y = quantile( 0.8, mu );
-	t.equal( y, mu, 'returns `mu`' );
+	t.strictEqual( y, mu, 'returns `mu`' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.quantile.js
index d3445c578992..43aa143d4bef 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.quantile.js
@@ -37,13 +37,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = quantile( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -52,10 +52,10 @@ tape( 'if provided a number outside the interval `[0,1]` for `p`, the function r
 	var y;
 
 	y = quantile( 1.1, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( -0.1, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,10 +67,10 @@ tape( 'if provided a number on the interval `[0,1]` for `p`, the function return
 	mu = 2.0;
 
 	y = quantile( 0.3, mu );
-	t.equal( y, mu, 'returns `mu`' );
+	t.strictEqual( y, mu, 'returns `mu`' );
 
 	y = quantile( 0.8, mu );
-	t.equal( y, mu, 'returns `mu`' );
+	t.strictEqual( y, mu, 'returns `mu`' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.js
index fcd87a81fa75..8d505bcb3a61 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.js
@@ -35,18 +35,18 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns the standard deviation of a degenerate distribution', function test( t ) {
 	var v = stdev( 2.0 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 
 	v = stdev( -5.0 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 
 	v = stdev( 0.5 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.native.js
index 2d24ef53b19d..5f1b45e5fba8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.native.js
@@ -44,18 +44,18 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns the standard deviation of a degenerate distribution', opts, function test( t ) {
 	var v = stdev( 2.0 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 
 	v = stdev( -5.0 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 
 	v = stdev( 0.5 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/test/test.js
index 37715bb9339e..c572ef0ce1c9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains degenerate distribution functions', function test( t ) {
 	var keys = objectKeys( degenerate );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.js
index a9f69b7a1f1d..faf56fbe62fe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.js
@@ -35,18 +35,18 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns the variance of a degenerate distribution', function test( t ) {
 	var v = variance( 2.0 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 
 	v = variance( -5.0 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 
 	v = variance( 0.5 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.native.js
index c47419ab4b3f..6cbe8c4cbf66 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.native.js
@@ -44,18 +44,18 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns the variance of a degenerate distribution', opts, function test( t ) {
 	var v = variance( 2.0 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 
 	v = variance( -5.0 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 
 	v = variance( 0.5 );
-	t.equal( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns 0.0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.cdf.js
index ad83d788421b..7357942e18dc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.cdf.js
@@ -46,31 +46,31 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( 0.4, 0, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 1.0, -2.2, 3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( NaN, 0, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, NaN, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 1, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a valid `a` and `b`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 2, 4 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a valid `a` and `b`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 2, 4 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -78,10 +78,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = cdf( 0.0, 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -2, -3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function evaluates the cdf for `x` given a small range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -130,7 +130,7 @@ tape( 'the function evaluates the cdf for `x` given a medium range `b - a`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -157,7 +157,7 @@ tape( 'the function evaluates the cdf for `x` given a large range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.factory.js
index 32c2fa2c175c..ab716e24f492 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0, 1 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,31 +56,31 @@ tape( 'if provided a non-integer value for any parameter, the created function r
 
 	cdf = factory( 0, 3.5 );
 	y = cdf( 1.4 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -2.2, 1 );
 	y = cdf( 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0, 1 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -91,7 +91,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0, 1 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -114,22 +114,22 @@ tape( 'if provided a `a > b`, the created function always returns `NaN`', functi
 	cdf = factory( 2, 1 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -1, -2 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -153,7 +153,7 @@ tape( 'the created function evaluates the cdf for `x` given a small range `b - a
 		cdf = factory( a[i], b[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -182,7 +182,7 @@ tape( 'the created function evaluates the cdf for `x` given a medium range `b -
 		cdf = factory( a[i], b[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -211,7 +211,7 @@ tape( 'the created function evaluates the cdf for `x` given a large range `b - a
 		cdf = factory( a[i], b[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.native.js
index eec3e728edd1..c6cccd25b10e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.native.js
@@ -55,13 +55,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `Infinity` for `x` and a valid `a` and `b`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 2, 4 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a valid `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 2, 4 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -69,10 +69,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = cdf( 0.0, 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -2, -3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function evaluates the cdf for `x` given a small range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -121,7 +121,7 @@ tape( 'the function evaluates the cdf for `x` given a medium range `b - a`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -148,7 +148,7 @@ tape( 'the function evaluates the cdf for `x` given a large range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.js
index 40752d98fcdf..5e3c5078f8d4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( 0.1, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10, 20.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,10 +66,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = entropy( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns the entropy of a discrete uniform distribution', fun
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.native.js
index 45080c0cf20a..029a93580520 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = entropy( 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'the function returns the entropy of a discrete uniform distribution', opt
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.js
index becd6bb57f3f..ac4f3fe03ead 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( 0.1, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10, 20.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,10 +66,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = kurtosis( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns the excess kurtosis of a discrete uniform distributi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.native.js
index 0b3cefa3f1f9..c29c56ed094c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = kurtosis( 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'the function returns the excess kurtosis of a discrete uniform distributi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.factory.js
index c51d93399d22..826dd0c2bb12 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0, 1 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided a non-integer value for `a` or `b`, the created function retu
 
 	logcdf = factory( 0, 1 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,11 +83,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0, 3.5 );
 	y = logcdf( 1.4 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( -2.2, 1 );
 	y = logcdf( 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0, 1 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0, 1 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -121,22 +121,22 @@ tape( 'if provided a `a > b`, the created function always returns `NaN`', functi
 	logcdf = factory( 2, 1 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( -1, -2 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -160,7 +160,7 @@ tape( 'the created function evaluates the logcdf for `x` given a small range `b
 		logcdf = factory( a[i], b[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 110.0 * EPS * abs( expected[ i ] );
@@ -189,7 +189,7 @@ tape( 'the created function evaluates the logcdf for `x` given a medium range `b
 		logcdf = factory( a[i], b[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
@@ -218,7 +218,7 @@ tape( 'the created function evaluates the logcdf for `x` given a large range `b
 		logcdf = factory( a[i], b[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.logcdf.js
index 7ff457659354..c5e52feccc5c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.logcdf.js
@@ -46,36 +46,36 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided a non-integer value for `a` or `b`, the function returns `NaN`', function test( t ) {
 	var y = logcdf( 0.4, 0, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 1.0, -2.2, 3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, NaN, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 1, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a valid `a` and `b`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 2, 4 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a valid `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 2, 4 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -83,10 +83,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logcdf( 0.0, 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -2, -3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -108,7 +108,7 @@ tape( 'the function evaluates the logcdf for `x` given a small range `b - a`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 110.0 * EPS * abs( expected[ i ] );
@@ -135,7 +135,7 @@ tape( 'the function evaluates the logcdf for `x` given a medium range `b - a`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
@@ -162,7 +162,7 @@ tape( 'the function evaluates the logcdf for `x` given a large range `b - a`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.native.js
index 69fea1e209b7..690a1b2fd1c4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.native.js
@@ -55,13 +55,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `Infinity` for `x` and a valid `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 2, 4 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a valid `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 2, 4 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -69,10 +69,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = logcdf( 0.0, 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -2, -3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function evaluates the logcdf for `x` given a small range `b - a`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 110.0 * EPS * abs( expected[ i ] );
@@ -121,7 +121,7 @@ tape( 'the function evaluates the logcdf for `x` given a medium range `b - a`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
@@ -148,7 +148,7 @@ tape( 'the function evaluates the logcdf for `x` given a large range `b - a`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.factory.js
index d44ec6fdb5f0..73f768836a92 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 0, 1 );
-	t.equal( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpmf = factory( 0, 1 );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( NaN, 1 );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( 1, NaN );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( NaN, NaN );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( NaN, NaN );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logpmf = factory( -2, 2 );
 	y = logpmf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logpmf = factory( -2, 2 );
 	y = logpmf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -105,11 +105,11 @@ tape( 'if provided a non-integer value for `a` or `b`, the created function retu
 
 	logpmf = factory( 0.5, 2 );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( -2, 5.5 );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,22 +121,22 @@ tape( 'if provided `a > b`, the created function always returns `NaN`', function
 	logpmf = factory( 0, -1 );
 
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( 0.0, NINF );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( PINF, NINF );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( NaN, NINF );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -160,7 +160,7 @@ tape( 'the created function evaluates the logpmf for `x` given small range `b -
 		logpmf = factory( a[i], b[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -189,7 +189,7 @@ tape( 'the created function evaluates the logpmf for `x` given a medium range `b
 		logpmf = factory( a[i], b[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -218,7 +218,7 @@ tape( 'the created function evaluates the logpmf for `x` given a large range `b
 		logpmf = factory( a[i], b[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.js
index 373f96b89f76..bb8d4629a397 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpmf` functions', function test( t ) {
-	t.equal( typeof logpmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.logpmf.js
index 42b8ea89993d..8d3ceddcff1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.logpmf.js
@@ -46,32 +46,32 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpmf( NaN, 0, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpmf( 0.0, NaN, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpmf( 0.0, 1, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( PINF, 0, 1 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( NINF, 0, 1 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpmf( 1.0, 1, 2.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 2.0, 0.1, 4 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,10 +80,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logpmf( 2.0, 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -105,7 +105,7 @@ tape( 'the function evaluates the logpmf for `x` given a small range `b - a`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -132,7 +132,7 @@ tape( 'the function evaluates the logpmf for `x` given a medium range `b - a`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -159,7 +159,7 @@ tape( 'the function evaluates the logpmf for `x` given a large range `b - a`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.native.js
index 037d5f6d3247..02ea16de9b50 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.native.js
@@ -55,20 +55,20 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpmf( NaN, 0, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( PINF, 0, 1 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( NINF, 0, 1 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -76,7 +76,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = logpmf( 2.0, 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function evaluates the logpmf for `x` given a small range `b - a`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -125,7 +125,7 @@ tape( 'the function evaluates the logpmf for `x` given a medium range `b - a`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -152,7 +152,7 @@ tape( 'the function evaluates the logpmf for `x` given a large range `b - a`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.js
index 2dd9b5ac47ec..7abe623b19b5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( 0.1, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10, 20.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,10 +66,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns the mean of a discrete uniform distribution', functi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.native.js
index c7419534abe6..e6558266a773 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mean( 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'the function returns the mean of a discrete uniform distribution', opts,
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.js
index 8ef67f2b6924..f45944a3a40e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( 0.1, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( 10, 20.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,10 +66,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = median( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns the median of a discrete uniform distribution', func
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.native.js
index cef893a5baaa..64d7af36ec86 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = median( 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'the function returns the median of a discrete uniform distribution', opts
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.factory.js
index 7d6627dd027d..b9833156afc4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,11 +56,11 @@ tape( 'if provided a non-integer value for `a` or `b`, the created function retu
 
 	mgf = factory( 0.5, 2 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( -2, 5.5 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -71,23 +71,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0, 1 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, 1 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 1, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -99,22 +99,22 @@ tape( 'if provided `a > b`, the created function always returns `NaN`', function
 	mgf = factory( 0, -1 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -125,11 +125,11 @@ tape( 'if provided valid parameters `a` and `b`, the created function returns `1
 
 	mgf = factory( -4, 4 );
 	y = mgf( 0.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	mgf = factory( 0, 10 );
 	y = mgf( 0.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -154,7 +154,7 @@ tape( 'the created function evaluates the MGF for `x` given small range `b - a`'
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the created function evaluates the MGF for `x` given a medium range `b -
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -216,7 +216,7 @@ tape( 'the created function evaluates the MGF for `x` given a large range `b - a
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.js
index 9391bd503275..2b218a20cdcf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `MGF` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.mgf.js
index 163a07a1c6c9..1f4633a96b52 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.mgf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( 0.0, 1, 2.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 0.1, 4 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, NaN, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 1, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -71,10 +71,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mgf( 2.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,13 +83,13 @@ tape( 'if provided valid parameters, the function returns `1` for `t = 0`', func
 	var y;
 
 	y = mgf( 0.0, 2, 4 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = mgf( 0.0, 1, 2 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = mgf( 0.0, -4, 4 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -112,7 +112,7 @@ tape( 'the function evaluates the MGF for `x` given a small range `b - a`', func
 		y = mgf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -141,7 +141,7 @@ tape( 'the function evaluates the MGF for `x` given a medium range `b - a`', fun
 		y = mgf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -170,7 +170,7 @@ tape( 'the function evaluates the MGF for `x` given a large range `b - a`', func
 		y = mgf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.native.js
index 18492a589d9a..6aae24f00c0f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -62,7 +62,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mgf( 2.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -71,13 +71,13 @@ tape( 'if provided valid parameters, the function returns `1` for `t = 0`', opts
 	var y;
 
 	y = mgf( 0.0, 2, 4 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = mgf( 0.0, 1, 2 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = mgf( 0.0, -4, 4 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function evaluates the MGF for `x` given a small range `b - a`', opts
 		y = mgf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -129,7 +129,7 @@ tape( 'the function evaluates the MGF for `x` given a medium range `b - a`', opt
 		y = mgf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the MGF for `x` given a large range `b - a`', opts
 		y = mgf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.factory.js
index 7437a27e391d..7ab50b2b2561 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 0.0, 1.0 );
-	t.equal( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 0.0, 1.0 );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( NaN, 1.0 );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( 1.0, NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( NaN, NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( NaN, NaN );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pmf = factory( -2, 2 );
 	y = pmf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pmf = factory( -2, 2 );
 	y = pmf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -105,11 +105,11 @@ tape( 'if provided a non-integer value for `a` or `b`, the created function retu
 
 	pmf = factory( 0.5, 2 );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( -2, 5.5 );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,22 +121,22 @@ tape( 'if provided `a > b`, the created function always returns `NaN`', function
 	pmf = factory( 0.0, -1.0 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( 0.0, NINF );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( PINF, NINF );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( NaN, NINF );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -160,7 +160,7 @@ tape( 'the created function evaluates the pmf for `x` given small range `b - a`'
 		pmf = factory( a[i], b[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -189,7 +189,7 @@ tape( 'the created function evaluates the pmf for `x` given a medium range `b -
 		pmf = factory( a[i], b[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -218,7 +218,7 @@ tape( 'the created function evaluates the pmf for `x` given a large range `b - a
 		pmf = factory( a[i], b[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.js
index 686bb53fea47..33c536be2daf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pmf` functions', function test( t ) {
-	t.equal( typeof pmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.native.js
index 11190f50dd1c..4256386754a2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.native.js
@@ -52,20 +52,20 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pmf( NaN, 0, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -73,7 +73,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = pmf( 2.0, 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function evaluates the pmf for `x` given a small range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -122,7 +122,7 @@ tape( 'the function evaluates the pmf for `x` given a medium range `b - a`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -149,7 +149,7 @@ tape( 'the function evaluates the pmf for `x` given a large range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.pmf.js
index bccad1edf998..d5b8e3eff6f6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.pmf.js
@@ -46,32 +46,32 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( NaN, 0, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pmf( 0.0, NaN, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pmf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pmf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pmf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( 1.0, 1, 2.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 2.0, 0.1, 4 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,10 +80,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pmf( 2.0, 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -105,7 +105,7 @@ tape( 'the function evaluates the pmf for `x` given a small range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -132,7 +132,7 @@ tape( 'the function evaluates the pmf for `x` given a medium range `b - a`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -159,7 +159,7 @@ tape( 'the function evaluates the pmf for `x` given a large range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.factory.js
index ba07de571c15..435d4d9eb400 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0, 1 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0, 1 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1 );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1, NaN );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	quantile = factory( -2, 2 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,14 +98,14 @@ tape( 'if provided a non-integer value for `a` or `b`, the created function alwa
 	quantile = factory( 2, 1.5 );
 
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.2, 4 );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -117,14 +117,14 @@ tape( 'if provided `a > b`, the created function always returns `NaN`', function
 	quantile = factory( 2, 1 );
 
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -148,7 +148,7 @@ tape( 'the created function evaluates the quantile for `p` given a small range `
 		quantile = factory( a[i], b[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -177,7 +177,7 @@ tape( 'the created function evaluates the quantile for `p` given a medium range
 		quantile = factory( a[i], b[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -206,7 +206,7 @@ tape( 'the created function evaluates the quantile for `p` given a large range `
 		quantile = factory( a[i], b[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.native.js
index de0ddac9fba6..fe970883dfbe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.native.js
@@ -53,15 +53,15 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0, 1 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0, 1 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -69,10 +69,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = quantile( 0.5, 2, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -2, -3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function evaluates the quantile for `p` given a small range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -121,7 +121,7 @@ tape( 'the function evaluates the quantile for `p` given a medium range `b - a`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -148,7 +148,7 @@ tape( 'the function evaluates the quantile for `p` given a large range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.quantile.js
index b8bdd56ca71d..f7d7cdd3d754 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, NaN, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, 1, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0, 1 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0, 1 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,13 +66,13 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = quantile( 0.5, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2, 1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -2, -3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,10 +81,10 @@ tape( 'if provided a non-integer value for `a` or `b`, the function returns `NaN
 	var y;
 
 	y = quantile( 0.5, 1, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -0.1, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function evaluates the quantile for `p` given a small range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -133,7 +133,7 @@ tape( 'the function evaluates the quantile for `p` given a medium range `b - a`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -160,7 +160,7 @@ tape( 'the function evaluates the quantile for `p` given a large range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.js
index 072cda1a811c..6666aa1bbab3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.js
@@ -39,20 +39,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( 0.1, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10, 20.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -61,10 +61,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns `0.0` as the skewness of a discrete uniform distribu
 		a = round( randu()*10.0 );
 		b = round( ( randu()*10.0 ) + a );
 		v = skewness( a, b );
-		t.equal( v, 0.0, 'returns 0.0' );
+		t.strictEqual( v, 0.0, 'returns 0.0' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.native.js
index 117283830ecc..81e5a489e56a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.native.js
@@ -48,7 +48,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = skewness( 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -63,7 +63,7 @@ tape( 'the function returns `0.0` as the skewness of a discrete uniform distribu
 		a = round( randu()*10.0 );
 		b = round( ( randu()*10.0 ) + a );
 		v = skewness( a, b );
-		t.equal( v, 0.0, 'returns 0.0' );
+		t.strictEqual( v, 0.0, 'returns 0.0' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.js
index 34fb4bc39a75..13bec3f922b1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( 0.1, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10, 20.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,10 +66,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = stdev( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns the standard deviation of a discrete uniform distrib
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.native.js
index 58e11a8d3c58..fc63bfe51566 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = stdev( 3, 2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'the function returns the standard deviation of a discrete uniform distrib
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/test/test.js
index 2b8a3852b033..09acfab59205 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains discrete uniform distribution functions', function test( t ) {
 	var keys = objectKeys( discreteUniform );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.js
index fc9116531b5e..e5c820ce9445 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( 0.1, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10, 20.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,10 +66,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = variance( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns the variance of a discrete uniform distribution', fu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.native.js
index 18ca3bff1cf4..c4c31b7bb20f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = variance( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'the function returns the variance of a discrete uniform distribution', op
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.cdf.js
index 7707989dbe86..7d27593e7b25 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `k` and `lambda`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 2, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `k` and `lambda`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 2, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `k`, the function returns `NaN`', function test( t
 	var y;
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided a negative `lambda`, the function returns `NaN`', function te
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function evaluates the cdf for `x` given large `k` and `lambda`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 180.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the cdf for `x` given large shape parameter `k`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 100.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the cdf for `x` given large rate parameter `lambda
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.factory.js
index ad8fb79f330b..177fdf594fa2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `k` and `lambda`, the function returns a function wh
 
 	cdf = factory( 2, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `k` and `lambda`, the function returns a function wh
 
 	cdf = factory( 2, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	cdf = factory( 2, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,26 +137,26 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -180,7 +180,7 @@ tape( 'the created function evaluates the cdf for `x` given large `k` and `lambd
 		cdf = factory( k[i], lambda[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 180.0 * EPS * abs( expected[ i ] );
@@ -209,7 +209,7 @@ tape( 'the created function evaluates the cdf for `x` given large shape paramete
 		cdf = factory( k[i], lambda[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 100.0 * EPS * abs( expected[ i ] );
@@ -238,7 +238,7 @@ tape( 'the created function evaluates the cdf for `x` given large rate parameter
 		cdf = factory( k[i], lambda[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.js
index 0cf794d2f109..42f3ef3ed168 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = entropy( 1.5, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 3.9, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = entropy( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the differential entropy of an Erlang distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 15000.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.native.js
index 6860bc3e4877..ca387e647029 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,22 +65,22 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = entropy( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = entropy( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function returns the differential entropy of an Erlang distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 15000.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.js
index f8c891a479ee..57a122fcb415 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -54,28 +54,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = kurtosis( 1.7, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 3.7, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,19 +84,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = kurtosis( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function returns the excess kurtosis of an Erlang distribution', func
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( k[i], lambda[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.native.js
index f299d24efacc..5f54591bf186 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.native.js
@@ -50,10 +50,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -62,10 +62,10 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = kurtosis( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -74,19 +74,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = kurtosis( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2, -2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 3, -1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns the excess kurtosis of an Erlang distribution', opts
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( k[i], lambda[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.factory.js
index 81fd4bdc26fc..d52b463fc595 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `k` and `lambda`, the function returns a function whi
 
 	logpdf = factory( 2, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `k` and `lambda`, the function returns a function whi
 
 	logpdf = factory( 2, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `lambda <= 0`, the created function always returns `NaN`', fu
 	logpdf = factory( 0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -136,31 +136,31 @@ tape( 'if provided `k` is not a nonnegative integer, the created function always
 
 	logpdf = factory( -1.0, 0.5 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.5, 0.5 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -184,7 +184,7 @@ tape( 'the created function evaluates the logpdf for `x` given large `k` and `la
 		logpdf = factory( k[i], lambda[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 450.0 * EPS * abs( expected[ i ] );
@@ -213,7 +213,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large shape par
 		logpdf = factory( k[i], lambda[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 350.0 * EPS * abs( expected[ i ] );
@@ -242,7 +242,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large rate para
 		logpdf = factory( k[i], lambda[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 450.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.logpdf.js
index 5d8297661664..c273c653876c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `k` and `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `k` and `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function evaluates the logpdf for `x` given large `k` and `lambda`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 450.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the logpdf for `x` given large shape parameter `k`
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 350.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the logpdf for `x` given large rate parameter `lam
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 450.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.js
index 2deeec390ed6..a6ec1254fd99 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = mean( 1.5, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 3.9, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mean( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the mean of an Erlang distribution', function test(
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.native.js
index fc4e393dc8f7..60b62c709ffd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,22 +65,22 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = mean( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = mean( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function returns the mean of an Erlang distribution', opts, function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.factory.js
index 1045e9af7e37..4e01cb893e44 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 1, 1.0 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 1, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,26 +84,26 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	mgf = factory( 2, -1.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -115,26 +115,26 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	mgf = factory( -1.0, 0.5 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, 1.0 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, PINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NaN );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -145,9 +145,9 @@ tape( 'the created function returns `NaN` if provided `t >= lambda`', function t
 
 	mgf = factory( 1, 1.0 );
 	y = mgf( 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -170,7 +170,7 @@ tape( 'the created function evaluates the mgf for `x` given large `k` and `lambd
 		mgf = factory( k[i], lambda[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2500.0 * EPS * abs( expected[ i ] );
@@ -199,7 +199,7 @@ tape( 'the created function evaluates the mgf for `x` given large shape paramete
 		mgf = factory( k[i], lambda[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2000.0 * EPS * abs( expected[ i ] );
@@ -228,7 +228,7 @@ tape( 'the created function evaluates the mgf for `x` given large rate parameter
 		mgf = factory( k[i], lambda[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.mgf.js
index 2448ea82e2f0..a84708597a69 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.mgf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,22 +58,22 @@ tape( 'if provided a negative `k`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mgf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -82,31 +82,31 @@ tape( 'if provided a negative `lambda`, the function returns `NaN`', function te
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `t >= lambda`, the function returns `NaN`', function test( t ) {
 	var y = mgf( 1.5, 1, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.8, 1, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -127,7 +127,7 @@ tape( 'the function evaluates the mgf for `x` given large `k` and `lambda`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2500.0 * EPS * abs( expected[ i ] );
@@ -154,7 +154,7 @@ tape( 'the function evaluates the mgf for `x` given large shape parameter `k`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2000.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the function evaluates the mgf for `x` given large rate parameter `lambda
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.js
index 5765081380db..76153bfa08ba 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = mode( 1.5, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 3.9, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mode( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the mode of an Erlang distribution', function test(
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.native.js
index 4f799e92cb12..419b55205fa2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,22 +65,22 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = mode( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = mode( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function returns the mode of an Erlang distribution', opts, function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.factory.js
index 12ec251d1528..f807980159d8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `k` and `lambda`, the function returns a function whi
 
 	pdf = factory( 2, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `k` and `lambda`, the function returns a function whi
 
 	pdf = factory( 2, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `lambda <= 0`, the created function always returns `NaN`', fu
 	pdf = factory( 0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -136,31 +136,31 @@ tape( 'if provided `k` is not a nonnegative integer, the created function always
 
 	pdf = factory( -1.0, 0.5 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.5, 0.5 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -184,7 +184,7 @@ tape( 'the created function evaluates the pdf for `x` given large `k` and `lambd
 		pdf = factory( k[i], lambda[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 180.0 * EPS * abs( expected[ i ] );
@@ -213,7 +213,7 @@ tape( 'the created function evaluates the pdf for `x` given a large shape parame
 		pdf = factory( k[i], lambda[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 90.0 * EPS * abs( expected[ i ] );
@@ -242,7 +242,7 @@ tape( 'the created function evaluates the pdf for `x` given a large rate paramet
 		pdf = factory( k[i], lambda[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 100.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.pdf.js
index e4c3ff67b458..e3b968ee68cf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `k` and `lambda`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `k` and `lambda`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function evaluates the pdf for `x` given large `k` and `lambda`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 180.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the pdf for `x` given large shape parameter `k`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 90.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the pdf for `x` given large rate parameter `lambda
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 100.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.factory.js
index 026973e8f92e..7295b4a9fadc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `k` and `lambda`, the function returns a function wh
 
 	quantile = factory( 1, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,26 +98,26 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	quantile = factory( 1, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -129,26 +129,26 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	quantile = factory( -1, 0.5 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -172,7 +172,7 @@ tape( 'the created function evaluates the quantile for `p` given large `k` and `
 		quantile = factory( k[i], lambda[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -201,7 +201,7 @@ tape( 'the created function evaluates the quantile for `p` given large shape par
 		quantile = factory( k[i], lambda[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -230,7 +230,7 @@ tape( 'the created function evaluates the quantile for `p` given large rate para
 		quantile = factory( k[i], lambda[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.quantile.js
index 91ec71c1e84e..120620117d96 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `k` and `lambda`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 1, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,28 +66,28 @@ tape( 'if provided a `k` which is not a nonnegative integer, the function return
 	var y;
 
 	y = quantile( 2.0, -1, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, -1, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 0.5, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 4.5, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -96,22 +96,22 @@ tape( 'if provided a negative `lambda`, the function returns `NaN`', function te
 	var y;
 
 	y = quantile( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the function evaluates the quantile for `x` given large parameters `k` an
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -160,7 +160,7 @@ tape( 'the function evaluates the quantile for `x` given large shape parameter `
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -187,7 +187,7 @@ tape( 'the function evaluates the quantile for `x` given large rate parameter `l
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', k:'+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.js
index 100ec1c04bed..4970731ca3ef 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = skewness( 1.5, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 3.9, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = skewness( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the skewness of an Erlang distribution', function te
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.native.js
index ddd520a3bfe8..a9465e36b2bf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,22 +65,22 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = skewness( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = skewness( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function returns the skewness of an Erlang distribution', opts, funct
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.js
index 3506a52a743b..e78a349d1d58 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = stdev( 1.5, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 3.9, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = stdev( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the standard deviation of an Erlang distribution', f
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.native.js
index 51d3c10d6ed9..969834997a30 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,22 +65,22 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = stdev( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = stdev( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function returns the standard deviation of an Erlang distribution', o
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/test/test.js
index 147a0e173f5f..d040504e2b9d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Erlang distribution functions', function test( t ) {
 	var keys = objectKeys( erlang );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.js
index 8805cfac5f5c..473ca01c4a61 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = variance( 1.5, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 3.9, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = variance( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the variance of an Erlang distribution', function te
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.native.js
index cef9e9800569..2645e6d0baec 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,22 +65,22 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = variance( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = variance( 2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function returns the variance of an Erlang distribution', opts, funct
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.cdf.js
index 0e0ca9c506b7..8b798f30376a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.cdf.js
@@ -44,21 +44,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -66,16 +66,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', functi
 	var y;
 
 	y = cdf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,13 +84,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.factory.js
index d50507dfa5c4..cb7da37a1b76 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	cdf = factory( 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	cdf = factory( 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -92,16 +92,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns a function whi
 	cdf = factory( PINF );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,10 +113,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	cdf = factory( -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the created function evaluates the cdf for `x` given parameter `lambda`',
 		cdf = factory( lambda[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 4.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.native.js
index d64d158a20bc..46d5476c603b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.native.js
@@ -53,21 +53,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -75,16 +75,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', opts,
 	var y;
 
 	y = cdf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,13 +93,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', opts
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.js
index 3506e47ff813..4bb5ad05c470 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'the function returns the differential entropy of an exponential distribut
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( lambda[i] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.native.js
index f69a5f8946df..0986141f17cb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the differential entropy of an exponential distribut
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( lambda[i] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.js
index f549bb9c63f0..630b25d64f47 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the excess kurtosis of an exponential distribution',
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.native.js
index 394229a059b4..47ef147838b8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the excess kurtosis of an exponential distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( lambda[i] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.factory.js
index 5a16c10edb2e..0e378ae2a660 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logcdf = factory( 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logcdf = factory( 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -92,16 +92,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns a function whi
 	logcdf = factory( PINF );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,10 +113,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	logcdf = factory( -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the created function evaluates the logcdf for `x` given parameter `lambda
 		logcdf = factory( lambda[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 6800.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.logcdf.js
index 3e039f9ed926..a63b42bc1819 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.logcdf.js
@@ -44,21 +44,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda`, the function returns `1`', function test( t ) {
 	var y = logcdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda`, the function returns `0`', function test( t ) {
 	var y = logcdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
@@ -66,16 +66,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', functi
 	var y;
 
 	y = logcdf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,13 +84,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = logcdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function evaluates the logcdf for `x` given parameter `lambda`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda:'+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda:'+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 6800.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.native.js
index 14afc6556f44..af99f6dedc7a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.native.js
@@ -53,21 +53,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda`, the function returns `1`', opts, function test( t ) {
 	var y = logcdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
@@ -75,16 +75,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', opts,
 	var y;
 
 	y = logcdf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,13 +93,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', opts
 	var y;
 
 	y = logcdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function evaluates the logcdf for `x` given parameter `lambda`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda:'+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda:'+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 6800.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.factory.js
index 12ce46b53b0d..27d7badf525c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,11 +57,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logpdf = factory( 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns a function whi
 	logpdf = factory( PINF );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,10 +116,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	logpdf = factory( -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the created function evaluates the logpdf for `x` given parameter `lambda
 		logpdf = factory( lambda[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
@@ -168,7 +168,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `lambda` (when
 		logpdf = factory( lambda[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 22.0 * EPS * abs( expected[ i ] );
@@ -195,7 +195,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `lambda` (when
 		logpdf = factory( lambda[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 22.0 * EPS * abs( expected[ i ] );
@@ -222,7 +222,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `lambda` (when
 		logpdf = factory( lambda[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.logpdf.js
index cbe93376b768..981046a08de5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.logpdf.js
@@ -47,21 +47,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -69,16 +69,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', functi
 	var y;
 
 	y = logpdf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,13 +87,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = logpdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `lambda` (when
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 30.0 * EPS * abs( expected[i] );
@@ -138,7 +138,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `lambda` (when
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 22.0 * EPS * abs( expected[i] );
@@ -163,7 +163,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `lambda` (when
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 22.0 * EPS * abs( expected[i] );
@@ -188,7 +188,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `lambda` (when
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 30.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.native.js
index 3b2e259573a4..ba729896dc3b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.native.js
@@ -56,21 +56,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -78,16 +78,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', opts,
 	var y;
 
 	y = logpdf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -96,13 +96,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', opts
 	var y;
 
 	y = logpdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `lambda` (when
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 30.0 * EPS * abs( expected[i] );
@@ -147,7 +147,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `lambda` (when
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 22.0 * EPS * abs( expected[i] );
@@ -172,7 +172,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `lambda` (when
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 22.0 * EPS * abs( expected[i] );
@@ -197,7 +197,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `lambda` (when
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 30.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.js
index c0fed67b573d..f5e16609d272 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the expected value of an exponential distribution',
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.native.js
index 6b0baf21c121..fc0275d0fe60 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the expected value of an exponential distribution',
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.js
index 2719b15457e9..06a42a4f6d80 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = median( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the median of an exponential distribution', function
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.native.js
index 415be5ee884b..dd09221b85fb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = median( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the median of an exponential distribution', opts, fu
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.factory.js
index 8edf0de3401b..1699c7cc5187 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 1.0 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -72,16 +72,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns a function whi
 	mgf = factory( PINF );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,18 +93,18 @@ tape( 'if provided a nonpositive `lambda`, the created function always returns `
 	mgf = factory( -1.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -115,11 +115,11 @@ tape( 'the created function returns `NaN` for `x >= lambda`', function test( t )
 
 	mgf = factory( 3.0 );
 	y = mgf( 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.1 );
 	y = mgf( 0.9 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the created function evaluates the mgf for `x` given small `lambda` value
 		mgf = factory( lambda[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 100.0 * EPS * abs( expected[i] );
@@ -168,7 +168,7 @@ tape( 'the created function evaluates the mgf for `x` given medium `lambda` valu
 		mgf = factory( lambda[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 250.0 * EPS * abs( expected[i] );
@@ -195,7 +195,7 @@ tape( 'the created function evaluates the mgf for `x` given large `lambda` value
 		mgf = factory( lambda[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 250.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.mgf.js
index 1ec64c3dbdc9..c5f0828547c5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.mgf.js
@@ -46,9 +46,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -56,16 +56,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', functi
 	var y;
 
 	y = mgf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -74,19 +74,19 @@ tape( 'if provided a nonpositive `lambda`, the function always returns `NaN`', f
 	var y;
 
 	y = mgf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( -2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,10 +95,10 @@ tape( 'the function returns `NaN` for `x >= lambda`', function test( t ) {
 	var y;
 
 	y = mgf( 4.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.9, 0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function evaluates the mgf for `x` given small `lambda` values', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 100.0 * EPS * abs( expected[i] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the mgf for `x` given medium `lambda` values', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 250.0 * EPS * abs( expected[i] );
@@ -168,7 +168,7 @@ tape( 'the function evaluates the mgf for `x` given large `lambda` values', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 250.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.native.js
index 8c221b7ee72e..c5d2ffa90377 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.native.js
@@ -55,9 +55,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -65,16 +65,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', opts,
 	var y;
 
 	y = mgf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided a nonpositive `lambda`, the function always returns `NaN`', o
 	var y;
 
 	y = mgf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( -2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -104,10 +104,10 @@ tape( 'the function returns `NaN` for `x >= lambda`', opts, function test( t ) {
 	var y;
 
 	y = mgf( 4.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.9, 0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function evaluates the mgf for `x` given small `lambda` values', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 100.0 * EPS * abs( expected[i] );
@@ -152,7 +152,7 @@ tape( 'the function evaluates the mgf for `x` given medium `lambda` values', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 250.0 * EPS * abs( expected[i] );
@@ -177,7 +177,7 @@ tape( 'the function evaluates the mgf for `x` given large `lambda` values', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 250.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.js
index 6f0226296f6f..43d8eeed1a1a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the mode of an exponential distribution', function t
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.native.js
index c62b8611dcf5..f117ffc25a86 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the mode of an exponential distribution', opts, func
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.factory.js
index 10188efee2bd..b4465105c236 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,11 +57,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	pdf = factory( 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	pdf = factory( 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns a function whi
 	pdf = factory( PINF );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,10 +116,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	pdf = factory( -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the created function evaluates the pdf for `x` given parameter `lambda` (
 		pdf = factory( lambda[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -168,7 +168,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `lambda` (when `x`
 		pdf = factory( lambda[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 22.0 * EPS * abs( expected[ i ] );
@@ -195,7 +195,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `lambda` (when `x`
 		pdf = factory( lambda[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 22.0 * EPS * abs( expected[ i ] );
@@ -222,7 +222,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `lambda` (when `x`
 		pdf = factory( lambda[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.native.js
index cfc9c8e02255..77444971c1a3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.native.js
@@ -56,13 +56,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', opts,
 	var y;
 
 	y = pdf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,13 +88,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', opts
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `lambda` (when `x`
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 20.0 * EPS * abs( expected[i] );
@@ -139,7 +139,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `lambda` (when `x`
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 22.0 * EPS * abs( expected[i] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `lambda` (when `x`
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 22.0 * EPS * abs( expected[i] );
@@ -189,7 +189,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `lambda` (when `x`
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.pdf.js
index 7c0cf3233fd2..b29eb2b2b917 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.pdf.js
@@ -47,21 +47,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -69,16 +69,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', functi
 	var y;
 
 	y = pdf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,13 +87,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `lambda` (when `x`
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 20.0 * EPS * abs( expected[i] );
@@ -138,7 +138,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `lambda` (when `x`
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 22.0 * EPS * abs( expected[i] );
@@ -163,7 +163,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `lambda` (when `x`
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 22.0 * EPS * abs( expected[i] );
@@ -188,7 +188,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `lambda` (when `x`
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.factory.js
index 7d29b88e0565..15fb382b43e0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.factory.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -63,11 +63,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -78,10 +78,10 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	quantile = factory( 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,16 +93,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns a function whi
 	quantile = factory( PINF );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -114,10 +114,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	quantile = factory( -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -139,7 +139,7 @@ tape( 'the created function evaluates the quantile for `x` given parameter `lamb
 		quantile = factory( lambda[i] );
 		y = quantile( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 110.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.native.js
index ee02fd702072..2e0c8411cf3d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.native.js
@@ -62,17 +62,17 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 2.2, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.2, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -80,16 +80,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', opts,
 	var y;
 
 	y = quantile( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,13 +98,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', opts
 	var y;
 
 	y = quantile( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function evaluates the quantile for `x` given parameter `lambda`', op
 	for ( i = 0; i < x.length; i++ ) {
 		y = quantile( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 110.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.quantile.js
index d8dfedfba712..68952e756657 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.quantile.js
@@ -53,17 +53,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `lambda`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 2.2, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.2, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -71,16 +71,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', functi
 	var y;
 
 	y = quantile( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,13 +89,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = quantile( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -115,7 +115,7 @@ tape( 'the function evaluates the quantile for `x` given parameter `lambda`', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = quantile( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 110.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.js
index 3efd8586a6f2..93710d69b219 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = skewness( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the skewness of an exponential distribution', functi
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.native.js
index ce1538901a81..c1a75d0a0555 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = skewness( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the skewness of an exponential distribution', opts,
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( lambda[i] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.js
index f4c5596be48e..7d3e05473693 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'the function returns the standard deviation of an exponential distributio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( lambda[i] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.native.js
index adc92b17c772..c7d03eaf8cbf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = stddev( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = stddev( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stddev( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the standard deviation of an exponential distributio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stddev( lambda[i] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/test/test.js
index b06215411ed7..f5c628c08a01 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains exponential distribution functions', function test( t ) {
 	var keys = objectKeys( exponential );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.js
index a12fa725a2be..1b5a2a75d406 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'the function returns the variance of an exponential distribution', functi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( lambda[i] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.native.js
index d74e9ff5fae0..af183f6918db 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the variance of an exponential distribution', opts,
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( lambda[i] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.cdf.js
index 91ec2a681806..d3b95d66cd95 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `d1` and `d2`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `d1` and `d2`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `d1`, the function returns `NaN`', function test(
 	var y;
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided a negative `d2`, the function returns `NaN`', function test(
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function evaluates the cdf for `x` given large `d1` and `d2`', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1:'+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1:'+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the cdf for `x` given large parameter `d1`', funct
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1:'+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1:'+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 400.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the cdf for `x` given large scale parameter `d2`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1:'+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1:'+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 200.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.factory.js
index d6e01878ccc7..de225f39cd85 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `d1` and `d2`, the function returns a function which
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `d1` and `d2`, the function returns a function which
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,27 +106,27 @@ tape( 'if provided a nonpositive `d2`, the created function always returns `NaN`
 	cdf = factory( 0.5, 0.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.5, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -138,27 +138,27 @@ tape( 'if provided a nonpositive `d1`, the created function always returns `NaN`
 	cdf = factory( 0.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -182,7 +182,7 @@ tape( 'the created function evaluates the cdf for `x` given large `d1` and `d2`'
 		cdf = factory( d1[i], d2[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
@@ -211,7 +211,7 @@ tape( 'the created function evaluates the cdf for `x` given large parameter `d1`
 		cdf = factory( d1[i], d2[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 400.0 * EPS * abs( expected[ i ] );
@@ -240,7 +240,7 @@ tape( 'the created function evaluates the cdf for `x` given large parameter `d2`
 		cdf = factory( d1[i], d2[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 200.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.js
index 737ca4c7b6be..a8814fe8d606 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `d2 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the differential entropy of an F distribution', func
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 90.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.native.js
index ab94ba2dfcb7..0e8a930f024a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `d2 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the differential entropy of an F distribution', opts
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 90.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.js
index abb8956c0e88..d040b8a5a120 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,43 +77,43 @@ tape( 'if provided `d2 <= 8`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = kurtosis( 2.0, 8.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 7.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 6.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 5.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the function returns the excess kurtosis of an F distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.native.js
index 6befb8c407b5..543485720777 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,43 +86,43 @@ tape( 'if provided `d2 <= 8`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = kurtosis( 2.0, 8.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 7.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 6.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 5.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -142,7 +142,7 @@ tape( 'the function returns the excess kurtosis of an F distribution', opts, fun
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.js
index 856f14894b29..ca4fff466880 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 3.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,25 +77,25 @@ tape( 'if provided `d2 <= 2`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -115,7 +115,7 @@ tape( 'the function returns the mean of an F distribution', function test( t ) {
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.native.js
index 68bdbf8c001b..eb53998a5094 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 3.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,25 +86,25 @@ tape( 'if provided `d2 <= 2`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = mean( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns the mean of an F distribution', opts, function test(
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.js
index f842c4739c37..5bedf21fb43b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,25 +56,25 @@ tape( 'if provided `d1 <= 2`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mode( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.5, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided `d2 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mode( 3.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 3.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -115,7 +115,7 @@ tape( 'the function returns the mode of an F distribution', function test( t ) {
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.native.js
index 47f78c985071..24ee3a8e055c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,25 +65,25 @@ tape( 'if provided `d1 <= 2`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = mode( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.5, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -92,19 +92,19 @@ tape( 'if provided `d2 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = mode( 3.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 3.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns the mode of an F distribution', opts, function test(
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.factory.js
index bf281eea1ff2..e74ba90e62ee 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.factory.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -59,23 +59,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 2.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,7 +86,7 @@ tape( 'if provided a finite `d1` and `d2`, the function returns a function which
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'if provided a finite `d1` and `d2`, the function returns a function which
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -108,11 +108,11 @@ tape( 'if provided `d1 < 2.0`, the function returns a function which returns `+I
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	pdf = factory( 1.5, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	t.end();
 });
@@ -123,11 +123,11 @@ tape( 'if provided `d1 = 2.0`, the function returns a function which returns `1.
 
 	pdf = factory( 2.0, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	pdf = factory( 2.0, 3.0 );
 	y = pdf( 0.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -138,11 +138,11 @@ tape( 'if provided `d1 > 2.0`, the function returns a function which returns `0.
 
 	pdf = factory( 3.0, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	pdf = factory( 3.5, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -154,31 +154,31 @@ tape( 'if provided `d2 <= 0`, the created function always returns `NaN`', functi
 	pdf = factory( 1.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -190,31 +190,31 @@ tape( 'if provided `d1 <= 0`, the created function always returns `NaN`', functi
 	pdf = factory( 0.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -238,7 +238,7 @@ tape( 'the created function evaluates the pdf for `x` given large `d1` and `d2`
 		pdf = factory( d1[i], d2[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2300.0 * EPS * abs( expected[ i ] );
@@ -267,7 +267,7 @@ tape( 'the created function evaluates the pdf for `x` given a large parameter `d
 		pdf = factory( d1[i], d2[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
@@ -296,7 +296,7 @@ tape( 'the created function evaluates the pdf for `x` given a large parameter `d
 		pdf = factory( d1[i], d2[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1800.0 * EPS * abs( expected[ i ] );
@@ -325,7 +325,7 @@ tape( 'the created function evaluates the pdf for `x` given large `d1` and `d2`
 		pdf = factory( d1[i], d2[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
@@ -354,7 +354,7 @@ tape( 'the created function evaluates the pdf for `x` given a large parameter `d
 		pdf = factory( d1[i], d2[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 100.0 * EPS * abs( expected[ i ] );
@@ -383,7 +383,7 @@ tape( 'the created function evaluates the pdf for `x` given a large parameter `d
 		pdf = factory( d1[i], d2[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.pdf.js
index ff876af2802a..259bff65e8cd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.pdf.js
@@ -49,23 +49,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `d1` and `d2`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `d1` and `d2`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -73,22 +73,22 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,22 +97,22 @@ tape( 'if provided `d2 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,10 +121,10 @@ tape( 'if provided `d1 < 2.0`, the function returns `+Infinity` when provided `0
 	var y;
 
 	y = pdf( 0.0, 1.0, 1.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = pdf( 0.0, 1.5, 1.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	t.end();
 });
@@ -133,10 +133,10 @@ tape( 'if provided `d1 = 2.0`, the function returns `1.0` when provided `0.0` fo
 	var y;
 
 	y = pdf( 0.0, 2.0, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = pdf( 0.0, 2.0, 3.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -145,10 +145,10 @@ tape( 'if provided `d1 > 2.0`, the function returns `0.0` when provided `0.0` fo
 	var y;
 
 	y = pdf( 0.0, 3.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 0.0, 3.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -170,7 +170,7 @@ tape( 'the function evaluates the pdf for `x` given large `d1` and `d2` (tested
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2300.0 * EPS * abs( expected[ i ] );
@@ -197,7 +197,7 @@ tape( 'the function evaluates the pdf for `x` given large parameter `d1` (tested
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
@@ -224,7 +224,7 @@ tape( 'the function evaluates the pdf for `x` given large parameter `d2` (tested
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1800.0 * EPS * abs( expected[ i ] );
@@ -251,7 +251,7 @@ tape( 'the function evaluates the pdf for `x` given large `d1` and `d2` (tested
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
@@ -278,7 +278,7 @@ tape( 'the function evaluates the pdf for `x` given large parameter `d1` (tested
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 100.0 * EPS * abs( expected[ i ] );
@@ -305,7 +305,7 @@ tape( 'the function evaluates the pdf for `x` given large parameter `d2` (tested
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.factory.js
index f3776e70ec64..70d38eaf41cc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `d1` and `d2`, the function returns a function which
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,31 +98,31 @@ tape( 'if provided a nonpositive `d2`, the created function always returns `NaN`
 	quantile = factory( 1.0, 0.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -134,31 +134,31 @@ tape( 'if provided a nonpositive `d1`, the created function always returns `NaN`
 	quantile = factory( 0.0, 0.5 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -182,7 +182,7 @@ tape( 'the created function evaluates the quantile for `p` given large `d1` and
 		quantile = factory( d1[i], d2[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -211,7 +211,7 @@ tape( 'the created function evaluates the quantile for `p` given large parameter
 		quantile = factory( d1[i], d2[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
@@ -240,7 +240,7 @@ tape( 'the created function evaluates the quantile for `p` given large parameter
 		quantile = factory( d1[i], d2[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.quantile.js
index 9eaf7ffb9049..a8a26420deae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `d1` and `d2`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,25 +66,25 @@ tape( 'if provided a nonpositive `d1`, the function returns `NaN`', function tes
 	var y;
 
 	y = quantile( 0.5, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,25 +93,25 @@ tape( 'if provided a nonpositive `d2`, the function returns `NaN`', function tes
 	var y;
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the function evaluates the quantile for `x` given large parameters `d1` a
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -160,7 +160,7 @@ tape( 'the function evaluates the quantile for `x` given large parameter `d1`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
@@ -187,7 +187,7 @@ tape( 'the function evaluates the quantile for `x` given large parameter `d2`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', d1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.js
index 621b09d93e63..b072bcacdcdc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,37 +77,37 @@ tape( 'if provided `d2 <= 6`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = skewness( 2.0, 6.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 5.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function returns the skewness of an F distribution', function test( t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.native.js
index 00644906abd5..dd00f6018d65 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,37 +86,37 @@ tape( 'if provided `d2 <= 6`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = skewness( 2.0, 6.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 5.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -136,7 +136,7 @@ tape( 'the function returns the skewness of an F distribution', opts, function t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.js
index adad027963ee..c87b84ac3619 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,31 +77,31 @@ tape( 'if provided `d2 <= 4`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = stdev( 2.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function returns the standard deviation of an F distribution', functi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.native.js
index f22b2fba40de..5b4cfcf85e27 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,31 +86,31 @@ tape( 'if provided `d2 <= 4`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = stdev( 2.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function returns the standard deviation of an F distribution', opts,
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/test/test.js
index 70db10d065e4..fb92cb50e472 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Fisher\'s F distribution functions', function test( t ) {
 	var keys = objectKeys( f );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.js
index ca5ec34a3f9f..7703b799d0af 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,31 +77,31 @@ tape( 'if provided `d2 <= 4`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = variance( 2.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function returns the variance of an F distribution', function test( t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.native.js
index 24e67f9bbb8a..7a320e2f5883 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,31 +86,31 @@ tape( 'if provided `d2 <= 4`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = variance( 2.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function returns the variance of an F distribution', opts, function t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( d1[i], d2[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'd1: '+d1[i]+', d2: '+d2[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.cdf.js
index aa5a3f540639..60a484e36061 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.cdf.js
@@ -46,34 +46,34 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 1.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `alpha` and `s`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0, 1.0, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 0.0, 1.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 1.0, 1.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 2.0, 1.0, 1.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -82,25 +82,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, PINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,25 +109,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -176,7 +176,7 @@ tape( 'the function evaluates the cdf for `x` given large `s`', function test( t
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -203,7 +203,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha` and `s`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 4100.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.factory.js
index 7267a490efdf..a1dd61531273 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0, 1.0, 1.0, 0.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,27 +56,27 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0, 0.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0, 0.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN, 0.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN, 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'if provided a finite `alpha` and `s`, the function returns a function whi
 
 	cdf = factory( 1.0, 1.0, 0.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -98,19 +98,19 @@ tape( 'if provided a finite `alpha` and `s`, the function returns a function whi
 
 	cdf = factory( 1.0, 1.0, 2.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 2.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -122,30 +122,30 @@ tape( 'if provided a nonpositive `s`, the created function always returns `NaN`'
 	cdf = factory( 1.0, -1.0, 1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, 0.0, 1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF, NaN );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -169,7 +169,7 @@ tape( 'the created function evaluates the cdf for `x` given large `alpha`', func
 		cdf = factory( alpha[i], s[i], 0.0 );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -198,7 +198,7 @@ tape( 'the created function evaluates the cdf for `x` given large `s`', function
 		cdf = factory( alpha[i], s[i], 0.0 );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -227,7 +227,7 @@ tape( 'the created function evaluates the cdf for `x` given large `alpha` and `s
 		cdf = factory( alpha[i], s[i], 0.0 );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 4100.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.native.js
index 004bd996866e..836be4565649 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.native.js
@@ -55,34 +55,34 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 1.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `alpha` and `s`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 1.0, 1.0, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 1.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 0.0, 1.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 1.0, 1.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 2.0, 1.0, 1.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -91,25 +91,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = cdf( 2.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, PINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,25 +118,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the cdf for `x` given large `s`', opts, function t
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -212,7 +212,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha` and `s`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 4100.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.js
index 19ce20a53751..30d1a46b4594 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = entropy( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = entropy( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function returns the differential entropy of a Fréchet distribution'
 		y = entropy( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.native.js
index 3a429f449ae9..90c6782a2b69 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = entropy( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = entropy( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns the differential entropy of a Fréchet distribution'
 		y = entropy( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.js
index 6e953420a920..8c874997dfb6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = kurtosis( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = kurtosis( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = kurtosis( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function returns the excess kurtosis of a Fréchet distribution', fun
 		y = kurtosis( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1350.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.native.js
index 9a1c876ab5bc..3a80d773a3f7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = kurtosis( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = kurtosis( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns the excess kurtosis of a Fréchet distribution', opt
 		y = kurtosis( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1500.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.factory.js
index be24209a88ef..7872aa736e5e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 1.0, 1.0, 1.0, 0.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,27 +56,27 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0, 1.0, 0.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0, 0.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN, 0.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN, 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'if provided a finite `alpha` and `s`, the function returns a function whi
 
 	logcdf = factory( 1.0, 1.0, 0.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -98,19 +98,19 @@ tape( 'if provided a finite `alpha` and `s`, the function returns a function whi
 
 	logcdf = factory( 1.0, 1.0, 2.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( -1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 0.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 2.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -122,30 +122,30 @@ tape( 'if provided a nonpositive `s`, the created function always returns `NaN`'
 	logcdf = factory( 1.0, -1.0, 1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, 0.0, 1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NINF, 1.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF, 1.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NINF, NaN );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -169,7 +169,7 @@ tape( 'the created function evaluates the logcdf for `x` given large `alpha`', f
 		logcdf = factory( alpha[i], s[i], 0.0 );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -198,7 +198,7 @@ tape( 'the created function evaluates the logcdf for `x` given large `s`', funct
 		logcdf = factory( alpha[i], s[i], 0.0 );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -227,7 +227,7 @@ tape( 'the created function evaluates the logcdf for `x` given large `alpha` and
 		logcdf = factory( alpha[i], s[i], 0.0 );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.logcdf.js
index 9e1b8dadf448..8de286976f87 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.logcdf.js
@@ -46,34 +46,34 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 1.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `alpha` and `s`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 1.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `0`', function test( t ) {
 	var y = logcdf( NINF, 1.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 0.0, 1.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 1.0, 1.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 2.0, 1.0, 1.0, 3.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -82,25 +82,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = logcdf( 2.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, PINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,25 +109,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function evaluates the logcdf for `x` given large `alpha`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -176,7 +176,7 @@ tape( 'the function evaluates the logcdf for `x` given large `s`', function test
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -203,7 +203,7 @@ tape( 'the function evaluates the logcdf for `x` given large `alpha` and `s`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.native.js
index 780261d363fa..0d712fe1589f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.native.js
@@ -55,34 +55,34 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 1.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `alpha` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 1.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( NINF, 1.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 0.0, 1.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 1.0, 1.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 2.0, 1.0, 1.0, 3.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -91,25 +91,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = logcdf( 2.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, PINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,25 +118,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the function evaluates the logcdf for `x` given large `alpha`', opts, fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the logcdf for `x` given large `s`', opts, functio
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -212,7 +212,7 @@ tape( 'the function evaluates the logcdf for `x` given large `alpha` and `s`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.factory.js
index c921fff1c493..99df70505d53 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 1.0, 1.0, 1.0, 0.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,27 +56,27 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0, 1.0, 0.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0, 0.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN, 0.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN, 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,19 +87,19 @@ tape( 'if provided a finite `alpha` and `s`, the function returns a function whi
 
 	logpdf = factory( 1.0, 1.0, 2.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( -1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 0.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 2.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -111,30 +111,30 @@ tape( 'if provided a nonpositive `s`, the created function always returns `NaN`'
 	logpdf = factory( 1.0, -1.0, 1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, 0.0, 1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF, NaN );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the created function evaluates the logPDF for `x` given large `alpha`', f
 		logpdf = factory( alpha[i], s[i], 0.0 );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5.0 * EPS * abs( expected[ i ] );
@@ -187,7 +187,7 @@ tape( 'the created function evaluates the logPDF for `x` given large `s`', funct
 		logpdf = factory( alpha[i], s[i], 0.0 );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5.0 * EPS * abs( expected[ i ] );
@@ -216,7 +216,7 @@ tape( 'the created function evaluates the logPDF for `x` given large `alpha` and
 		logpdf = factory( alpha[i], s[i], 0.0 );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.logpdf.js
index 37a45d57a81f..a8b7a1873d9c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.logpdf.js
@@ -46,28 +46,28 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 0.0, 1.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 1.0, 1.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 2.0, 1.0, 1.0, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -76,25 +76,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = logpdf( 2.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, PINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,25 +103,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function evaluates the logPDF for `x` given large `alpha`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5.0 * EPS * abs( expected[ i ] );
@@ -170,7 +170,7 @@ tape( 'the function evaluates the logPDF for `x` given large `s`', function test
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5.0 * EPS * abs( expected[ i ] );
@@ -197,7 +197,7 @@ tape( 'the function evaluates the logPDF for `x` given large `alpha` and `s`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.native.js
index 95244ccf9a0b..e09c47b11890 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.native.js
@@ -55,28 +55,28 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 0.0, 1.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 1.0, 1.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 2.0, 1.0, 1.0, 3.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -85,25 +85,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = logpdf( 2.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, PINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -112,25 +112,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function evaluates the logPDF for `x` given large `alpha`', opts, fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5.0 * EPS * abs( expected[ i ] );
@@ -179,7 +179,7 @@ tape( 'the function evaluates the logPDF for `x` given large `s`', opts, functio
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5.0 * EPS * abs( expected[ i ] );
@@ -206,7 +206,7 @@ tape( 'the function evaluates the logPDF for `x` given large `alpha` and `s`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.js
index 9f96323e2cf6..9fb75c9f6e63 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = mean( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = mean( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function returns the expected value of a Fréchet distribution', func
 		y = mean( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.native.js
index 134fb53136ac..06b2d20df5f4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mean( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mean( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns the expected value of a Fréchet distribution', opts
 		y = mean( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.js
index 24acba2c9958..c01047b7fcfa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = median( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = median( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = median( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = median( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function returns the median of a Fréchet distribution', function tes
 		y = median( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.native.js
index a25f85a587e7..cc1ce2a5c58f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = median( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = median( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = median( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = median( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns the median of a Fréchet distribution', opts, functi
 		y = median( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.js
index acb90a3cc118..adee00d6d653 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = mode( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = mode( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function returns the mode of a Fréchet distribution', function test(
 		y = mode( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.native.js
index fe52a451ca42..12cc7b242ab7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mode( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mode( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns the mode of a Fréchet distribution', opts, function
 		y = mode( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.factory.js
index c3ca36c1c8a1..87bf4aaadf4a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 1.0, 1.0, 1.0, 0.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,27 +56,27 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0, 1.0, 0.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0, 0.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN, 0.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN, 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,19 +87,19 @@ tape( 'if provided a finite `alpha` and `s`, the function returns a function whi
 
 	pdf = factory( 1.0, 1.0, 2.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 2.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -111,30 +111,30 @@ tape( 'if provided a nonpositive `s`, the created function always returns `NaN`'
 	pdf = factory( 1.0, -1.0, 1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, 0.0, 1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF, NaN );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the created function evaluates the pdf for `x` given large `alpha`', func
 		pdf = factory( alpha[i], s[i], 0.0 );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
@@ -187,7 +187,7 @@ tape( 'the created function evaluates the pdf for `x` given large `s`', function
 		pdf = factory( alpha[i], s[i], 0.0 );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -216,7 +216,7 @@ tape( 'the created function evaluates the pdf for `x` given large `alpha` and `s
 		pdf = factory( alpha[i], s[i], 0.0 );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1200.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.pdf.js
index 6a5e6bac841e..6462afd876fe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.pdf.js
@@ -46,28 +46,28 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 0.0, 1.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 1.0, 1.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 2.0, 1.0, 1.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -76,25 +76,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = pdf( 2.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, PINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,25 +103,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 150.0 * EPS * abs( expected[ i ] );
@@ -170,7 +170,7 @@ tape( 'the function evaluates the pdf for `x` given large `s`', function test( t
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -197,7 +197,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha` and `s`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1200.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.factory.js
index e8dbaf6b76b4..127f03c7b21a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 1.0, 1.0, 1.0, 0.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,27 +56,27 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0, 1.0, 0.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0, 0.0 );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN, 0.0 );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN, 1.0, NaN );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN, NaN );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,30 +88,30 @@ tape( 'if provided a nonpositive `s`, the created function always returns `NaN`'
 	quantile = factory( 1.0, -1.0, 1.0 );
 
 	y = quantile( 0.6 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, 0.0, 1.0 );
 
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NINF, 1.0 );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF, 1.0 );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF, NaN );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -119,9 +119,9 @@ tape( 'if provided a nonpositive `s`, the created function always returns `NaN`'
 tape( 'the created function returns `NaN` if provided a number outside `[0,1]`', function test( t ) {
 	var quantile = factory( 1.0, 1.0, 0.0 );
 	var y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -144,7 +144,7 @@ tape( 'the created function evaluates the quantile function for `p` given large
 		quantile = factory( alpha[i], s[i], 0.0 );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the created function evaluates the quantile function for `p` given large
 		quantile = factory( alpha[i], s[i], 0.0 );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -202,7 +202,7 @@ tape( 'the created function evaluates the quantile function for `p` given large
 		quantile = factory( alpha[i], s[i], 0.0 );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.native.js
index dcea74092935..83b895295304 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.native.js
@@ -55,13 +55,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.5, NaN, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.5, 1.0, NaN, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.5, 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -69,10 +69,10 @@ tape( 'if provided `p < 0` or `p > 1`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = quantile( -0.1, 1.0, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1, 1.0, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,25 +81,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = quantile( 0.5, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, PINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -108,25 +108,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 1.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, PINF, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NaN, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -148,7 +148,7 @@ tape( 'the function evaluates the quantile for `p` given large `alpha`', opts, f
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 300.0 * EPS * abs( expected[ i ] );
@@ -175,7 +175,7 @@ tape( 'the function evaluates the quantile for `p` given large `s`', opts, funct
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1500.0 * EPS * abs( expected[ i ] );
@@ -202,7 +202,7 @@ tape( 'the function evaluates the quantile for `p` given large `alpha` and `s`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 4100.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.quantile.js
index 4555a8533fee..7f534b501221 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.quantile.js
@@ -46,21 +46,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, NaN, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, 1.0, NaN, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 1.0, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -68,25 +68,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = quantile( 0.3, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, -1.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 0.0, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.3, NINF, PINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.3, NINF, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,25 +95,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = quantile( 0.3, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 2.0, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 2.0, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.3, 1.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, PINF, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.1, NaN, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -135,7 +135,7 @@ tape( 'the function evaluates the quantile function for `p` given large `alpha`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -162,7 +162,7 @@ tape( 'the function evaluates the quantile function for `p` given large `s`', fu
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -189,7 +189,7 @@ tape( 'the function evaluates the quantile function for `p` given large `alpha`
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], s[i], 0.0 );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.js
index 3e4ec59ded1d..ba4c7d38c12a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = skewness( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = skewness( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = skewness( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function returns the skewness of a Fréchet distribution', function t
 		y = skewness( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 140.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.native.js
index 835dbc12f817..5d9230d3989c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = skewness( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = skewness( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns the skewness of a Fréchet distribution', opts, func
 		y = skewness( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 140.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.js
index 947c96186d66..2aa39b36f9c4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = stdev( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = stdev( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function returns the standard deviation of a Fréchet distribution',
 		y = stdev( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.native.js
index bee23714f318..96e7e809adb3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = stdev( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = stdev( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns the standard deviation of a Fréchet distribution',
 		y = stdev( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/test/test.js
index 49251b941da3..6f0d46ef1aab 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Fréchet distribution functions', function test( t ) {
 	var keys = objectKeys( frechet );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.js
index 0b4385f39cd1..f60d6f535627 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = variance( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = variance( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function returns the variance of a Fréchet distribution', function t
 		y = variance( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 45.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.native.js
index 3a5e411a0d2e..d560dabd43d9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = variance( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( -1.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = variance( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns the variance of a Fréchet distribution', opts, func
 		y = variance( alpha[i], s[i], 0.0 );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'alpha:'+alpha[i]+', s: '+s[i]+', m: 0, y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 45.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.cdf.js
index f8a9362d9173..c3f68d7b43c7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `alpha`, the function returns `NaN`', function tes
 	var y;
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,25 +94,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,22 +121,22 @@ tape( 'if provided an `alpha` equal to `0` and `beta` is positive, the function
 	var y;
 
 	y = cdf( PINF, 0.0, 2.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than 0' );
 
 	y = cdf( 2.5, 0.0, 2.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than 0' );
 
 	y = cdf( 0.0, 0.0, 2.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = cdf( -2.0, 0.0, 2.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than 0' );
 
 	y = cdf( NINF, 0.0, 2.0 );
-	t.equal( y, 0.0, 'returns  0 for x smaller than 0' );
+	t.strictEqual( y, 0.0, 'returns  0 for x smaller than 0' );
 
 	y = cdf( NaN, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha` and `beta`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 140.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the cdf for `x` given large shape parameter `alpha
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 120.0 * EPS * abs( expected[ i ] );
@@ -212,7 +212,7 @@ tape( 'the function evaluates the cdf for `x` given large rate parameter `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.factory.js
index dc0837e6680f..141a9da142c3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositiveeta`, the created function always returns `NaN`'
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -145,26 +145,26 @@ tape( 'if provided a negative `alpha`, the created function always returns `NaN`
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -176,22 +176,22 @@ tape( 'if `alpha` equals `0` and `beta` is positive, the created function evalua
 	cdf = factory( 0.0, 2.0 );
 
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1 for x greater than one' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than one' );
 
 	y = cdf( 3.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than 0' );
 
 	y = cdf( 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = cdf( -0.5 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than one' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than one' );
 
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0 for x smaller than one' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than one' );
 
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the created function evaluates the cdf for `x` given large `alpha` and `b
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 140.0 * EPS * abs( expected[ i ] );
@@ -244,7 +244,7 @@ tape( 'the created function evaluates the cdf for `x` given large shape paramete
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 120.0 * EPS * abs( expected[ i ] );
@@ -273,7 +273,7 @@ tape( 'the created function evaluates the cdf for `x` given large rate parameter
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.native.js
index 468df28ffbe3..7e79be71ef9a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.native.js
@@ -49,7 +49,7 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof cdf, 'function', 'main export is a function' );
+	t.strictEqual( typeof cdf, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -57,13 +57,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = cdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -72,22 +72,22 @@ tape( 'if provided a negative `alpha`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -96,25 +96,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -136,7 +136,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 120.0 * EPS * abs( expected[ i ] );
@@ -163,7 +163,7 @@ tape( 'the function evaluates the cdf for `x` given large `beta`', opts, functio
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
@@ -190,7 +190,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha` and `beta`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 140.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.js
index c8940ce4e691..85008afeef11 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.js
@@ -43,10 +43,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -55,19 +55,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,19 +76,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -108,7 +108,7 @@ tape( 'the function returns the differential entropy of a gamma distribution', f
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1e-10 * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.native.js
index f94b633c3ff1..b40692e9b5b1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.native.js
@@ -52,10 +52,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -64,19 +64,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,19 +85,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -117,7 +117,7 @@ tape( 'the function returns the differential entropy of a gamma distribution', o
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1e-10 * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.js
index 3415916787a1..b117b2a9bd49 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the excess kurtosis of a gamma distribution', functi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.native.js
index 07897f39cd28..3a8ef18e9baa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the excess kurtosis of a gamma distribution', opts,
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.factory.js
index 068554daf6b0..5a140270645c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.factory.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -51,23 +51,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -78,7 +78,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -101,34 +101,34 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	logcdf = factory( 2.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 2.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 2.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -140,26 +140,26 @@ tape( 'if provided `alpha < 0`, the created function always returns `NaN`', func
 	logcdf = factory( -1.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, 1.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, PINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NaN );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -171,22 +171,22 @@ tape( 'if `alpha` equals `0`, the created function evaluates a degenerate distri
 	logcdf = factory( 0.0, 2.0 );
 
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0 for x greater than 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x greater than 0' );
 
 	y = logcdf( 2.5 );
-	t.equal( y, 0.0, 'returns 0 for x greater than 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x greater than 0' );
 
 	y = logcdf( 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x equal to 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x equal to 0' );
 
 	y = logcdf( -2.0 );
-	t.equal( y, NINF, 'returns -Infinity for x smaller than 0' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x smaller than 0' );
 
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity for x smaller than 0' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x smaller than 0' );
 
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -207,7 +207,7 @@ tape( 'the created function evaluates the logarithm of the CDF', function test(
 		logcdf = factory( alpha, beta );
 		y = logcdf( x );
 		expected = ln( cdf( x, alpha, beta ) );
-		t.equal( y, expected, 'x: '+x+', alpha: '+alpha+', beta: '+beta+', y: '+y+', expected: '+expected );
+		t.strictEqual( y, expected, 'x: '+x+', alpha: '+alpha+', beta: '+beta+', y: '+y+', expected: '+expected );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.js
index 2ecaf2af97cd..e2ad888c8e9d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.logcdf.js
index 085c07d8e503..210d8074a724 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.logcdf.js
@@ -43,26 +43,26 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logcdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `1`', function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided `alpha < 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,25 +94,25 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -121,22 +121,22 @@ tape( 'if provided an `alpha` equal to `0` and `beta` is positive, the function
 	var y;
 
 	y = logcdf( PINF, 0.0, 2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 2.5, 0.0, 2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, 2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( -2.0, 0.0, 2.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( NINF, 0.0, 2.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( NaN, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function evaluates the logarithm of the CDF', function test( t ) {
 		beta = uniform( EPS, 10.0 );
 		y = logcdf( x, alpha, beta );
 		expected = ln( cdf( x, alpha, beta ) );
-		t.equal( y, expected, 'x: '+x+', alpha: '+alpha+', beta: '+beta+', y: '+y+', expected: '+expected );
+		t.strictEqual( y, expected, 'x: '+x+', alpha: '+alpha+', beta: '+beta+', y: '+y+', expected: '+expected );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.native.js
index cd27c532f8b1..ae3798841625 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.native.js
@@ -45,7 +45,7 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof logcdf, 'function', 'main export is a function' );
+	t.strictEqual( typeof logcdf, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -53,26 +53,26 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = logcdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `1`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -80,22 +80,22 @@ tape( 'if provided `alpha < 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,25 +104,25 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -131,22 +131,22 @@ tape( 'if provided an `alpha` equal to `0` and `beta` is positive, the function
 	var y;
 
 	y = logcdf( PINF, 0.0, 2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 2.5, 0.0, 2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, 2.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( -2.0, 0.0, 2.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( NINF, 0.0, 2.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( NaN, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -168,7 +168,7 @@ tape( 'the function evaluates the logarithm of the CDF', opts, function test( t
 		y = logcdf( x, alpha, beta );
 		expected = ln( cdf( x, alpha, beta ) );
 		if ( y === expected ) {
-			t.equal( y, expected, 'x: '+x+', alpha: '+alpha+', beta: '+beta+', y: '+y+', expected: '+expected );
+			t.strictEqual( y, expected, 'x: '+x+', alpha: '+alpha+', beta: '+beta+', y: '+y+', expected: '+expected );
 		} else {
 			// NOTE: increased test tolerance due to differences in accumulated error between JavaScript and C, especially as we are wrapping `cdf` which relies on `gammainc`, where compiler optimizations can result in different error propagation
 			delta = abs( y - expected );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.factory.js
index b0badf952851..506649711f59 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	logpdf = factory( 2.0, 0.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 2.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 2.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -145,26 +145,26 @@ tape( 'if provided `alpha < 0`, the created function always returns `NaN`', func
 	logpdf = factory( -1.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -176,22 +176,22 @@ tape( 'if `alpha` equals `0`, the created function evaluates a degenerate distri
 	logpdf = factory( 0.0, 2.0 );
 
 	y = logpdf( -2.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = logpdf( 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the created function evaluates the logpdf for `x` given large `alpha` and
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 900.0 * EPS * abs( expected[ i ] );
@@ -244,7 +244,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large shape par
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 350.0 * EPS * abs( expected[ i ] );
@@ -273,7 +273,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large rate para
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 350.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.logpdf.js
index ccf026f99f41..61eb7adb381a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided `alpha < 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,25 +94,25 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,22 +121,22 @@ tape( 'if `alpha` equals `0`, the function evaluates a degenerate distribution c
 	var y;
 
 	y = logpdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = logpdf( 1.0, 0.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -1.5, 0.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( PINF, 0.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( NINF, 0.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha` and `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 900.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the logpdf for `x` given large shape parameter `al
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 350.0 * EPS * abs( expected[ i ] );
@@ -212,7 +212,7 @@ tape( 'the function evaluates the logpdf for `x` given large rate parameter `bet
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 350.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.native.js
index 9b99333f0558..56c9e3e6c7b7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided `alpha < 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,25 +103,25 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -130,22 +130,22 @@ tape( 'if `alpha` equals `0`, the function evaluates a degenerate distribution c
 	var y;
 
 	y = logpdf( 0.0, 0.0, 1.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = logpdf( 1.0, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -1.5, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -167,7 +167,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha` and `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 900.0 * EPS * abs( expected[ i ] );
@@ -194,7 +194,7 @@ tape( 'the function evaluates the logpdf for `x` given large shape parameter `al
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 350.0 * EPS * abs( expected[ i ] );
@@ -221,7 +221,7 @@ tape( 'the function evaluates the logpdf for `x` given large rate parameter `bet
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 350.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.js
index ee2e3d0a581b..1239c552c125 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the mean of a gamma distribution', function test( t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.native.js
index b1dc711b818f..a2a8c5e9c8f1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the mean of a gamma distribution', opts, function te
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.factory.js
index 8903aff4e7bf..7aba3afa4ba4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0, 1.0 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,26 +84,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	mgf = factory( 0.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -115,26 +115,26 @@ tape( 'if provided `alpha < 0`, the created function always returns `NaN`', func
 	mgf = factory( -1.0, 0.5 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, 1.0 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, PINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NaN );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the created function evaluates the mgf for `x` given large `alpha` and `b
 		mgf = factory( alpha[i], beta[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3000.0 * EPS * abs( expected[ i ] );
@@ -187,7 +187,7 @@ tape( 'the created function evaluates the mgf for `x` given a large shape parame
 		mgf = factory( alpha[i], beta[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 6500.0 * EPS * abs( expected[ i ] );
@@ -216,7 +216,7 @@ tape( 'the created function evaluates the mgf for `x` given a large rate paramet
 		mgf = factory( alpha[i], beta[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1200.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.mgf.js
index 53389e0ff004..39e77da04fb4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.mgf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,22 +58,22 @@ tape( 'if provided a negative `alpha`, the function returns `NaN`', function tes
 	var y;
 
 	y = mgf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -82,22 +82,22 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function evaluates the MGF for `x` given large `alpha` and `beta`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3000.0 * EPS * abs( expected[ i ] );
@@ -146,7 +146,7 @@ tape( 'the function evaluates the MGF for `x` given large shape parameter `alpha
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 6500.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the function evaluates the MGF for `x` given large rate parameter `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2200.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.native.js
index f36e6a2930f9..f3182b82a54a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.native.js
@@ -55,11 +55,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -67,22 +67,22 @@ tape( 'if provided a negative `alpha`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = mgf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -91,22 +91,22 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function evaluates the MGF for `x` given large `alpha` and `beta`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3000.0 * EPS * abs( expected[ i ] );
@@ -155,7 +155,7 @@ tape( 'the function evaluates the MGF for `x` given large shape parameter `alpha
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 6500.0 * EPS * abs( expected[ i ] );
@@ -182,7 +182,7 @@ tape( 'the function evaluates the MGF for `x` given large rate parameter `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2200.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.js
index 8f86a7b70c5a..a926fa2284ac 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the mode of a gamma distribution', function test( t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.native.js
index f79c975fbb85..4809c53980af 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the mode of a gamma distribution', opts, function te
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.factory.js
index 72c1ac3a25d7..388f2c7efd8f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	pdf = factory( 2.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 2.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 2.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -145,26 +145,26 @@ tape( 'if provided `alpha < 0`, the created function always returns `NaN`', func
 	pdf = factory( -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -176,22 +176,22 @@ tape( 'if `alpha` equals `0`, the created function evaluates a degenerate distri
 	pdf = factory( 0.0, 2.0 );
 
 	y = pdf( -2.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -215,7 +215,7 @@ tape( 'the created function evaluates the pdf for `x` given large `alpha` and `b
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 170.0 * EPS * abs( expected[ i ] );
@@ -244,7 +244,7 @@ tape( 'the created function evaluates the pdf for `x` given a large shape parame
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 140.0 * EPS * abs( expected[ i ] );
@@ -273,7 +273,7 @@ tape( 'the created function evaluates the pdf for `x` given a large rate paramet
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 120.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.native.js
index df7cd0edc532..f4caa4481a47 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided `alpha < 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,25 +103,25 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -130,22 +130,22 @@ tape( 'if `alpha` equals `0`, the function evaluates a degenerate distribution c
 	var y;
 
 	y = pdf( 0.0, 0.0, 1.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 1.0, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -1.5, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( PINF, 0.0, 1.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NINF, 0.0, 1.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NaN, 0.0, 1, 5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -167,7 +167,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha` and `beta`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 170.0 * EPS * abs( expected[ i ] );
@@ -194,7 +194,7 @@ tape( 'the function evaluates the pdf for `x` given large shape parameter `alpha
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 140.0 * EPS * abs( expected[ i ] );
@@ -221,7 +221,7 @@ tape( 'the function evaluates the pdf for `x` given large rate parameter `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 120.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.pdf.js
index 9aee90f6bedf..55e48d0b7852 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided `alpha < 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,25 +94,25 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,22 +121,22 @@ tape( 'if `alpha` equals `0`, the function evaluates a degenerate distribution c
 	var y;
 
 	y = pdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 1.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -1.5, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( PINF, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NINF, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha` and `beta`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 170.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the pdf for `x` given large shape parameter `alpha
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 140.0 * EPS * abs( expected[ i ] );
@@ -212,7 +212,7 @@ tape( 'the function evaluates the pdf for `x` given large rate parameter `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 120.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.factory.js
index 50ccf060d609..14d80a0e8bd9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,34 +98,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	quantile = factory( 2.0, 0.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 2.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 2.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,26 +137,26 @@ tape( 'if provided a negative `alpha`, the created function always returns `NaN`
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -168,16 +168,16 @@ tape( 'if `alpha` equals `0`, the created function evaluates a degenerate distri
 	quantile = factory( 0.0, 2.0 );
 
 	y = quantile( 0.3 );
-	t.equal( y, 0.0, 'returns 0 for p inside [0,1]' );
+	t.strictEqual( y, 0.0, 'returns 0 for p inside [0,1]' );
 
 	y = quantile( 0.9 );
-	t.equal( y, 0.0, 'returns 0 for p inside [0,1]' );
+	t.strictEqual( y, 0.0, 'returns 0 for p inside [0,1]' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	t.end();
 });
@@ -201,7 +201,7 @@ tape( 'the created function evaluates the quantile for `p` given large `alpha` a
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1350.0 * EPS * abs( expected[ i ] );
@@ -230,7 +230,7 @@ tape( 'the created function evaluates the quantile for `p` given large shape par
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -259,7 +259,7 @@ tape( 'the created function evaluates the quantile for `p` given large rate para
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 200.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.quantile.js
index 78934194e866..21e9e610368f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `alpha` and `beta`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,22 +66,22 @@ tape( 'if provided a negative `alpha`, the function returns `NaN`', function tes
 	var y;
 
 	y = quantile( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -90,39 +90,39 @@ tape( 'if provided a nonpositive`beta`, the function returns `NaN`', function te
 	var y;
 
 	y = quantile( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `alpha` equal to `0.0`, the function returns `0.0` for  a valid `p`', function test( t ) {
 	var y = quantile( 0.2, 0.0, 2.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	y = quantile( 0.9, 0.0, 2.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = quantile( 1.1, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( -0.1, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'the function evaluates the quantile for `x` given large parameters `alpha
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1350.0 * EPS * abs( expected[ i ] );
@@ -171,7 +171,7 @@ tape( 'the function evaluates the quantile for `x` given large shape parameter `
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -198,7 +198,7 @@ tape( 'the function evaluates the quantile for `x` given large rate parameter `b
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 200.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.js
index f2df1772776e..7e5a780c7060 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the skewness of a gamma distribution', function test
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.native.js
index fb38d448b10d..630dccff9019 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the skewness of a gamma distribution', opts, functio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.js
index 1c7626b23f20..e74adbf921a5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the standard deviation of a gamma distribution', fun
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.native.js
index 523e2c191d62..8c50705b5081 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the standard deviation of a gamma distribution', opt
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/test/test.js
index 4fb12c32e169..826ebdb91ab1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains gamma distribution functions', function test( t ) {
 	var keys = objectKeys( gamma );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.js
index faee647adf98..92fd8702d450 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the variance of a gamma distribution', function test
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.native.js
index 3c959af76e38..b72c6c20548e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the variance of a gamma distribution', opts, functio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.cdf.js
index 5dc9cd3905a2..8b66c86dda45 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.cdf.js
@@ -45,27 +45,27 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -4.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -0.5, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -74,16 +74,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = cdf( 3.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 3.0, -0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 3.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function evaluates the cdf for `x` given small parameter `p`', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -128,7 +128,7 @@ tape( 'the function evaluates the cdf for `x` given large parameter `p`', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.factory.js
index 5ea2080a0827..7a5012cd9acb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.5 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a valid `p`, the function returns a function which returns `1
 
 	cdf = factory( 0.5 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -81,16 +81,16 @@ tape( 'if provided a valid `p`, the function returns a function which returns `0
 
 	cdf = factory( 0.5 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -20.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -2.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -101,21 +101,21 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the created fun
 
 	cdf = factory( -1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.5 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'the created function evaluates the cdf for `x` given small parameter `p`'
 		cdf = factory( p[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -164,7 +164,7 @@ tape( 'the created function evaluates the cdf for `x` given large parameter `p`'
 		cdf = factory( p[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.native.js
index da2ca3cf4502..750ec77fc617 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.native.js
@@ -54,27 +54,27 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -4.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -0.5, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -83,16 +83,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = cdf( 3.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 3.0, -0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 3.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -112,7 +112,7 @@ tape( 'the function evaluates the cdf for `x` given small parameter `p`', opts,
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -137,7 +137,7 @@ tape( 'the function evaluates the cdf for `x` given large parameter `p`', opts,
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.js
index 21e829750f62..6eacfa513c5c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the entropy of a geometric distribution', function t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.native.js
index 04d328c09ce8..c3772c5fe0c3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var k = entropy( NaN );
-	t.equal( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var k;
 
 	k = entropy( -1.0 );
-	t.equal( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns NaN' );
 
 	k = entropy( 1.5 );
-	t.equal( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns NaN' );
 
 	k = entropy( NINF );
-	t.equal( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns NaN' );
 
 	k = entropy( PINF );
-	t.equal( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the entropy of a geometric distribution', opts, func
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.js
index 0ef55e9ac9c4..b47383564c57 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the excess kurtosis of a geometric distribution', fu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.native.js
index 4ed4e5f6b868..a828220f997b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var k = kurtosis( NaN );
-	t.equal( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var k;
 
 	k = kurtosis( -1.0 );
-	t.equal( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns NaN' );
 
 	k = kurtosis( 1.5 );
-	t.equal( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns NaN' );
 
 	k = kurtosis( NINF );
-	t.equal( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns NaN' );
 
 	k = kurtosis( PINF );
-	t.equal( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the excess kurtosis of a geometric distribution', op
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.factory.js
index 2ff131cb9439..9558bde2eb30 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.5 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.5 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a valid `p`, the function returns a function which returns `0
 
 	logcdf = factory( 0.5 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -81,15 +81,15 @@ tape( 'if provided a valid `p`, the function returns a function which returns `-
 
 	logcdf = factory( 0.5 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( -20.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( -2.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	y = logcdf( -0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -100,21 +100,21 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the created fun
 
 	logcdf = factory( -1.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.5 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -136,7 +136,7 @@ tape( 'the created function evaluates the logcdf for `x` given small parameter `
 		logcdf = factory( p[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -163,7 +163,7 @@ tape( 'the created function evaluates the logcdf for `x` given large parameter `
 		logcdf = factory( p[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.logcdf.js
index 3548c834caac..838cb6fb2d06 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.logcdf.js
@@ -45,27 +45,27 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( -4.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( -0.5, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -74,16 +74,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = logcdf( 3.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 3.0, -0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 3.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function evaluates the logcdf for `x` given small parameter `p`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -128,7 +128,7 @@ tape( 'the function evaluates the logcdf for `x` given large parameter `p`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.native.js
index a3ae8d441466..5394609ed739 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.native.js
@@ -54,27 +54,27 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `p`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( -4.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( -0.5, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -83,16 +83,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = logcdf( 3.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 3.0, -0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 3.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -112,7 +112,7 @@ tape( 'the function evaluates the logcdf for `x` given small parameter `p`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -137,7 +137,7 @@ tape( 'the function evaluates the logcdf for `x` given large parameter `p`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.factory.js
index 78b0a1746155..686213e5944b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 0.5 );
-	t.equal( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpmf = factory( 0.5 );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( NaN );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	logpmf = factory( 1.0 );
 	y = logpmf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -81,10 +81,10 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	logpmf = factory( 0.4 );
 	y = logpmf( -4.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -95,19 +95,19 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	logpmf = factory( 0.4 );
 	y = logpmf( 1.3 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 1.4 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 3.2 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 4.8 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -1.2 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -119,18 +119,18 @@ tape( 'if provided a `p` outside of `[0,1]`, the created function always returns
 	logpmf = factory( -1.5 );
 
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( 1.2 );
 
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the created function evaluates the logpmf for `x` given small `p`', funct
 		logpmf = factory( p[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -179,7 +179,7 @@ tape( 'the function evaluates the logpmf for `x` given large `p`', function test
 		logpmf = factory( p[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.js
index 373f96b89f76..bb8d4629a397 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpmf` functions', function test( t ) {
-	t.equal( typeof logpmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.logpmf.js
index 7bb65f7e8ac8..d61a8a3e2cd2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.logpmf.js
@@ -45,40 +45,40 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpmf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( PINF, 0.01 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( -20.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -4.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -1.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( -1.3, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 2.4, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 0.5, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -87,10 +87,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function al
 	var y;
 
 	y = logpmf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function evaluates the logpmf for `x` given small parameter `p`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p:'+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p:'+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -135,7 +135,7 @@ tape( 'the function evaluates the logpmf for `x` given large parameter `p`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.native.js
index c55e9990e824..e7876ad71241 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.native.js
@@ -54,40 +54,40 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpmf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( PINF, 0.01 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `p`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( -20.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -4.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -1.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `p`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( -1.3, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 2.4, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 0.5, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -96,10 +96,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function al
 	var y;
 
 	y = logpmf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function evaluates the logpmf for `x` given small parameter `p`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p:'+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p:'+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -144,7 +144,7 @@ tape( 'the function evaluates the logpmf for `x` given large parameter `p`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.js
index ffb738a5041c..75752cc8cf8d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the mean of a geometric distribution', function test
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.native.js
index 33be2c3edfe0..98d222423bec 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var m = mean( NaN );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var m;
 
 	m = mean( -1.0 );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	m = mean( 1.5 );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	m = mean( NINF );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	m = mean( PINF );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the mean of a geometric distribution', opts, functio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.js
index f6fa4c457e33..9848114d410f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -50,16 +50,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = median( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns the median of a geometric distribution', function te
 	p = data.p;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( p[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.native.js
index 7451cdb49c59..86653839c24e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var m = median( NaN );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var m;
 
 	m = median( -1.0 );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	m = median( 1.5 );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	m = median( NINF );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	m = median( PINF );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the median of a geometric distribution', opts, funct
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.factory.js
index 7a7d04c9f13d..e4208abdbfaf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.5 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.5 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -70,27 +70,27 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the created fun
 
 	mgf = factory( -1.0 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 1.5 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( PINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -112,7 +112,7 @@ tape( 'the created function evaluates the mgf for `x` given small parameter `p`'
 		mgf = factory( p[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
@@ -139,7 +139,7 @@ tape( 'the created function evaluates the mgf for `x` given large parameter `p`'
 		mgf = factory( p[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.mgf.js
index f8c59e3722ca..82953e99c5d1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.mgf.js
@@ -45,9 +45,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -55,16 +55,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = mgf( 3.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 3.0, -0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 3.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'the function evaluates the mgf for `x` given small parameter `p`', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
@@ -109,7 +109,7 @@ tape( 'the function evaluates the mgf for `x` given large parameter `p`', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.native.js
index 770c42c9506c..8f0106a9a2fd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.native.js
@@ -54,9 +54,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -64,16 +64,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = mgf( 3.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 3.0, -0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 3.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function evaluates the mgf for `x` given small parameter `p`', opts,
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
@@ -118,7 +118,7 @@ tape( 'the function evaluates the mgf for `x` given large parameter `p`', opts,
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.js
index 0b4ec4bcd274..2d6b9730adfb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -50,16 +50,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns the mode of a geometric distribution', function test
 	p = data.p;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( p[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.native.js
index 8a56a3061040..79078bc48aa4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var m = mode( NaN );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -59,16 +59,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var m;
 
 	m = mode( -1.0 );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	m = mode( 1.5 );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	m = mode( NINF );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	m = mode( PINF );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns the mode of a geometric distribution', opts, functio
 	p = data.p;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( p[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.factory.js
index bc352c6e02f9..aee3a199cb45 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 0.5 );
-	t.equal( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 0.5 );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	pmf = factory( 1.0 );
 	y = pmf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -80,10 +80,10 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	pmf = factory( 0.4 );
 	y = pmf( -4.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,19 +94,19 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	pmf = factory( 0.4 );
 	y = pmf( 1.3 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 1.4 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 3.2 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 4.8 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.2 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -118,18 +118,18 @@ tape( 'if provided a `p` outside of `[0,1]`, the created function always returns
 	pmf = factory( -1.5 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( 1.2 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -151,7 +151,7 @@ tape( 'the created function evaluates the pmf for `x` given small `p`', function
 		pmf = factory( p[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -178,7 +178,7 @@ tape( 'the function evaluates the pmf for `x` given large `p`', function test( t
 		pmf = factory( p[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.js
index 686bb53fea47..33c536be2daf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pmf` functions', function test( t ) {
-	t.equal( typeof pmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.native.js
index 57ca72e657ef..40a056bc237c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.native.js
@@ -53,40 +53,40 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pmf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( PINF, 0.01 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( -20.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -4.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( -1.3, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 2.4, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 0.5, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -95,10 +95,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function al
 	var y;
 
 	y = pmf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function evaluates the pmf for `x` given small parameter `p`', opts,
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p:'+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p:'+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the pmf for `x` given large parameter `p`', opts,
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.pmf.js
index f69e75fcbe82..3b838aaca1cd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.pmf.js
@@ -44,40 +44,40 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = pmf( PINF, 0.01 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = pmf( -20.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -4.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = pmf( -1.3, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 2.4, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 0.5, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -86,10 +86,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function al
 	var y;
 
 	y = pmf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function evaluates the pmf for `x` given small parameter `p`', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p:'+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p:'+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -134,7 +134,7 @@ tape( 'the function evaluates the pmf for `x` given large parameter `p`', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.factory.js
index 2759b8c54f37..2491b0f54f33 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -69,10 +69,10 @@ tape( 'if provided a valid success probability `p`, the function returns a funct
 
 	quantile = factory( 0.8 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid success probability `p`, the function returns a funct
 
 	quantile = factory( 0.5 );
 	y = quantile( 1.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	t.end();
 });
@@ -95,18 +95,18 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the created functi
 	quantile = factory( -1.0 );
 
 	y = quantile( 0.4 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.5 );
 
 	y = quantile( 0.4 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the created function evaluates the quantile for `r` given small parameter
 		quantile = factory( p[i] );
 		y = quantile( r[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -155,7 +155,7 @@ tape( 'the created function evaluates the quantile for `r` given large parameter
 		quantile = factory( p[i] );
 		y = quantile( r[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.native.js
index a5e01a58ccdc..8a9f7ef97254 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.native.js
@@ -54,25 +54,25 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `r` and a valid `p`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 2.2, 0.8 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.2, 0.8 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'if provided `1.0` for `r` and a valid `p`, the function returns `+Infinity`', opts, function test( t ) {
 	var y = quantile( 1.0, 0.5 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 	y = quantile( 1.0, 0.5 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 	t.end();
 });
 
@@ -80,13 +80,13 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the function alway
 	var y;
 
 	y = quantile( 0.8, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.9, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function evaluates the quantile for `r` given small parameter `p`', o
 	for ( i = 0; i < r.length; i++ ) {
 		y = quantile( r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -131,7 +131,7 @@ tape( 'the function evaluates the quantile for `r` given large parameter `p`', o
 	for ( i = 0; i < r.length; i++ ) {
 		y = quantile( r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.quantile.js
index d6d9a944cc2c..e8ee975e8e31 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.quantile.js
@@ -45,25 +45,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `r` and a valid `p`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 2.2, 0.8 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.2, 0.8 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'if provided `1.0` for `r` and a valid `p`, the function returns `+Infinity`', function test( t ) {
 	var y = quantile( 1.0, 0.5 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 	y = quantile( 1.0, 0.5 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 	t.end();
 });
 
@@ -71,13 +71,13 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the function alway
 	var y;
 
 	y = quantile( 0.8, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.9, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function evaluates the quantile for `r` given small parameter `p`', f
 	for ( i = 0; i < r.length; i++ ) {
 		y = quantile( r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -122,7 +122,7 @@ tape( 'the function evaluates the quantile for `r` given large parameter `p`', f
 	for ( i = 0; i < r.length; i++ ) {
 		y = quantile( r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.js
index f7806d91c3b3..02d792195da2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = skewness( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the skewness of a geometric distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.native.js
index 52377db074d0..2dc32a4d2de8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var s = skewness( NaN );
-	t.equal( isnan( s ), true, 'returns NaN' );
+	t.strictEqual( isnan( s ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var s;
 
 	s = skewness( -1.0 );
-	t.equal( isnan( s ), true, 'returns NaN' );
+	t.strictEqual( isnan( s ), true, 'returns NaN' );
 
 	s = skewness( 1.5 );
-	t.equal( isnan( s ), true, 'returns NaN' );
+	t.strictEqual( isnan( s ), true, 'returns NaN' );
 
 	s = skewness( NINF );
-	t.equal( isnan( s ), true, 'returns NaN' );
+	t.strictEqual( isnan( s ), true, 'returns NaN' );
 
 	s = skewness( PINF );
-	t.equal( isnan( s ), true, 'returns NaN' );
+	t.strictEqual( isnan( s ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the skewness of a geometric distribution', opts, fun
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.js
index 85be55c802d7..c00dfd6203ae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the standard deviation of a geometric distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.native.js
index adff55f454f9..1f4d0d6c56aa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var m = stdev( NaN );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var m;
 
 	m = stdev( -1.0 );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	m = stdev( 1.5 );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	m = stdev( NINF );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	m = stdev( PINF );
-	t.equal( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the standard deviation of a geometric distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/test/test.js
index 00846bdf65f7..6f48d9151f91 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains geometric distribution functions', function test( t ) {
 	var keys = objectKeys( geometric );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.js
index 45c45e37c827..d470f0463f9a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the variance of a geometric distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.native.js
index a63082654080..808effcb25de 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the variance of a geometric distribution', opts, fun
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.cdf.js
index d4102ca57123..3f8b48027495 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,28 +70,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function evaluates the cdf for `x` given positive `mu`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -140,7 +140,7 @@ tape( 'the function evaluates the cdf for `x` given negative `mu`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -167,7 +167,7 @@ tape( 'the function evaluates the cdf for `x` given large variance ( = large `be
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.factory.js
index bc1192e6d59c..d5aab25a5bc4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'the created function evaluates the cdf for `x` given positive `mu`', func
 		cdf = factory( mu[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -186,7 +186,7 @@ tape( 'the created function evaluates the cdf for `x` given negative `mu`', func
 		cdf = factory( mu[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -215,7 +215,7 @@ tape( 'the created function evaluates the cdf for `x` given large variance ( = l
 		cdf = factory( mu[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.native.js
index cc2c91b296d3..b7855152594b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,28 +79,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function evaluates the cdf for `x` given positive `mu`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -149,7 +149,7 @@ tape( 'the function evaluates the cdf for `x` given negative `mu`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -176,7 +176,7 @@ tape( 'the function evaluates the cdf for `x` given large variance ( = large `be
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.js
index 948cae3a2011..5db72c04ddaf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the differential entropy of a Gumbel distribution',
 		y = entropy( mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.native.js
index 70bb0caf2479..47dd05805527 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the differential entropy of a Gumbel distribution',
 		y = entropy( mu[i], beta[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.js
index 511af3cd2de4..b53a8f9fe057 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the excess kurtosis of a Gumbel distribution', funct
 	for ( i = 0; i < mu.length; i++ ) {
 		y = kurtosis( mu[i], beta[i] );
 		if ( expected[i] !== null ) {
-			t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.native.js
index 3deee938444f..434051e34747 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns the excess kurtosis of a Gumbel distribution', opts,
 	for ( i = 0; i < mu.length; i++ ) {
 		y = kurtosis( mu[i], beta[i] );
 		if ( expected[i] !== null) {
-			t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.factory.js
index f45f3c753462..af1381f9674c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	logcdf = factory( 0.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the created function evaluates the logcdf for `x` given positive `mu`', f
 		y = logcdf( x[i] );
 		if ( expected[ i ] ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -189,7 +189,7 @@ tape( 'the created function evaluates the logcdf for `x` given negative `mu`', f
 		y = logcdf( x[i] );
 		if ( expected[ i ] ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -220,7 +220,7 @@ tape( 'the created function evaluates the logcdf for `x` given large variance (
 		y = logcdf( x[i] );
 		if ( expected[ i ] ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.logcdf.js
index bdd543aad93a..61d73a5902cf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `1`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -70,28 +70,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function evaluates the log cdf for `x` given positive `mu`', function
 		y = logcdf( x[i], mu[i], beta[i] );
 		if ( expected[ i ] ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the log cdf for `x` given negative `mu`', function
 		y = logcdf( x[i], mu[i], beta[i] );
 		if ( expected[ i ] ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -172,7 +172,7 @@ tape( 'the function evaluates the log cdf for `x` given large variance ( = large
 		y = logcdf( x[i], mu[i], beta[i] );
 		if ( expected[ i ] ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.native.js
index 4551a9b96476..2e65ec9c9d41 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `1`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -79,28 +79,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'the function evaluates the log cdf for `x` given positive `mu`', opts, fu
 		y = logcdf( x[i], mu[i], beta[i] );
 		if ( expected[ i ] ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -152,7 +152,7 @@ tape( 'the function evaluates the log cdf for `x` given negative `mu`', opts, fu
 		y = logcdf( x[i], mu[i], beta[i] );
 		if ( expected[ i ] ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the function evaluates the log cdf for `x` given large variance ( = large
 		y = logcdf( x[i], mu[i], beta[i] );
 		if ( expected[ i ] ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.factory.js
index 1777086eb015..da5f176a2acc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, 0.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the created function evaluates the logpdf for `x` given positive `mu`', f
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -189,7 +189,7 @@ tape( 'the created function evaluates the logpdf for `x` given negative `mu`', f
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -220,7 +220,7 @@ tape( 'the created function evaluates the logpdf for `x` given large variance (
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.logpdf.js
index 8981c41b8a08..32e07cebc5cd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,28 +70,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function evaluates the logpdf for `x` given positive `mu`', function
 		y = logpdf( x[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the logpdf for `x` given negative `mu`', function
 		y = logpdf( x[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -172,7 +172,7 @@ tape( 'the function evaluates the logpdf for `x` given large variance ( = large
 		y = logpdf( x[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.native.js
index 8b76c2a5969e..6ed2ea5d389f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,28 +79,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'the function evaluates the logpdf for `x` given positive `mu`', opts, fun
 		y = logpdf( x[i], mu[i], beta[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -152,7 +152,7 @@ tape( 'the function evaluates the logpdf for `x` given negative `mu`', opts, fun
 		y = logpdf( x[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the function evaluates the logpdf for `x` given large variance ( = large
 		y = logpdf( x[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.js
index ed35e8eb1976..4fea9bb7bfa0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the mean of a Gumbel distribution', function test( t
 		y = mean( mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.native.js
index 51e7ad865858..ab7e53b94c8e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the mean of a Gumbel distribution', opts, function t
 		y = mean( mu[i], beta[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.js
index b6ab14d8707b..64f32769fbff 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = median( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the median of a Gumbel distribution', function test(
 		y = median( mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.native.js
index 5cbb84668b81..67a22cac885d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = median( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,22 +63,22 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'the function returns the median of a Gumbel distribution', opts, function
 		y = median( mu[i], beta[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.factory.js
index 6dc57a1e8a68..444395b9ee9a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.factory.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -49,23 +49,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 20, 0.5 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, 0.5 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 20, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the created function returns `NaN` for `x >= 1/beta`', function test( t )
 
 	for ( i = 1; i < 10; i++ ) {
 		y = mgf( i/2.0 );
-		t.equal( isnan( y ), true, 'returns NaN' );
+		t.strictEqual( isnan( y ), true, 'returns NaN' );
 	}
 	t.end();
 });
@@ -91,34 +91,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	mgf = factory( 0.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0, 0.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.mgf.js
index 9301ec3590fc..fae639549ff9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.mgf.js
@@ -39,11 +39,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 10, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 10, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -51,28 +51,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns `NaN` for `x >= 1/beta`', function test( t ) {
 
 	for ( i = 1; i < 10; i++ ) {
 		y = mgf( i/2.0, 0.0, 2.0 );
-		t.equal( isnan( y ), true, 'returns NaN' );
+		t.strictEqual( isnan( y ), true, 'returns NaN' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.native.js
index 4aad1e803b60..435508277263 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.native.js
@@ -48,11 +48,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 10, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 10, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,28 +60,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'the function returns `NaN` for `x >= 1/beta`', opts, function test( t ) {
 
 	for ( i = 1; i < 10; i++ ) {
 		y = mgf( i/2.0, 0.0, 2.0 );
-		t.equal( isnan( y ), true, 'returns NaN' );
+		t.strictEqual( isnan( y ), true, 'returns NaN' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.js
index a0708c4b490c..087bcc9d6c53 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the mode of a Gumbel distribution', function test( t
 	for ( i = 0; i < mu.length; i++ ) {
 		y = mode( mu[i], beta[i] );
 		if ( expected[i] !== null ) {
-			t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.native.js
index c48560abe685..02010dbd2cdd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns the mode of a Gumbel distribution', opts, function t
 	for ( i = 0; i < mu.length; i++ ) {
 		y = mode( mu[i], beta[i] );
 		if ( expected[i] !== null) {
-			t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.factory.js
index 03d8889d721e..39f0113cd77b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the created function evaluates the pdf for `x` given positive `mu`', func
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -189,7 +189,7 @@ tape( 'the created function evaluates the pdf for `x` given negative `mu`', func
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -220,7 +220,7 @@ tape( 'the created function evaluates the pdf for `x` given large variance ( = l
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.native.js
index 72a9706ac9ff..39becd8d9ac7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,28 +79,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'the function evaluates the pdf for `x` given positive `mu`', opts, functi
 		y = pdf( x[i], mu[i], beta[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -152,7 +152,7 @@ tape( 'the function evaluates the pdf for `x` given negative `mu`', opts, functi
 		y = pdf( x[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the function evaluates the pdf for `x` given large variance ( = large `be
 		y = pdf( x[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.pdf.js
index 6e4571517c2c..1d18b787e448 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,28 +70,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function evaluates the pdf for `x` given positive `mu`', function tes
 		y = pdf( x[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the pdf for `x` given negative `mu`', function tes
 		y = pdf( x[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -172,7 +172,7 @@ tape( 'the function evaluates the pdf for `x` given large variance ( = large `be
 		y = pdf( x[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.factory.js
index 16434de78605..844b07ce6cd4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,34 +98,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, 0.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -150,7 +150,7 @@ tape( 'the created function evaluates the quantile function at `p` given positiv
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the created function evaluates the quantile function at `p` given negativ
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -212,7 +212,7 @@ tape( 'the created function evaluates the quantile function at `p` given large v
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.native.js
index 2c4b16b76260..c36763d06835 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `beta`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -75,28 +75,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function evaluates the quantile for `x` given positive mean `mu`', op
 		y = quantile( p[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 50.0 * EPS * abs( expected[ i ] );
@@ -148,7 +148,7 @@ tape( 'the function evaluates the quantile for `x` given negative mean `mu`', op
 		y = quantile( p[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 50.0 * EPS * abs( expected[ i ] );
@@ -177,7 +177,7 @@ tape( 'the function evaluates the quantile function at `p` given large variance
 		y = quantile( p[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.quantile.js
index 74e487f644e0..2c065064c10a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `beta`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,28 +66,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function evaluates the quantile function at `p` given positive `mu`',
 		y = quantile( p[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -139,7 +139,7 @@ tape( 'the function evaluates the quantile function at `p` given negative `mu`',
 		y = quantile( p[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -168,7 +168,7 @@ tape( 'the function evaluates the quantile function at `p` given large variance
 		y = quantile( p[i], mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.js
index 9f607f939d71..5d0213917431 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.js
@@ -38,9 +38,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -48,25 +48,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns `~1.14` as the skewness of a Gumbel distribution ',
 		mu = ( randu()*10.0 );
 		beta = ( randu()*10.0 ) + 1.0;
 		v = skewness( mu, beta );
-		t.equal( v, 1.1395470994046488, 'returns ~1.14' );
+		t.strictEqual( v, 1.1395470994046488, 'returns ~1.14' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.native.js
index 1e7314d27098..58084823d2b2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.native.js
@@ -47,9 +47,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -57,25 +57,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns `~1.14` as the skewness of a Gumbel distribution ',
 		a = ( randu()*10.0 );
 		b = ( randu()*10.0 ) + a;
 		v = skewness( a, b );
-		t.equal( v, 1.1395470994046488, 'returns ~1.14' );
+		t.strictEqual( v, 1.1395470994046488, 'returns ~1.14' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.js
index 615b1df8e1cd..7d33f9fb15ae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the standard deviation of a Gumbel distribution', fu
 		y = stdev( mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.native.js
index 2b16989dbf09..6c337f135592 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the standard deviation of a Gumbel distribution', op
 		y = stdev( mu[i], beta[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/test/test.js
index e1ea5556255f..6dd0f7f498c4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Gumbel distribution functions', function test( t ) {
 	var keys = objectKeys( gumbel );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.js
index 13bb6e612444..c20d7457a28b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the variance of a Gumbel distribution', function tes
 		y = variance( mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.native.js
index 5bfbd2be31f5..b37b0563c2f3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the variance of a Gumbel distribution', opts, functi
 		y = variance( mu[i], beta[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.cdf.js
index b0fecade544b..fd37885c23a7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.cdf.js
@@ -44,41 +44,41 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 10, 10, 5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 10, 5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 10, NaN, 5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 10, 10, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a `x` greater equal to `min( n, K )`, the function returns `1` (provided all parameters are valid)', function test( t ) {
 	var y = cdf( PINF, 20, 20, 10 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 11, 20, 20, 10 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 10, 20, 20, 10 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 100, 20, 20, 10 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
 
 tape( 'if provided a number for `x` smaller than `max( 0, n + K - N )`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 20, 20, 10 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -1.0, 20, 20, 10 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 9.0, 20, 10, 20 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -87,19 +87,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = cdf( 2.0, 30.5, 20, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, -2, 20, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, -1, 20, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 20.5, 20, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, PINF, 20, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -108,19 +108,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = cdf( 2.0, 20, 3.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 20, 2.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 20, PINF, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -129,19 +129,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = cdf( 2.0, 40, 20, 3.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 40, 20, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 40, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -165,7 +165,7 @@ tape( 'the function evaluates the cdf for `x`', function test( t ) {
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.factory.js
index 5aaa3afdba9a..8ec04df4b370 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 20, 20, 10 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,35 +54,35 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 40, 20, 10 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 20, 10 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 40, NaN, 10 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 30, 20, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN, 10 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 20, NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 20, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,23 +93,23 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	cdf = factory( 40, 20, 10 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 200.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 20.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 10.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	cdf = factory( 25, 5, 10 );
 	y = cdf( 5.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 10.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -120,19 +120,19 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	cdf = factory( 30, 20, 15 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -10.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -4.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 4.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -144,22 +144,22 @@ tape( 'if provided an `N` which is not a nonnegative integer, the created functi
 	cdf = factory( 40.5, 20, 10 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -10, 20, 10 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, 20, 10 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, 20, 10 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -171,22 +171,22 @@ tape( 'if provided a `K` which is not a nonnegative integer, the created functio
 	cdf = factory( 40, 20.5, 10 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 40, -10, 10 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 40, PINF, 10 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 40, NINF, 10 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -198,22 +198,22 @@ tape( 'if provided an `n` which is not a nonnegative integer, the created functi
 	cdf = factory( 40, 20, 10.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 40, 20, -10 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 40, 10, PINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 40, 10, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -239,7 +239,7 @@ tape( 'the created function evaluates the cdf for `x`', function test( t ) {
 		cdf = factory( N[i], K[i], n[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2150.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/kurtosis/test/test.js
index 23e94e06a180..8d98e3d68d84 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/kurtosis/test/test.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 10, 4 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 20, NaN, 4 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 20, 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -58,19 +58,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = kurtosis( 10.5, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( -2, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( -1, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 20.5, 10, 5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( PINF, 10, 5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,19 +79,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = kurtosis( 20, 3.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 20, 2.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 20, PINF, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -100,19 +100,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = kurtosis( 40, 20, 3.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 40, 20, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 40, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'the function returns the excess kurtosis of a hypergeometric distribution
 	for ( i = 0; i < n.length; i++ ) {
 		y = kurtosis( N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.factory.js
index c22901582706..eae97b16ef54 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.factory.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 20, 20, 10 );
-	t.equal( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -61,35 +61,35 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpmf = factory( 40, 20, 10 );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, 20, 10 );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 40, NaN, 10 );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 40, 10, NaN );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, NaN, 10 );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 40, NaN, NaN );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, 20, NaN );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, NaN, NaN );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -100,13 +100,13 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	logpmf = factory( 40, 20, 10 );
 	y = logpmf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 12.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 11.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -118,10 +118,10 @@ tape( 'if provided valid parameters, the function returns a function which retur
 	logpmf = factory( 40, 30, 15 );
 
 	y = logpmf( 1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 4.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -133,22 +133,22 @@ tape( 'if provided an `N` which is not a nonnegative integer, the created functi
 	logpmf = factory( 20.5, 20, 10 );
 
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( -10, 20, 10 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( PINF, 20, 10 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NINF, 20, 10 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -160,22 +160,22 @@ tape( 'if provided a `K` which is not a nonnegative integer, the created functio
 	logpmf = factory( 40, 20.5, 10 );
 
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 40, -10, 10 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 40, PINF, 10 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 40, NINF, 10 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -187,22 +187,22 @@ tape( 'if provided an `n` which is not a nonnegative integer, the created functi
 	logpmf = factory( 40, 20, 10.5 );
 
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 40, 20, -10 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 30, 20, PINF );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 30, 20, NINF );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -228,7 +228,7 @@ tape( 'the created function evaluates the logpmf for `x`', function test( t ) {
 		logpmf = factory( N[i], K[i], n[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3600.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.js
index 373f96b89f76..bb8d4629a397 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpmf` functions', function test( t ) {
-	t.equal( typeof logpmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.logpmf.js
index 25577ed35acc..75b5a97de5c2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.logpmf.js
@@ -51,38 +51,38 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpmf( NaN, 10, 10, 5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, NaN, 10, 5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, 10, NaN, 5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, 10, 10, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided an integer `x` greater than `min( n, K )`, the function returns `-Infinity` (provided all parameters are valid)', function test( t ) {
 	var y = logpmf( PINF, 20, 20, 10 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 11, 20, 20, 10 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 100, 20, 20, 10 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided an integer for `x` smaller than `max( 0, n + K - N )`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( NINF, 40, 20, 10 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.0, 40, 20, 10 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -2.0, 30, 20, 20 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -91,19 +91,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = logpmf( 2.0, 30.5, 20, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, -2, 20, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, -1, 20, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, 20.5, 20, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, PINF, 20, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -112,19 +112,19 @@ tape( 'if provided a `K` which is not a nonnegative integer, the function return
 	var y;
 
 	y = logpmf( 2.0, 20, 3.5, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, 20, 2.5, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, 20, PINF, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -133,19 +133,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = logpmf( 2.0, 40, 20, 3.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, 40, 20, 2.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, 40, 20, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -169,7 +169,7 @@ tape( 'the function evaluates the logpmf for `x`', function test( t ) {
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3600.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.native.js
index 5167ae9fe1c1..097d2f9e11e6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.native.js
@@ -59,26 +59,26 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for input value `x`, the function returns `NaN`', opts, function test( t ) {
 	var y = logpmf( NaN, 10, 9, 5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided an integer `x` greater than `min( n, K )`, the function returns `-Infinity` (provided all parameters are valid)', opts, function test( t ) {
 	var y = logpmf( 11, 20, 20, 10 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 100, 20, 20, 10 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided an integer for `x` smaller than `max( 0, n + K - N )`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( -1.0, 40, 20, 10 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -2.0, 30, 20, 20 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -87,10 +87,10 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = logpmf( 2.0, -2, 20, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, -1, 20, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -99,10 +99,10 @@ tape( 'if provided a `K` which is not a nonnegative integer, the function return
 	var y;
 
 	y = logpmf( 2.0, 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -111,10 +111,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = logpmf( 2.0, 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the function evaluates the logpmf for `x`', opts, function test( t ) {
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3600.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.js
index b58adb62477d..e4497b8dd060 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 10, 4 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 20, NaN, 4 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 20, 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -58,19 +58,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = mean( 10.5, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( -2, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( -1, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 20.5, 10, 5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( PINF, 10, 5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,19 +79,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mean( 20, 3.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 20, 2.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 20, PINF, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -100,19 +100,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mean( 40, 20, 3.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 40, 20, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 40, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'the function returns the mean of a hypergeometric distribution', function
 	for ( i = 0; i < n.length; i++ ) {
 		y = mean( N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.native.js
index 6d0b34417178..59252e161c8e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = mean( -2, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( -1, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mean( 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mean( 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the mean of a hypergeometric distribution', opts, fu
 	for ( i = 0; i < n.length; i++ ) {
 		y = mean( N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.js
index 03b27960a273..d7df77cce7e5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 10, 4 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 20, NaN, 4 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 20, 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -58,19 +58,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = mode( 10.5, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( -2, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( -1, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 20.5, 10, 5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( PINF, 10, 5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,19 +79,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mode( 20, 3.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 20, 2.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 20, PINF, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -100,19 +100,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mode( 40, 20, 3.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 40, 20, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 40, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'the function returns the mode of a hypergeometric distribution', function
 	for ( i = 0; i < n.length; i++ ) {
 		y = mode( N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.native.js
index 968b738f742f..8ed32d875b9f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = mode( -2, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( -1, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mode( 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mode( 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the mode of a hypergeometric distribution', opts, fu
 	for ( i = 0; i < n.length; i++ ) {
 		y = mode( N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.factory.js
index 9d4ee943015a..99590bcc39c7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 20, 20, 10 );
-	t.equal( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,35 +54,35 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 40, 20, 10 );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, 20, 10 );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 40, NaN, 10 );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 40, 10, NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, NaN, 10 );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 40, NaN, NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, 20, NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, NaN, NaN );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,13 +93,13 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	pmf = factory( 40, 20, 10 );
 	y = pmf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 12.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 11.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -111,10 +111,10 @@ tape( 'if provided valid parameters, the function returns a function which retur
 	pmf = factory( 40, 30, 15 );
 
 	y = pmf( 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 4.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -126,22 +126,22 @@ tape( 'if provided an `N` which is not a nonnegative integer, the created functi
 	pmf = factory( 20.5, 20, 10 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( -10, 20, 10 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( PINF, 20, 10 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NINF, 20, 10 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -153,22 +153,22 @@ tape( 'if provided a `K` which is not a nonnegative integer, the created functio
 	pmf = factory( 40, 20.5, 10 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 40, -10, 10 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 40, PINF, 10 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 40, NINF, 10 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -180,22 +180,22 @@ tape( 'if provided an `n` which is not a nonnegative integer, the created functi
 	pmf = factory( 40, 20, 10.5 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 40, 20, -10 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 30, 20, PINF );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 30, 20, NINF );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,7 +221,7 @@ tape( 'the created function evaluates the pmf for `x`', function test( t ) {
 		pmf = factory( N[i], K[i], n[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1040.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.js
index 686bb53fea47..33c536be2daf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pmf` functions', function test( t ) {
-	t.equal( typeof pmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.native.js
index f3468885040e..f4eff717ff94 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.native.js
@@ -51,26 +51,26 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for input value `x`, the function returns `NaN`', opts, function test( t ) {
 	var y = pmf( NaN, 10, 10, 5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided an integer `x` greater than `min( n, K )`, the function returns `0` (provided all parameters are valid)', opts, function test( t ) {
 	var y = pmf( 11.0, 20, 20, 10 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 100.0, 20, 20, 10 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided an integer for `x` smaller than `max( 0, n + K - N )`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( -1.0, 40, 20, 10 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -2.0, 30, 20, 20 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -79,10 +79,10 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = pmf( 2.0, -20, 3, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, -10, 3, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -91,10 +91,10 @@ tape( 'if provided a `K` which is not a nonnegative integer, the function return
 	var y;
 
 	y = pmf( 2.0, 20, -3, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, 20, -10, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -103,10 +103,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = pmf( 2.0, 20, 3, -10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, 20, 3, -20 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function evaluates the pmf for `x`', opts, function test( t ) {
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1040.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.pmf.js
index 486931be3f1f..cb752ab5e5f5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.pmf.js
@@ -44,38 +44,38 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( NaN, 10, 10, 5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, NaN, 10, 5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, 10, NaN, 5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, 10, 10, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided an integer `x` greater than `min( n, K )`, the function returns `0` (provided all parameters are valid)', function test( t ) {
 	var y = pmf( PINF, 20, 20, 10 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 11, 20, 20, 10 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 100, 20, 20, 10 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided an integer for `x` smaller than `max( 0, n + K - N )`, the function returns `0`', function test( t ) {
 	var y = pmf( NINF, 40, 20, 10 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0, 40, 20, 10 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -2.0, 30, 20, 20 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -84,19 +84,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = pmf( 2.0, 30.5, 20, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, -2, 20, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, -1, 20, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, 20.5, 20, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, PINF, 20, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -105,19 +105,19 @@ tape( 'if provided a `K` which is not a nonnegative integer, the function return
 	var y;
 
 	y = pmf( 2.0, 20, 3.5, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, 20, 2.5, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, 20, PINF, 10 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -126,19 +126,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = pmf( 2.0, 40, 20, 3.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, 40, 20, 2.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, 40, 20, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -162,7 +162,7 @@ tape( 'the function evaluates the pmf for `x`', function test( t ) {
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1040.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.factory.js
index b99c35284b3d..6616ec6a50ad 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.factory.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 4, 4, 2 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -52,39 +52,39 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 8, 4, 2 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 4, 2 );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 8, NaN, 2 );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 8, 4, NaN );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 8, NaN, NaN );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 4, NaN );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN, 2 );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN, NaN );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,10 +95,10 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	quantile = factory( 6, 4, 2 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -110,23 +110,23 @@ tape( 'if provided an `N` which is not a nonnegative integer, the created functi
 	quantile = factory( 20.5, 4, 2 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( -1.0, 4, 2 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, 4, 2 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, 4, 2 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,21 +137,21 @@ tape( 'if provided a `K` which is not a nonnegative integer, the created functio
 
 	quantile = factory( 40, 20.5, 2 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 40, -1.0, 2 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 40, NINF, 2 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 40, PINF, 2 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -162,21 +162,21 @@ tape( 'if provided an `n` which is not a nonnegative integer, the created functi
 
 	quantile = factory( 20, 10, 2.5 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 4, 2, -1.0 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 4, 2, NINF );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 4, 2, PINF );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -187,11 +187,11 @@ tape( 'given valid parameters, the created function returns `max( 0, n + K - N )
 
 	quantile = factory( 20, 10, 5 );
 	y = quantile( 0.0 );
-	t.equal( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns 0' );
 
 	quantile = factory( 20, 10, 15 );
 	y = quantile( 0.0 );
-	t.equal( y, 5, 'returns 5' );
+	t.strictEqual( y, 5, 'returns 5' );
 	t.end();
 });
 
@@ -201,15 +201,15 @@ tape( 'given valid parameters, the created function returns `min( n, K )` as the
 
 	quantile = factory( 30, 20, 15 );
 	y = quantile( 1.0 );
-	t.equal( y, 15, 'returns 15' );
+	t.strictEqual( y, 15, 'returns 15' );
 
 	quantile = factory( 30, 20, 25 );
 	y = quantile( 1.0 );
-	t.equal( y, 20, 'returns 20' );
+	t.strictEqual( y, 20, 'returns 20' );
 
 	quantile = factory( 30, 20, 5 );
 	y = quantile( 1.0 );
-	t.equal( y, 5, 'returns 5' );
+	t.strictEqual( y, 5, 'returns 5' );
 
 	t.end();
 });
@@ -232,7 +232,7 @@ tape( 'the created function evaluates the quantile for `p` given valid parameter
 	for ( i = 0; i < p.length; i++ ) {
 		quantile = factory( N[i], K[i], n[i] );
 		y = quantile( p[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.quantile.js
index b387f540cb87..e113899a1621 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.quantile.js
@@ -42,21 +42,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 20, 20, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, NaN, 10, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, 20, NaN, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, 20, 20, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and valid parameters, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 20, 10, 10 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 20, 10, 10 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -64,22 +64,22 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = quantile( 0.5, 10.5, 10, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 10.5, 10, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, PINF, 10, 5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, 10, 5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -2.0, 10, 5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -0.5, 10, 5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,22 +88,22 @@ tape( 'if provided a `K` which is not a nonnegative integer, the function return
 	var y;
 
 	y = quantile( 0.5, 20, 10.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 20, 1.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 20, PINF, 5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 20, NINF, 5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 20, -2.0, 5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 20, -0.5, 5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -112,44 +112,44 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = quantile( 0.5, 20, 10, 10.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 20, 10, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 20, 10, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 20, 10, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 20, 5, -2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 20, 5, -0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'given valid parameters, the function returns `max( 0, n + K - N )` as the 0% quantile', function test( t ) {
 	var y = quantile( 0.0, 20, 10, 5 );
-	t.equal( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns 0' );
 
 	y = quantile( 0.0, 20, 10, 15 );
-	t.equal( y, 5, 'returns 5' );
+	t.strictEqual( y, 5, 'returns 5' );
 	t.end();
 });
 
 tape( 'given valid parameters, the function returns `min( n, K )` as the 100% quantile', function test( t ) {
 	var y = quantile( 1.0, 30, 20, 15 );
-	t.equal( y, 15, 'returns 15' );
+	t.strictEqual( y, 15, 'returns 15' );
 
 	y = quantile( 1.0, 30, 20, 25 );
-	t.equal( y, 20, 'returns 20' );
+	t.strictEqual( y, 20, 'returns 20' );
 
 	y = quantile( 1.0, 30, 20, 5 );
-	t.equal( y, 5, 'returns 5' );
+	t.strictEqual( y, 5, 'returns 5' );
 
 	t.end();
 });
@@ -170,7 +170,7 @@ tape( 'the function evaluates the quantile for `p` given valid parameters', func
 	n = data.n;
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], N[i], K[i], n[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.js
index 01349592ca89..487180832f1c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 10, 4 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 20, NaN, 4 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 20, 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -58,19 +58,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = skewness( 10.5, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( -2, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( -1, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 20.5, 10, 5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( PINF, 10, 5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,19 +79,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = skewness( 20, 3.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 20, 2.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 20, PINF, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -100,19 +100,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = skewness( 40, 20, 3.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 40, 20, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 40, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'the function returns the skewness of a hypergeometric distribution', func
 	for ( i = 0; i < n.length; i++ ) {
 		y = skewness( N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.native.js
index a7e44cfd484d..67a560d4ffea 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = skewness( -2, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( -1, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = skewness( 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = skewness( 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the skewness of a hypergeometric distribution', opts
 	for ( i = 0; i < n.length; i++ ) {
 		y = skewness( N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.js
index 1b191931269f..5c1249d9b172 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 10, 4 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 20, NaN, 4 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 20, 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -58,19 +58,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = stdev( 10.5, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( -2, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( -1, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 20.5, 10, 5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( PINF, 10, 5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,19 +79,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = stdev( 20, 3.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 20, 2.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 20, PINF, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -100,19 +100,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = stdev( 40, 20, 3.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 40, 20, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 40, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'the function returns the standard deviation of a hypergeometric distribut
 	for ( i = 0; i < n.length; i++ ) {
 		y = stdev( N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.native.js
index 8d25286e7138..6e2a029d87b8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = stdev( -2, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( -1, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = stdev( 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = stdev( 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the standard deviation of a hypergeometric distribut
 	for ( i = 0; i < n.length; i++ ) {
 		y = stdev( N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/test/test.js
index 7562dc5d1183..92f05931c0ea 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains hypergeometric distribution functions', function test( t ) {
 	var keys = objectKeys( hypergeometric );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.js
index 6b868fe2d937..94f46fb7e4c7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 10, 4 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 20, NaN, 4 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 20, 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -58,19 +58,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = variance( 10.5, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( -2, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( -1, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 20.5, 10, 5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( PINF, 10, 5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,19 +79,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = variance( 20, 3.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 20, 2.5, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 20, PINF, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -100,19 +100,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = variance( 40, 20, 3.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 40, 20, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 40, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'the function returns the variance of a hypergeometric distribution', func
 	for ( i = 0; i < n.length; i++ ) {
 		y = variance( N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 18.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.native.js
index e5f36690f509..5ea34b6e2bad 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = variance( -2, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( -1, 4, 2 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = variance( 20, -2, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 20, -1, 10 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = variance( 40, 20, -2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 40, 20, -1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the variance of a hypergeometric distribution', opts
 	for ( i = 0; i < n.length; i++ ) {
 		y = variance( N[i], K[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'N: '+N[i]+', K: '+K[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 18.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.cdf.js
index 9bcb54fd0886..9f08c9e20a53 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,16 +88,16 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha` and `beta`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 950.0 * EPS * abs( expected[ i ] );
@@ -146,7 +146,7 @@ tape( 'the function evaluates the cdf for `x` given large shape parameter `alpha
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 400.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the function evaluates the cdf for `x` given large rate parameter `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 350.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.factory.js
index d2b339662efc..a920478261ce 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `beta`, the created function always returns `NaN`'
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,26 +137,26 @@ tape( 'if provided a negative `alpha`, the created function always returns `NaN`
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -180,7 +180,7 @@ tape( 'the created function evaluates the cdf for `x` given large `alpha` and `b
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 950.0 * EPS * abs( expected[ i ] );
@@ -209,7 +209,7 @@ tape( 'the created function evaluates the cdf for `x` given large shape paramete
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 400.0 * EPS * abs( expected[ i ] );
@@ -238,7 +238,7 @@ tape( 'the created function evaluates the cdf for `x` given large rate parameter
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 350.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.native.js
index a4c3e2aee78e..8552ea796b4d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.native.js
@@ -48,7 +48,7 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof cdf, 'function', 'main export is a function' );
+	t.strictEqual( typeof cdf, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -56,26 +56,26 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = cdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -83,16 +83,16 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -101,16 +101,16 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1e-11 * abs( expected[ i ] );
@@ -159,7 +159,7 @@ tape( 'the function evaluates the cdf for `x` given large `beta`', opts, functio
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1e-11 * abs( expected[ i ] );
@@ -186,7 +186,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha` and `beta`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1e-11 * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.js
index 865ccf3b2a0f..aec5d008b42d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.js
@@ -43,10 +43,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -55,19 +55,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,19 +76,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -108,7 +108,7 @@ tape( 'the function returns the differential entropy of an inverse gamma distrib
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1e-10 * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.native.js
index 7c695d56d959..5fc172d5ca4b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.native.js
@@ -52,10 +52,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -64,19 +64,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,19 +85,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -117,7 +117,7 @@ tape( 'the function returns the differential entropy of an inverse gamma distrib
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1e-10 * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.js
index 21bcba9b6644..7c0e10d4cbaa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided `alpha <= 4`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( 4.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the excess kurtosis of an inverse gamma distribution
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.native.js
index 336d8eaeb69f..b37044e9238f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,28 +65,28 @@ tape( 'if provided `alpha <= 4`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = kurtosis( 4.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,19 +95,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function returns the excess kurtosis of an inverse gamma distribution
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.factory.js
index 2a2f31d3c1d1..ed39e3495ec5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,26 +137,26 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 	logpdf = factory( -1.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -180,7 +180,7 @@ tape( 'the created function evaluates the logpdf for `x` given large `alpha` and
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
@@ -209,7 +209,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large shape par
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
@@ -238,7 +238,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large rate para
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.logpdf.js
index d0b42788bf18..576fac256a70 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `alpha` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `alpha` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha` and `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the logpdf for `x` given large shape parameter `al
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the logpdf for `x` given large rate parameter `bet
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.nativs.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.nativs.js
index c3900a26b9ba..e3f004f89405 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.nativs.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.nativs.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `alpha` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `alpha` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,22 +103,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -140,7 +140,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha` and `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -167,7 +167,7 @@ tape( 'the function evaluates the logpdf for `x` given large shape parameter `al
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -194,7 +194,7 @@ tape( 'the function evaluates the logpdf for `x` given large rate parameter `bet
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.js
index 58479adbdd02..c33e82391580 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the mean of an inverse gamma distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.native.js
index 4932416697eb..b96a6902c142 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the mean of an inverse gamma distribution', opts, fu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.js
index 3fb384d646f8..6daa24914c0d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the mode of an inverse gamma distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.native.js
index f47c8bf1b644..e9b36a54802f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the mode of an inverse gamma distribution', opts, fu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.factory.js
index 0b5b7aae0a9f..42898bde1aa7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,26 +137,26 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 	pdf = factory( -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -180,7 +180,7 @@ tape( 'the created function evaluates the pdf for `x` given large `alpha` and `b
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
@@ -209,7 +209,7 @@ tape( 'the created function evaluates the pdf for `x` given a large shape parame
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
@@ -238,7 +238,7 @@ tape( 'the created function evaluates the pdf for `x` given a large rate paramet
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.native.js
index 6aeefbf2052c..423ccc02e31f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,22 +103,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -140,7 +140,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha` and `beta`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 130.0 * EPS * abs( expected[ i ] );
@@ -167,7 +167,7 @@ tape( 'the function evaluates the pdf for `x` given large shape parameter `alpha
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 70.0 * EPS * abs( expected[ i ] );
@@ -194,7 +194,7 @@ tape( 'the function evaluates the pdf for `x` given large rate parameter `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 75.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.pdf.js
index 6394d18f2f37..ea37f41731b9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha` and `beta`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the pdf for `x` given large shape parameter `alpha
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the pdf for `x` given large rate parameter `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.factory.js
index 8f0ae4b4e504..02ba12e5541b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,26 +98,26 @@ tape( 'if provided a negative `beta`, the created function always returns `NaN`'
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -129,26 +129,26 @@ tape( 'if provided a negative `alpha`, the created function always returns `NaN`
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -172,7 +172,7 @@ tape( 'the created function evaluates the quantile for `p` given large `alpha` a
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 200.0 * EPS * abs( expected[ i ] );
@@ -201,7 +201,7 @@ tape( 'the created function evaluates the quantile for `p` given large shape par
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 100.0 * EPS * abs( expected[ i ] );
@@ -230,7 +230,7 @@ tape( 'the created function evaluates the quantile for `p` given large rate para
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.quantile.js
index f574b55b570e..f2c9721589ea 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `alpha` and `beta`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,22 +66,22 @@ tape( 'if provided a negative `alpha`, the function returns `NaN`', function tes
 	var y;
 
 	y = quantile( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -90,22 +90,22 @@ tape( 'if provided a negative `beta`, the function returns `NaN`', function test
 	var y;
 
 	y = quantile( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function evaluates the quantile for `x` given large parameters `alpha
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 200.0 * EPS * abs( expected[ i ] );
@@ -154,7 +154,7 @@ tape( 'the function evaluates the quantile for `x` given large shape parameter `
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 100.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the function evaluates the quantile for `x` given large rate parameter `b
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha:'+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.js
index f2df1772776e..7e5a780c7060 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the skewness of a gamma distribution', function test
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.native.js
index 3b6ee29e945a..22c34c43184c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the skewness of a gamma distribution', opts, functio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.js
index e8654f8c57ba..abcc7f5ec973 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,25 +56,25 @@ tape( 'if provided `alpha <= 2`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -115,7 +115,7 @@ tape( 'the function returns the standard deviation of an inverse gamma distribut
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.native.js
index 91a230a60fbf..88719f87fd19 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,25 +65,25 @@ tape( 'if provided `alpha <= 2`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = stdev( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -92,19 +92,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns the standard deviation of an inverse gamma distribut
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/test/test.js
index a99676dc6080..4be620cfd9e6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains inverse-gamma distribution functions', function test( t ) {
 	var keys = objectKeys( invgamma );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.js
index 82fb1c247f56..c5a41a87eff1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,25 +56,25 @@ tape( 'if provided `alpha <= 2`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -115,7 +115,7 @@ tape( 'the function returns the variance of an inverse gamma distribution', func
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.native.js
index 2784ae64d183..3bfc6a15d585 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,25 +65,25 @@ tape( 'if provided `alpha <= 2`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = variance( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -92,19 +92,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns the variance of an inverse gamma distribution', opts
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.cdf.js
index 74ed6ca906a2..4a935779a705 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.cdf.js
@@ -40,42 +40,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 100.0, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 10.0, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 1.0, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -100.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -1.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 0.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -84,25 +84,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -111,25 +111,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function evaluates the cdf of a Kumaraswamy\'s double bounded distrib
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = cdf( x, a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.factory.js
index eb05831864e7..83fb824e52a3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.factory.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -50,23 +50,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,16 +77,16 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 100.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 10.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -97,19 +97,19 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -100.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -10.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -121,31 +121,31 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	cdf = factory( 1.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -157,31 +157,31 @@ tape( 'if provided a nonpositive `a`, the created function always returns `NaN`'
 	cdf = factory( 0.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -201,7 +201,7 @@ tape( 'the returned function evaluates the cdf of a Kumaraswamy\'s double bounde
 	for ( i = 0; i < 100; i++ ) {
 		x = randu();
 		y = cdf( x, a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.native.js
index d08810c4fdd3..e44eda645c58 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.native.js
@@ -49,42 +49,42 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 100.0, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 10.0, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = cdf( 1.0, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -100.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -1.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 0.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -93,25 +93,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -120,25 +120,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function evaluates the cdf of a Kumaraswamy\'s double bounded distrib
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = cdf( x, a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.js
index 7beedae6b917..e83eee35639b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.js
@@ -40,10 +40,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = kurtosis( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function returns the excess kurtosis of a Kumaraswamy\'s double bound
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = kurtosis( a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.native.js
index 11acd2a2b817..52237c5ee0fe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.native.js
@@ -49,10 +49,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = kurtosis( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,25 +88,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function returns the excess kurtosis of a Kumaraswamy\'s double bound
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = kurtosis( a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.factory.js
index a3634171e378..41565d56cf7d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.factory.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -50,23 +50,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,16 +77,16 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = logcdf( 100.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = logcdf( 10.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = logcdf( 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -97,19 +97,19 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( -100.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( -10.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( -1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 0.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -121,31 +121,31 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	logcdf = factory( 1.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -157,31 +157,31 @@ tape( 'if provided a nonpositive `a`, the created function always returns `NaN`'
 	logcdf = factory( 0.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( -1.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, 1.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, PINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NaN );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -201,7 +201,7 @@ tape( 'the returned function evaluates the logcdf of a Kumaraswamy\'s double bou
 	for ( i = 0; i < 100; i++ ) {
 		x = randu();
 		y = logcdf( x, a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.logcdf.js
index eda0d24dd871..0d3893061ef9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.logcdf.js
@@ -40,42 +40,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `1`', function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = logcdf( 100.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = logcdf( 10.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = logcdf( 1.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( -100.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( -1.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 0.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -84,25 +84,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -111,25 +111,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function evaluates the logcdf of a Kumaraswamy\'s double bounded dist
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = logcdf( x, a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.native.js
index b7efac9a3a2f..37e0abbce5d4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.native.js
@@ -49,42 +49,42 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `1`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = logcdf( 100.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = logcdf( 10.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = logcdf( 1.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( -100.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( -1.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 0.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -93,25 +93,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -120,25 +120,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -156,7 +156,7 @@ tape( 'the function evaluates the logcdf of a Kumaraswamy\'s double bounded dist
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = logcdf( x, a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.factory.js
index c8a71cd5b2f4..b023e6dd7d47 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.factory.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -52,23 +52,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,16 +79,16 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 100.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 10.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -99,19 +99,19 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -100.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -10.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 0.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -123,31 +123,31 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	logpdf = factory( 1.0, 0.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -159,31 +159,31 @@ tape( 'if provided a nonpositive `a`, the created function always returns `NaN`'
 	logpdf = factory( 0.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( -1.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -211,7 +211,7 @@ tape( 'the returned function evaluates the logpdf of a Kumaraswamy\'s double bou
 		y = logpdf( x );
 		expected = ln( pdf( x, a, b ) );
 		if ( y === expected ) {
-			t.equal( y, expected, 'x: '+x+', a:'+a+', b: '+b+', y: '+y+', expected: '+expected );
+			t.strictEqual( y, expected, 'x: '+x+', a:'+a+', b: '+b+', y: '+y+', expected: '+expected );
 		} else {
 			delta = abs( y - expected );
 			tol = 1000.0 * EPS * abs( expected );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.logpdf.js
index 14dfab811b9f..090b99f27340 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.logpdf.js
@@ -42,42 +42,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 100.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 10.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 1.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -100.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -1.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 0.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -86,25 +86,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = logpdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,25 +113,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'the function evaluates the logpdf of a Kumaraswamy\'s double bounded dist
 		y = logpdf( x, a, b );
 		expected = ln( pdf( x, a, b ) );
 		if ( y === expected ) {
-			t.equal( y, expected, 'x: '+x+', a:'+a+', b: '+b+', y: '+y+', expected: '+expected );
+			t.strictEqual( y, expected, 'x: '+x+', a:'+a+', b: '+b+', y: '+y+', expected: '+expected );
 		} else {
 			delta = abs( y - expected );
 			tol = 1000.0 * EPS * abs( expected );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.native.js
index 8a96b8d4921c..8f3c6b47546c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.native.js
@@ -51,42 +51,42 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 100.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 10.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 1.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -100.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -1.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 0.0, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -95,25 +95,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logpdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -122,25 +122,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -166,7 +166,7 @@ tape( 'the function evaluates the logpdf of a Kumaraswamy\'s double bounded dist
 		y = logpdf( x, a, b );
 		expected = ln( pdf( x, a, b ) );
 		if ( y === expected ) {
-			t.equal( y, expected, 'x: '+x+', a:'+a+', b: '+b+', y: '+y+', expected: '+expected );
+			t.strictEqual( y, expected, 'x: '+x+', a:'+a+', b: '+b+', y: '+y+', expected: '+expected );
 		} else {
 			delta = abs( y - expected );
 			tol = 1000.0 * EPS * abs( expected );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.js
index af56244c4822..98bba32b1f90 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,25 +56,25 @@ tape( 'if provided `a <= 0`, function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,25 +83,25 @@ tape( 'if provided `b <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function returns the expected value of a Kumaraswamy\'s double bounde
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 15.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.native.js
index 7a725c7e594d..62200f6f797b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,25 +65,25 @@ tape( 'if provided `a <= 0`, function returns `NaN`', opts, function test( t ) {
 	var y;
 
 	y = mean( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -92,25 +92,25 @@ tape( 'if provided `b <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function returns the expected value of a Kumaraswamy\'s double bounde
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 15.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/median/test/test.js
index 742c9fe7a70c..2632afc92f28 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/median/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,25 +56,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = median( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,25 +83,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function returns the median of a Kumaraswamy distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/median/test/test.native.js
index cfa78685c968..a98a9e8e8bcb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/median/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,25 +65,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = median( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,25 +92,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function returns the median of a Kumaraswamy distribution', opts, fun
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.js
index d64987b9eedf..805353ff750b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,7 +56,7 @@ tape( 'if provided `a = 1` and `b = 1`, the function returns `NaN`', function te
 	var y;
 
 	y = mode( 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,28 +65,28 @@ tape( 'if provided `a < 1`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mode( 0.8, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,28 +95,28 @@ tape( 'if provided `b < 1`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mode( 2.0, 0.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'the function returns the mode of a Kumaraswamy\'s double bounded distribu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 15.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.native.js
index ea5d93070944..a42ddacd96f4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,7 +65,7 @@ tape( 'if provided `a = 1` and `b = 1`, the function returns `NaN`', opts, funct
 	var y;
 
 	y = mode( 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -74,28 +74,28 @@ tape( 'if provided `a < 1`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mode( 0.8, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -104,28 +104,28 @@ tape( 'if provided `b < 1`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mode( 2.0, 0.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -146,7 +146,7 @@ tape( 'the function returns the mode of a Kumaraswamy\'s double bounded distribu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 15.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.factory.js
index b750641c6db9..b88ae463d5d2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.factory.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -50,23 +50,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,16 +77,16 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 100.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 10.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -97,19 +97,19 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -100.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -10.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -121,31 +121,31 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	pdf = factory( 1.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -157,31 +157,31 @@ tape( 'if provided a nonpositive `a`, the created function always returns `NaN`'
 	pdf = factory( 0.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -201,7 +201,7 @@ tape( 'the returned function evaluates the pdf of a Kumaraswamy\'s double bounde
 	for ( i = 0; i < 100; i++ ) {
 		x = randu();
 		y = pdf( x, a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.pdf.js
index 05ef15e74759..6fd5ba9bcff8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.pdf.js
@@ -40,42 +40,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 100.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 10.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 1.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -100.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -1.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 0.0, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -84,25 +84,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = pdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -111,25 +111,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function evaluates the pdf of a Kumaraswamy\'s double bounded distrib
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = pdf( x, a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.factory.js
index 65e9b00a969d..5eb5ffb8e608 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.factory.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -50,23 +50,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -78,31 +78,31 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	quantile = factory( 1.0, 0.0 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, -1.0 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NINF );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -114,31 +114,31 @@ tape( 'if provided a nonpositive `a`, the created function always returns `NaN`'
 	quantile = factory( 0.0, 0.5 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the returned function evaluates the quantile function of a Kumaraswamy\'s
 	for ( i = 0; i < 100; i++ ) {
 		p = randu();
 		y = quantile( p, a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.native.js
index d97b6802b151..274f70cdcd8f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.native.js
@@ -49,19 +49,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -69,25 +69,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = quantile( 0.2, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -96,25 +96,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = quantile( 0.2, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'the function evaluates the quantile function of a Kumaraswamy\'s double b
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = quantile( p, a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.quantile.js
index d3c8817ba10f..4ddba4c1edf7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.quantile.js
@@ -40,19 +40,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -60,25 +60,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = quantile( 0.2, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,25 +87,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = quantile( 0.2, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'the function evaluates the quantile function of a Kumaraswamy\'s double b
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = quantile( p, a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.js
index 98cc7fe422dc..c82557a3ba83 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.js
@@ -40,10 +40,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = skewness( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function returns the skewness of a Kumaraswamy\'s double bounded dist
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = skewness( a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.native.js
index 2bea61b6edee..36a65ab90ca2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.native.js
@@ -49,10 +49,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = skewness( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,25 +88,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function returns the skewness of a Kumaraswamy\'s double bounded dist
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = skewness( a, b );
-		t.equal( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns a number' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.js
index bf58aa7db9f6..97061c30f2fa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,25 +56,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = stdev( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,25 +83,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function returns the standard deviation of a Kumaraswamy\'s double bo
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.native.js
index 90136128e055..701780139d21 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,25 +65,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = stdev( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -92,25 +92,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function returns the standard deviation of a Kumaraswamy\'s double bo
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/test/test.js
index d627d4894052..b67f1dd65248 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Kumaraswamy\'s double bounded distribution functions', function test( t ) {
 	var keys = objectKeys( kumaraswamy );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.js
index 9eb9d28c6f8d..7975e21f8163 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,25 +56,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = variance( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,25 +83,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function returns the variance of a Kumaraswamy\'s double bounded dist
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 15000.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.native.js
index ab075ae705d5..4b977eb5352a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,25 +65,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = variance( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -92,25 +92,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function returns the variance of a Kumaraswamy\'s double bounded dist
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 17500.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.cdf.js
index 5433f2b379f7..3511d090517e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `b`, the function returns `NaN`', function test( t
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -107,7 +107,7 @@ tape( 'the function evaluates the cdf for `x` given positive `mu`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -134,7 +134,7 @@ tape( 'the function evaluates the cdf for `x` given negative `mu`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -161,7 +161,7 @@ tape( 'the function evaluates the cdf for `x` given large variance ( = large `b`
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.factory.js
index 9f1c28119fea..2c9ba882dc64 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `mu` and `b`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `mu` and `b`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'the created function evaluates the cdf for `x` given positive `mu`', func
 		cdf = factory( mu[i], b[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -186,7 +186,7 @@ tape( 'the created function evaluates the cdf for `x` given negative `mu`', func
 		cdf = factory( mu[i], b[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -215,7 +215,7 @@ tape( 'the created function evaluates the cdf for `x` given large variance ( = l
 		cdf = factory( mu[i], b[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.native.js
index 6eac38c0d218..054c4f212007 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `b`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function evaluates the cdf for `x` given positive `mu`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the cdf for `x` given negative `mu`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -170,7 +170,7 @@ tape( 'the function evaluates the cdf for `x` given large variance ( = large `b`
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.js
index 03e7a6334a9f..ce6c9c0212fc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the differential entropy of a Laplace distribution',
 		y = entropy( mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 4.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.native.js
index c2a9ae569766..64a903f67912 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the differential entropy of a Laplace distribution',
 		y = entropy( mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 4.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.js
index 6f198b6e844f..198f16b790cd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the excess kurtosis of a Laplace distribution', func
 		y = kurtosis( mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.native.js
index 80f0aa7b7f7a..f928e1fdc7a2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the excess kurtosis of a Laplace distribution', opts
 		y = kurtosis( mu[i], b[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.factory.js
index f6c333036393..ceccc7e0b6f6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	logcdf = factory( 0.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'the created function evaluates the logcdf for `x` given positive `mu`', f
 		logcdf = factory( mu[i], b[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -186,7 +186,7 @@ tape( 'the created function evaluates the logcdf for `x` given negative `mu`', f
 		logcdf = factory( mu[i], b[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -215,7 +215,7 @@ tape( 'the created function evaluates the logcdf for `x` given large variance (
 		logcdf = factory( mu[i], b[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.logcdf.js
index ba9520e7b24d..a07adec9f1a6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `b`, the function returns `NaN`', function test( t
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -107,7 +107,7 @@ tape( 'the function evaluates the logcdf for `x` given positive `mu`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -134,7 +134,7 @@ tape( 'the function evaluates the logcdf for `x` given negative `mu`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -161,7 +161,7 @@ tape( 'the function evaluates the logcdf for `x` given large variance ( = large
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.native.js
index 01289e65177d..5993474ac779 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `b`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function evaluates the logcdf for `x` given positive `mu`', opts, fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the logcdf for `x` given negative `mu`', opts, fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -170,7 +170,7 @@ tape( 'the function evaluates the logcdf for `x` given large variance ( = large
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.factory.js
index 191458a05e21..1f47e8cc4a9a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, 0.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the created function evaluates the logpdf for `x` given positive `mu`', f
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -189,7 +189,7 @@ tape( 'the created function evaluates the logpdf for `x` given negative `mu`', f
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -220,7 +220,7 @@ tape( 'the created function evaluates the logpdf for `x` given large variance (l
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.logpdf.js
index 621c14056f27..83f05b73313f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -70,28 +70,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function evaluates the logpdf for `x` given positive `mu`', function
 		y = logpdf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the logpdf for `x` given negative `mu`', function
 		y = logpdf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -172,7 +172,7 @@ tape( 'the function evaluates the logpdf for `x` given large variance (large `b`
 		y = logpdf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.native.js
index 17c422d5567d..7eb5c238fcdb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -79,28 +79,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'the function evaluates the logpdf for `x` given positive `mu`', opts, fun
 		y = logpdf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -152,7 +152,7 @@ tape( 'the function evaluates the logpdf for `x` given negative `mu`', opts, fun
 		y = logpdf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the function evaluates the logpdf for `x` given large variance (large `b`
 		y = logpdf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.js
index 73186bdf9462..d1ab1334a7d4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'the function returns the expected value of a Laplace distribution', funct
 	b = data.b;
 	for ( i = 0; i < mu.length; i++ ) {
 		y = mean( mu[i], b[i] );
-		t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.native.js
index 9437df79e258..07e9fc8310d1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 1.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns the expected value of a Laplace distribution', opts,
 	mu = data.mu;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( mu[i], b[i] );
-		t.equal( y, expected[i], 'mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.js
index 6146622bfaba..446c092c580d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = median( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'the function returns the median of a Laplace distribution', function test
 	b = data.b;
 	for ( i = 0; i < mu.length; i++ ) {
 		y = median( mu[i], b[i] );
-		t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.native.js
index c7faae07a8c6..556e782b623b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN, 1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( 1.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns the median of a Laplace distribution', opts, functio
 	mu = data.mu;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( mu[i], b[i] );
-		t.equal( y, expected[i], 'mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.factory.js
index 5b4ac8fb2027..a175636c04a5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0, 1.0 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,29 +83,29 @@ tape( 'the created function returns `NaN` for any `x` outside `(-1/b,1/b)', func
 
 	mgf = factory( 0.0, 2.0 );
 	y = mgf( -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( -0.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0, 4.0 );
 	y = mgf( -0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( -0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -117,34 +117,34 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	mgf = factory( 0.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0, 0.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -169,7 +169,7 @@ tape( 'the created function evaluates the mgf for `x` given positive `mu`', func
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 20.0 * EPS * abs( expected[ i ] );
@@ -200,7 +200,7 @@ tape( 'the created function evaluates the mgf for `x` given negative `mu`', func
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 60.0 * EPS * abs( expected[ i ] );
@@ -231,7 +231,7 @@ tape( 'the created function evaluates the mgf for `x` given large variance (larg
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 80.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.mgf.js
index 1dbfa2ee429c..487989c15ab3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.mgf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,28 +58,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,28 +88,28 @@ tape( 'the function returns `NaN` for any `x` outside `(-1/b,1/b)', function tes
 	var y;
 
 	y = mgf( -1.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( -0.8, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.8, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 1.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( -0.5, 0.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( -0.3, 0.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.5, 0.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.3, 0.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'the function evaluates the MGF for `x` given positive `mu`', function tes
 		y = mgf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 20.0 * EPS * abs( expected[ i ] );
@@ -161,7 +161,7 @@ tape( 'the function evaluates the MGF for `x` given negative `mu`', function tes
 		y = mgf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 60.0 * EPS * abs( expected[ i ] );
@@ -190,7 +190,7 @@ tape( 'the function evaluates the MGF for `x` given large variance (large `b` )'
 		y = mgf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 80.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.native.js
index 0d9fd6b44c5b..b74c584c1025 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.native.js
@@ -55,11 +55,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -67,28 +67,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,28 +97,28 @@ tape( 'the function returns `NaN` for any `x` outside `(-1/b,1/b)', opts, functi
 	var y;
 
 	y = mgf( -1.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( -0.8, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.8, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 1.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( -0.5, 0.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( -0.3, 0.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.5, 0.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.3, 0.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the function evaluates the MGF for `x` given positive `mu`', opts, functi
 		y = mgf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 20.0 * EPS * abs( expected[ i ] );
@@ -170,7 +170,7 @@ tape( 'the function evaluates the MGF for `x` given negative `mu`', opts, functi
 		y = mgf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 60.0 * EPS * abs( expected[ i ] );
@@ -199,7 +199,7 @@ tape( 'the function evaluates the MGF for `x` given large variance (large `b` )'
 		y = mgf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 80.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.js
index f72522fd5c97..2ddb465b1068 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the mode of a Laplace distribution', function test(
 		y = mode( mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.native.js
index 8dfcc2a3e360..6741cdd79e66 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the mode of a Laplace distribution', opts, function
 		y = mode( mu[i], b[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.factory.js
index cdfffa5ad9b7..564cdb38050e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the created function evaluates the pdf for `x` given positive `mu`', func
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -189,7 +189,7 @@ tape( 'the created function evaluates the pdf for `x` given negative `mu`', func
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -220,7 +220,7 @@ tape( 'the created function evaluates the pdf for `x` given large variance (larg
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.native.js
index bc859e36c1aa..8bdedf968f8c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,28 +79,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'the function evaluates the pdf for `x` given positive `mu`', opts, functi
 		y = pdf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
@@ -152,7 +152,7 @@ tape( 'the function evaluates the pdf for `x` given negative `mu`', opts, functi
 		y = pdf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the function evaluates the pdf for `x` given large variance (large `b` )'
 		y = pdf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.pdf.js
index 44a4aee51f93..bf0eb40ba4b2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,28 +70,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function evaluates the pdf for `x` given positive `mu`', function tes
 		y = pdf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the pdf for `x` given negative `mu`', function tes
 		y = pdf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -172,7 +172,7 @@ tape( 'the function evaluates the pdf for `x` given large variance (large `b` )'
 		y = pdf( x[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.factory.js
index 1780db663e30..a805fa1da050 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,34 +98,34 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, 0.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -150,7 +150,7 @@ tape( 'the created function evaluates the quantile function at `p` given positiv
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the created function evaluates the quantile function at `p` given negativ
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -212,7 +212,7 @@ tape( 'the created function evaluates the quantile function at `p` given large v
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.native.js
index aab39314937b..33a0e606fc8c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `b`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -75,28 +75,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function evaluates the quantile function at `p` given positive `mu`',
 		y = quantile( p[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 500.0 * EPS * abs( expected[ i ] );
@@ -148,7 +148,7 @@ tape( 'the function evaluates the quantile function at `p` given negative `mu`',
 		y = quantile( p[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 500.0 * EPS * abs( expected[ i ] );
@@ -177,7 +177,7 @@ tape( 'the function evaluates the quantile function at `p` given large variance
 		y = quantile( p[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 500.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.quantile.js
index 95cdc25b9a40..36b55bf69cf4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `b`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,28 +66,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function evaluates the quantile function at `p` given positive `mu`',
 		y = quantile( p[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -139,7 +139,7 @@ tape( 'the function evaluates the quantile function at `p` given negative `mu`',
 		y = quantile( p[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -168,7 +168,7 @@ tape( 'the function evaluates the quantile function at `p` given large variance
 		y = quantile( p[i], mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.js
index b7fae4d5bad8..533eb9e232fb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the skewness of a Laplace distribution', function te
 		y = skewness( mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.native.js
index f7fe54c3c783..31e1c6f61c2a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the skewness of a Laplace distribution', opts, funct
 		y = skewness( mu[i], b[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.js
index 84a936f5ecda..ce8d6a96ba4f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the standard deviation of a Laplace distribution', f
 		y = stdev( mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.native.js
index b5b13187c384..1580bd4a0f84 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the standard deviation of a Laplace distribution', o
 		y = stdev( mu[i], b[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/test/test.js
index e827c58082d7..b00c0195f25a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Laplace (double exponential) distribution functions', function test( t ) {
 	var keys = objectKeys( laplace );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.js
index e4c607b712d4..61d17d7638ec 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the variance of a Laplace distribution', function te
 		y = variance( mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.native.js
index 4e03ee989098..fbc7b8520650 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the variance of a Laplace distribution', opts, funct
 		y = variance( mu[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.cdf.js
index 6e0c5cca6ba1..a62a0b692335 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.cdf.js
@@ -46,32 +46,32 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `c`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided a `x` smaller than `mu`, the function returns `0`', function test( t ) {
 	var y = cdf( -1.0, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 3.0, 4.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -80,25 +80,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function evaluates the cdf for `x` given positive `mu`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -149,7 +149,7 @@ tape( 'the function evaluates the cdf for `x` given negative `mu`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -176,7 +176,7 @@ tape( 'the function evaluates the cdf for `x` given large variance ( = large `b`
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.factory.js
index c242f4b92324..860fab596992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `mu` and `c`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `mu` and `c`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -105,11 +105,11 @@ tape( 'the created function returns `0` for `x < mu`', function test( t ) {
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	cdf = factory( 4.0, 1.0 );
 	y = cdf( 3.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -121,34 +121,34 @@ tape( 'if provided a nonpositive `c`, the created function always returns `NaN`'
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -172,7 +172,7 @@ tape( 'the created function evaluates the cdf for `x` given positive `mu`', func
 		cdf = factory( mu[i], c[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -201,7 +201,7 @@ tape( 'the created function evaluates the cdf for `x` given negative `mu`', func
 		cdf = factory( mu[i], c[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -230,7 +230,7 @@ tape( 'the created function evaluates the cdf for `x` given large variance ( = l
 		cdf = factory( mu[i], c[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.native.js
index e08907d9c964..0133046f2eae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.native.js
@@ -55,32 +55,32 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `mu` and `c`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `mu` and `c`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided a `x` smaller than `mu`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( -1.0, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 3.0, 4.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -89,25 +89,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function evaluates the cdf for `x` given a positive `mu`', opts, func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[ i ], mu[ i ], c[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: ' + x[ i ] + ', mu: ' + mu[ i ] + ', c: ' + c[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: ' + x[ i ] + ', mu: ' + mu[ i ] + ', c: ' + c[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
@@ -158,7 +158,7 @@ tape( 'the function evaluates the cdf for `x` given a negative `mu`', opts, func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[ i ], mu[ i ], c[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: ' + x[ i ] + ', mu: ' + mu[ i ] + ', c: ' + c[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: ' + x[ i ] + ', mu: ' + mu[ i ] + ', c: ' + c[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the cdf for `x` given a large variance ( = large `
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[ i ], mu[ i ], c[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: ' + x[ i ] + ', mu: ' + mu[ i ] + ', c: ' + c[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: ' + x[ i ] + ', mu: ' + mu[ i ] + ', c: ' + c[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.js
index bde2d2baf865..2b54d32660a3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the differential entropy of a Lévy distribution', f
 		y = entropy( mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 110.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.native.js
index b7f7a04847a0..e529c0b4a210 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the differential entropy of a Lévy distribution', o
 		y = entropy( mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 110.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.factory.js
index c68d2a785ce2..84e3e01f1d29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `mu` and `c`, the function returns a function which r
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `mu` and `c`, the function returns a function which r
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -105,11 +105,11 @@ tape( 'the created function returns `-infinity` for `x < mu`', function test( t
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( -1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	logcdf = factory( 4.0, 1.0 );
 	y = logcdf( 3.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -121,34 +121,34 @@ tape( 'if provided a nonpositive `c`, the created function always returns `NaN`'
 	logcdf = factory( 0.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -172,7 +172,7 @@ tape( 'the created function evaluates the logcdf for `x` given positive `mu`', f
 		logcdf = factory( mu[i], c[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -201,7 +201,7 @@ tape( 'the created function evaluates the logcdf for `x` given negative `mu`', f
 		logcdf = factory( mu[i], c[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -230,7 +230,7 @@ tape( 'the created function evaluates the logcdf for `x` given large variance (
 		logcdf = factory( mu[i], c[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.logcdf.js
index 143cdbff3817..b8d1e2d0e999 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.logcdf.js
@@ -46,32 +46,32 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `c`, the function returns `-infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
 tape( 'if provided a `x` smaller than `mu`, the function returns `-infinity`', function test( t ) {
 	var y = logcdf( -1.0, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 3.0, 4.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -80,25 +80,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function evaluates the logcdf for `x` given positive `mu`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -149,7 +149,7 @@ tape( 'the function evaluates the logcdf for `x` given negative `mu`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -176,7 +176,7 @@ tape( 'the function evaluates the logcdf for `x` given large variance ( = large
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.native.js
index d5ec23c8afb6..3945709ab073 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.native.js
@@ -55,32 +55,32 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `c`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
 tape( 'if provided a `x` smaller than `mu`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logcdf( -1.0, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logcdf( 3.0, 4.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -89,25 +89,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function evaluates the logcdf for `x` given positive `mu`', opts, fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the logcdf for `x` given negative `mu`', opts, fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the logcdf for `x` given large variance ( = large
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.factory.js
index 5b53306a13c8..8eee05bb1d45 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `c`, the function returns a function which
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -95,13 +95,13 @@ tape( 'if provided a finite `mu` and `c`, the function returns a function which
 	logpdf = factory( 0.0, 1.0 );
 
 	y = logpdf( 0.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -2.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -113,31 +113,31 @@ tape( 'if provided a nonpositive `c`, the created function always returns `NaN`'
 	logpdf = factory( 0.0, 0.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -162,7 +162,7 @@ tape( 'the created function evaluates the logpdf for `x` given positive `mu`', f
 		y = logpdf( x[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -193,7 +193,7 @@ tape( 'the created function evaluates the logpdf for `x` given negative `mu`', f
 		y = logpdf( x[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -224,7 +224,7 @@ tape( 'the created function evaluates the logpdf for `x` given large variance (
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.logpdf.js
index bd40902cb6fd..e86333179a3e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.logpdf.js
@@ -46,17 +46,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
@@ -64,13 +64,13 @@ tape( 'if provided `x <= μ` and a finite `mu` and `c`, the function returns `-i
 	var y;
 
 	y = logpdf( 0.0, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -2.0, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function evaluates the logpdf for `x` given positive `mu`', function
 		y = logpdf( x[i], mu[i], c[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -149,7 +149,7 @@ tape( 'the function evaluates the logpdf for `x` given negative `mu`', function
 		y = logpdf( x[i], mu[i], c[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -178,7 +178,7 @@ tape( 'the function evaluates the logpdf for `x` given large variance ( = large
 		y = logpdf( x[i], mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.native.js
index 21ca5f0ea496..b62bc58daa1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `c`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function evaluates the logpdf for `x` given positive `mu`', opts, fun
 		y = logpdf( x[i], mu[i], c[i] );
 		if ( expected[i] !== null && !(expected[i] === NINF && y === NINF ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -149,7 +149,7 @@ tape( 'the function evaluates the logpdf for `x` given negative `mu`', opts, fun
 		y = logpdf( x[i], mu[i], c[i] );
 		if ( expected[i] !== null && !(expected[i] === NINF && y === NINF ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -178,7 +178,7 @@ tape( 'the function evaluates the logpdf for `x` given large variance ( = large
 		y = logpdf( x[i], mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.js
index 1d5e5cc84b19..4d524d7c65fb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.js
@@ -38,9 +38,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -48,25 +48,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the expected value of a Lévy distribution', functio
 		mu = ( randu()*10.0 ) - 5.0;
 		c = randu() * 20.0;
 		y = mean( mu, c );
-		t.equal( y, PINF, 'returns +Infinity' );
+		t.strictEqual( y, PINF, 'returns +Infinity' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.native.js
index 7caecbb9b373..9972881b66d5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.native.js
@@ -47,9 +47,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -57,25 +57,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns the expected value of a Lévy distribution', opts, f
 		mu = ( randu()*10.0 ) - 5.0;
 		c = randu() * 20.0;
 		y = mean( mu, c );
-		t.equal( y, PINF, 'returns +Infinity' );
+		t.strictEqual( y, PINF, 'returns +Infinity' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/median/test/test.js
index ceb0e49b2d70..6ea48349b2cc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/median/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the median of a Lévy distribution', function test(
 		y = median( mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/median/test/test.native.js
index 3520138ffd9e..49b686baa866 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/median/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the median of a Lévy distribution', opts, function
 		y = median( mu[i], c[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.js
index 875ed859852b..4d0e78e51722 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the mode of a Lévy distribution', function test( t
 		y = mode( mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.native.js
index 1bd594347146..8f4d20a62755 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the mode of a Lévy distribution', opts, function te
 		y = mode( mu[i], c[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.factory.js
index 4fae2508a6dd..5a6a202c8066 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `c`, the function returns a function which
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `c`, the function returns a function which
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,31 +106,31 @@ tape( 'if provided a nonpositive `c`, the created function always returns `NaN`'
 	pdf = factory( 0.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the created function evaluates the pdf for `x` given positive `mu`', func
 		y = pdf( x[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -186,7 +186,7 @@ tape( 'the created function evaluates the pdf for `x` given negative `mu`', func
 		y = pdf( x[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -217,7 +217,7 @@ tape( 'the created function evaluates the pdf for `x` given large variance ( = l
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.native.js
index 515326e1077d..567a549cc662 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `c`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function evaluates the pdf for `x` given positive `mu`', opts, functi
 		y = pdf( x[i], mu[i], c[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -149,7 +149,7 @@ tape( 'the function evaluates the pdf for `x` given negative `mu`', opts, functi
 		y = pdf( x[i], mu[i], c[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -178,7 +178,7 @@ tape( 'the function evaluates the pdf for `x` given large variance ( = large `c`
 		y = pdf( x[i], mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.pdf.js
index d4f3464cde81..fa80abb71726 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `c`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -111,7 +111,7 @@ tape( 'the function evaluates the pdf for `x` given positive `mu`', function tes
 		y = pdf( x[i], mu[i], c[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -140,7 +140,7 @@ tape( 'the function evaluates the pdf for `x` given negative `mu`', function tes
 		y = pdf( x[i], mu[i], c[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -169,7 +169,7 @@ tape( 'the function evaluates the pdf for `x` given large variance ( = large `c`
 		y = pdf( x[i], mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.factory.js
index 5a09bee823bc..beac6e18a43e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `mu` and `c`, the function returns a function which
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,26 +98,26 @@ tape( 'if provided a negative `c`, the created function always returns `NaN`', f
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -142,7 +142,7 @@ tape( 'the created function evaluates the quantile function at `p` given positiv
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 20.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the created function evaluates the quantile function at `p` given negativ
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 350.0 * EPS * abs( expected[ i ] );
@@ -204,7 +204,7 @@ tape( 'the created function evaluates the quantile function at `p` given large v
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 30.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.native.js
index 6a5a298e628e..fd21b05d79c4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `c`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -75,22 +75,22 @@ tape( 'if provided a negative `c`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function evaluates the quantile function at `p` given positive `mu`',
 		y = quantile( p[i], mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 20.0 * EPS * abs( expected[ i ] );
@@ -142,7 +142,7 @@ tape( 'the function evaluates the quantile function at `p` given negative `mu`',
 		y = quantile( p[i], mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 350.0 * EPS * abs( expected[ i ] );
@@ -171,7 +171,7 @@ tape( 'the function evaluates the quantile function at `p` given large variance
 		y = quantile( p[i], mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 30.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.quantile.js
index 579791a49e40..f63c87832750 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `c`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,22 +66,22 @@ tape( 'if provided a negative `c`, the function returns `NaN`', function test( t
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function evaluates the quantile function at `p` given positive `mu`',
 		y = quantile( p[i], mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 20.0 * EPS * abs( expected[ i ] );
@@ -133,7 +133,7 @@ tape( 'the function evaluates the quantile function at `p` given negative `mu`',
 		y = quantile( p[i], mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 350.0 * EPS * abs( expected[ i ] );
@@ -162,7 +162,7 @@ tape( 'the function evaluates the quantile function at `p` given large variance
 		y = quantile( p[i], mu[i], c[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 30.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.js
index a25ea5a3653a..3cf6ca1bb5db 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.js
@@ -38,9 +38,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -48,25 +48,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the standard deviation of a Lévy distribution', fun
 		mu = ( randu()*10.0 ) - 5.0;
 		c = randu() * 20.0;
 		y = stdev( mu, c );
-		t.equal( y, PINF, 'returns +Infinity' );
+		t.strictEqual( y, PINF, 'returns +Infinity' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.native.js
index dc2034ae609b..74da422038fe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.native.js
@@ -47,9 +47,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -57,25 +57,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns the standard deviation of a Lévy distribution', opt
 		mu = ( randu()*10.0 ) - 5.0;
 		c = randu() * 20.0;
 		y = stdev( mu, c );
-		t.equal( y, PINF, 'returns +Infinity' );
+		t.strictEqual( y, PINF, 'returns +Infinity' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/test/test.js
index 954e0fed5db1..955a5742fc8d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Lévy distribution functions', function test( t ) {
 	var keys = objectKeys( levy );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.js
index bffe5fd7220c..5ac294071ea8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.js
@@ -38,9 +38,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -48,25 +48,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the variance of a Lévy distribution', function test
 		mu = ( randu()*10.0 ) - 5.0;
 		c = randu() * 20.0;
 		y = variance( mu, c );
-		t.equal( y, PINF, 'returns +Infinity' );
+		t.strictEqual( y, PINF, 'returns +Infinity' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.native.js
index cd5491084286..b4af14078586 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.native.js
@@ -47,9 +47,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -57,25 +57,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns the variance of a Lévy distribution', opts, functio
 		mu = ( randu()*10.0 ) - 5.0;
 		c = randu() * 20.0;
 		y = variance( mu, c );
-		t.equal( y, PINF, 'returns +Infinity' );
+		t.strictEqual( y, PINF, 'returns +Infinity' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.cdf.js
index 185eefbfdd31..ec365ed53cd7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,13 +94,13 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to mu' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to mu' );
 
 	y = cdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than mu' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than mu' );
 
 	y = cdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than mu' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than mu' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function evaluates the cdf for `x` given positive `mu`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -149,7 +149,7 @@ tape( 'the function evaluates the cdf for `x` given negative `mu`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -176,7 +176,7 @@ tape( 'the function evaluates the cdf for `x` given large variance ( = large `s`
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.factory.js
index ddf1fcbd9db1..b470cc15d12c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `mu` and `s`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `mu` and `s`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,13 +137,13 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	cdf = factory( 2.0, 0.0 );
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to mu' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to mu' );
 
 	y = cdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than mu' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than mu' );
 
 	y = cdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than mu' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than mu' );
 
 	t.end();
 });
@@ -167,7 +167,7 @@ tape( 'the created function evaluates the cdf for `x` given positive `mu`', func
 		cdf = factory( mu[i], s[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -196,7 +196,7 @@ tape( 'the created function evaluates the cdf for `x` given negative `mu`', func
 		cdf = factory( mu[i], s[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -225,7 +225,7 @@ tape( 'the created function evaluates the cdf for `x` given large variance ( = l
 		cdf = factory( mu[i], s[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.native.js
index 8579e8af8426..43cea6598bd5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,13 +103,13 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to mu' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to mu' );
 
 	y = cdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than mu' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than mu' );
 
 	y = cdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than mu' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than mu' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function evaluates the cdf for `x` given positive `mu`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the cdf for `x` given negative `mu`', opts, functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the cdf for `x` given large variance ( = large `s`
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.js
index e9cab2533af2..baae0f07bd3d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the differential entropy of a logistic distribution'
 		y = entropy( mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.native.js
index cdc821203b22..2703e725d422 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the differential entropy of a logistic distribution'
 		y = entropy( mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.js
index 12a4afdce7e4..7c7e9f6d6538 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'the function returns the excess kurtosis of a logistic distribution', fun
 	s = data.s;
 	for ( i = 0; i < mu.length; i++ ) {
 		y = kurtosis( mu[ i ], s[ i ] );
-		t.equal( y, expected[ i ], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[ i ], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.native.js
index 4a6f1b1f2743..8aa97c40d431 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,22 +61,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the excess kurtosis of a logistic distribution', opt
 	s = data.s;
 	for ( i = 0; i < mu.length; i++ ) {
 		y = kurtosis( mu[ i ], s[ i ] );
-		t.equal( y, expected[ i ], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[ i ], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.factory.js
index bb9f6fbfd44f..793bfc6920e6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	logcdf = factory( 0.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,13 +137,13 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	logcdf = factory( 2.0, 0.0 );
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x equal to mu' );
+	t.strictEqual( y, 0.0, 'returns 0 for x equal to mu' );
 
 	y = logcdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x greater than mu' );
+	t.strictEqual( y, 0.0, 'returns 0 for x greater than mu' );
 
 	y = logcdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity for x smaller than mu' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x smaller than mu' );
 
 	t.end();
 });
@@ -167,7 +167,7 @@ tape( 'the created function evaluates the logcdf for `x` given positive `mu`', f
 		logcdf = factory( mu[i], s[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -196,7 +196,7 @@ tape( 'the created function evaluates the logcdf for `x` given negative `mu`', f
 		logcdf = factory( mu[i], s[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -225,7 +225,7 @@ tape( 'the created function evaluates the logcdf for `x` given large variance (
 		logcdf = factory( mu[i], s[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.logcdf.js
index cf3ee4882132..e37522e6a4cc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,13 +94,13 @@ tape( 'if provided `s=0`, the function evaluates a degenerate distribution cente
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x equal to mu' );
+	t.strictEqual( y, 0.0, 'returns 0 for x equal to mu' );
 
 	y = logcdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x greater than mu' );
+	t.strictEqual( y, 0.0, 'returns 0 for x greater than mu' );
 
 	y = logcdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity for x smaller than mu' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x smaller than mu' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function evaluates the logcdf for `x` given positive `mu`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -149,7 +149,7 @@ tape( 'the function evaluates the logcdf for `x` given negative `mu`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -176,7 +176,7 @@ tape( 'the function evaluates the logcdf for `x` given large variance ( = large
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.native.js
index 06556c3197bf..fde47ea8b711 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,13 +103,13 @@ tape( 'if provided `s=0`, the function evaluates a degenerate distribution cente
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x equal to mu' );
+	t.strictEqual( y, 0.0, 'returns 0 for x equal to mu' );
 
 	y = logcdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x greater than mu' );
+	t.strictEqual( y, 0.0, 'returns 0 for x greater than mu' );
 
 	y = logcdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity for x smaller than mu' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x smaller than mu' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function evaluates the logcdf for `x` given positive `mu`', opts, fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the logcdf for `x` given negative `mu`', opts, fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the logcdf for `x` given large variance ( = large
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], s[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.factory.js
index de6c8eb6a89a..f51a183932e9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,19 +137,19 @@ tape( 'if `s` equals `0`, the created function evaluates a degenerate distributi
 	logpdf = factory( 2.0, 0.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( y, PINF, 'returns +Infinity for x equal to mu' );
+	t.strictEqual( y, PINF, 'returns +Infinity for x equal to mu' );
 
 	y = logpdf( 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -174,7 +174,7 @@ tape( 'the created function evaluates the logpdf for `x` given positive `mu`', f
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -205,7 +205,7 @@ tape( 'the created function evaluates the logpdf for `x` given negative `mu`', f
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -236,7 +236,7 @@ tape( 'the created function evaluates the logpdf for `x` given large variance (
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.logpdf.js
index 8873fd05d307..615582e71629 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,19 +94,19 @@ tape( 'if provided `s` equal to `0`, the function evaluates a degenerate distrib
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to mu' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = logpdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -infinity ' );
+	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( PINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -infinity ' );
+	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( NINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -infinity ' );
+	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function evaluates the logpdf for `x` given positive `mu`', function
 		y = logpdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the logpdf for `x` given negative `mu`', function
 		y = logpdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -187,7 +187,7 @@ tape( 'the function evaluates the logpdf for `x` given large variance ( = large
 		y = logpdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.native.js
index 827572e8b90c..fb6193082971 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,19 +103,19 @@ tape( 'if provided `s` equal to `0`, the function evaluates a degenerate distrib
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to mu' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = logpdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -infinity ' );
+	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( PINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -infinity ' );
+	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( NINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -infinity ' );
+	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the function evaluates the logpdf for `x` given positive `mu`', opts, fun
 		y = logpdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -167,7 +167,7 @@ tape( 'the function evaluates the logpdf for `x` given negative `mu`', opts, fun
 		y = logpdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -196,7 +196,7 @@ tape( 'the function evaluates the logpdf for `x` given large variance ( = large
 		y = logpdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.js
index fd354efc9738..5234110f3a61 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the expected value of a logistic distribution', func
 		y = mean( mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.native.js
index c50d00f7db5a..08d6903f15dd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,22 +61,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns the expected value of a logistic distribution', opts
 	for ( i = 0; i < mu.length; i++ ) {
 		y = mean( mu[i], s[i] );
 		if ( expected[i] !== null ) {
-			t.equal( y, mu[i], 'mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, mu[i], 'mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.js
index ae76cf29b6ab..4ab83ae09f99 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = median( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the median of a logistic distribution', function tes
 		y = median( mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.native.js
index 401a02d39734..e52c3b579648 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = median( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,22 +61,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns the median of a logistic distribution', opts, functi
 	for ( i = 0; i < mu.length; i++ ) {
 		y = median( mu[i], s[i] );
 		if ( expected[i] !== null ) {
-			t.equal( y, mu[i], 'mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, mu[i], 'mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.factory.js
index e91b7751c169..379a17d26f8e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0, 1.0 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,26 +85,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	mgf = factory( 0.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,14 +116,14 @@ tape( 'if provided `s = 0`, the created function evaluates the MGF of the degene
 	mgf = factory( 0.0, 0.0 );
 
 	y = mgf( 0.5 );
-	t.equal( y, 1.0, 'returns exp( 0.0 * 0.5 )' );
+	t.strictEqual( y, 1.0, 'returns exp( 0.0 * 0.5 )' );
 
 	mgf = factory( 2.0, 0.0 );
 	y = mgf( 0.5 );
-	t.equal( y, exp( 1.0 ), 'returns exp( 2.0 * 0.5 )' );
+	t.strictEqual( y, exp( 1.0 ), 'returns exp( 2.0 * 0.5 )' );
 
 	y = mgf( 2.0 );
-	t.equal( y, exp( 4.0 ), 'returns exp( 2.0 * 2.0 )' );
+	t.strictEqual( y, exp( 4.0 ), 'returns exp( 2.0 * 2.0 )' );
 
 	t.end();
 });
@@ -148,7 +148,7 @@ tape( 'the created function evaluates the MGF for `x` given positive `mu`', func
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
@@ -179,7 +179,7 @@ tape( 'the created function evaluates the MGF for `x` given negative `mu`', func
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
@@ -210,7 +210,7 @@ tape( 'the created function evaluates the MGF for `x` given large variance ( = l
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.mgf.js
index 841f828b9f0f..4c354b6ea5f6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.mgf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,22 +58,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -96,7 +96,7 @@ tape( 'the function evaluates the MGF for `x` given positive `mu`', function tes
 		y = mgf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
@@ -125,7 +125,7 @@ tape( 'the function evaluates the MGF for `x` given negative `mu`', function tes
 		y = mgf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
@@ -154,7 +154,7 @@ tape( 'the function evaluates the MGF for `x` given large variance ( = large `s`
 		y = mgf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.native.js
index d02c40d8efcd..f16699efda6c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.native.js
@@ -55,11 +55,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -67,22 +67,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -105,7 +105,7 @@ tape( 'the function evaluates the MGF for `x` given positive `mu`', opts, functi
 		y = mgf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
@@ -134,7 +134,7 @@ tape( 'the function evaluates the MGF for `x` given negative `mu`', opts, functi
 		y = mgf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
@@ -163,7 +163,7 @@ tape( 'the function evaluates the MGF for `x` given large variance ( = large `s`
 		y = mgf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.js
index d0cb447addae..d6293d73db92 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the mode of a logistic distribution', function test(
 		y = mode( mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.native.js
index 6286a057240e..4dbf89584d79 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,22 +61,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns the mode of a logistic distribution', opts, function
 	for ( i = 0; i < mu.length; i++ ) {
 		y = mode( mu[i], s[i] );
 		if ( expected[i] !== null ) {
-			t.equal( y, mu[i], 'mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, mu[i], 'mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.factory.js
index d275b6f01477..c738454bac49 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,19 +137,19 @@ tape( 'if `s` equals `0`, the created function evaluates a degenerate distributi
 	pdf = factory( 2.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to mu' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = pdf( 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -174,7 +174,7 @@ tape( 'the created function evaluates the pdf for `x` given positive `mu`', func
 		y = pdf( x[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -205,7 +205,7 @@ tape( 'the created function evaluates the pdf for `x` given negative `mu`', func
 		y = pdf( x[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -236,7 +236,7 @@ tape( 'the created function evaluates the pdf for `x` given large variance ( = l
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.native.js
index 45d98802cf57..45badf63b148 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,19 +103,19 @@ tape( 'if provided `s` equal to `0`, the function evaluates a degenerate distrib
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to mu' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = pdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( PINF, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NINF, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the function evaluates the pdf for `x` given positive `mu`', opts, functi
 		y = pdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -167,7 +167,7 @@ tape( 'the function evaluates the pdf for `x` given negative `mu`', opts, functi
 		y = pdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -196,7 +196,7 @@ tape( 'the function evaluates the pdf for `x` given large variance ( = large `s`
 		y = pdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.pdf.js
index 13dd9021202f..a381983b24d1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,19 +94,19 @@ tape( 'if provided `s` equal to `0`, the function evaluates a degenerate distrib
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to mu' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = pdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( PINF, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NINF, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function evaluates the pdf for `x` given positive `mu`', function tes
 		y = pdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the pdf for `x` given negative `mu`', function tes
 		y = pdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null && !(expected[i] === 0.0 && y < EPS ) ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -187,7 +187,7 @@ tape( 'the function evaluates the pdf for `x` given large variance ( = large `s`
 		y = pdf( x[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.factory.js
index fd9885e2d04e..664e77ead56d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,26 +98,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -129,16 +129,16 @@ tape( 'if `s` equals `0`, the created function evaluates a degenerate distributi
 	quantile = factory( 2.0, 0.0 );
 
 	y = quantile( 0.3, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 0.9, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 1.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	y = quantile( -0.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	t.end();
 });
@@ -163,7 +163,7 @@ tape( 'the created function evaluates the quantile function at `p` given positiv
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -194,7 +194,7 @@ tape( 'the created function evaluates the quantile function at `p` given negativ
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -225,7 +225,7 @@ tape( 'the created function evaluates the quantile function at `p` given large v
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.native.js
index 2e94350a8077..1e99b2872949 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.native.js
@@ -54,19 +54,19 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `s`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -74,22 +74,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,16 +98,16 @@ tape( 'if provided `s` equals `0`, the function evaluates a degenerate distribut
 	var y;
 
 	y = quantile( 0.3, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 0.9, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 1.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	y = quantile( -0.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function evaluates the quantile function at `p` given positive `mu`',
 		y = quantile( p[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 60.0 * EPS * abs( expected[ i ] );
@@ -159,7 +159,7 @@ tape( 'the function evaluates the quantile function at `p` given negative `mu`',
 		y = quantile( p[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 110.0 * EPS * abs( expected[ i ] );
@@ -188,7 +188,7 @@ tape( 'the function evaluates the quantile function at `p` given large variance
 		y = quantile( p[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 8.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.quantile.js
index 2bd049b9b441..0637bf5929db 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `s`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,22 +66,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -90,16 +90,16 @@ tape( 'if provided `s` equals `0`, the function evaluates a degenerate distribut
 	var y;
 
 	y = quantile( 0.3, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 0.9, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 1.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	y = quantile( -0.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function evaluates the quantile function at `p` given positive `mu`',
 		y = quantile( p[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -151,7 +151,7 @@ tape( 'the function evaluates the quantile function at `p` given negative `mu`',
 		y = quantile( p[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -180,7 +180,7 @@ tape( 'the function evaluates the quantile function at `p` given large variance
 		y = quantile( p[i], mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.js
index 0bf9bc8cec6d..4942bc26e82e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'the function returns the skewness of a logistic distribution (always 0)',
 	s = data.s;
 	for ( i = 0; i < mu.length; i++ ) {
 		y = skewness( mu[i], s[i] );
-		t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.native.js
index 517082b69c0e..bef83cafd3a5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,22 +61,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the skewness of a logistic distribution (always 0)',
 	s = data.s;
 	for ( i = 0; i < mu.length; i++ ) {
 		y = skewness( mu[i], s[i] );
-		t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.js
index 99636d7eda8d..8cc75b570873 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the standard deviation of a logistic distribution',
 		y = stdev( mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.native.js
index a80d3a1eba26..89640f9ce615 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the standard deviation of a logistic distribution',
 		y = stdev( mu[i], s[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/test/test.js
index b9a1250346c0..23eb5e2c2039 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains logistic distribution functions', function test( t ) {
 	var keys = objectKeys( logistic );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.js
index b1e448bcf156..c5008590a86f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the variance of a logistic distribution', function t
 		y = variance( mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.native.js
index 32eb7589eb80..ee5df2691fae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the variance of a logistic distribution', opts, func
 		y = variance( mu[i], s[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', s: '+s[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.cdf.js
index 013bce5c92a1..edc9e86c96d9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `sigma`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function evaluates the cdf for `x` given positive `mu`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1500.0 * EPS * abs( expected[ i ] );
@@ -137,7 +137,7 @@ tape( 'the function evaluates the cdf for `x` given negative `mu`', function tes
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 550.0 * EPS * abs( expected[ i ] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the cdf for `x` given large variance ( = large `si
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.factory.js
index 6f29dd4b8e04..58034af09871 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the created function evaluates the cdf for `x` given positive `mu`', func
 		cdf = factory( mu[i], sigma[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1500.0 * EPS * abs( expected[ i ] );
@@ -178,7 +178,7 @@ tape( 'the created function evaluates the cdf for `x` given negative `mu`', func
 		cdf = factory( mu[i], sigma[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 550.0 * EPS * abs( expected[ i ] );
@@ -207,7 +207,7 @@ tape( 'the created function evaluates the cdf for `x` given large variance ( = l
 		cdf = factory( mu[i], sigma[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.js
index 860f3bdcb2bd..8bce41662234 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the differential entropy of a lognormal distribution
 		y = entropy( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 18.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.native.js
index a40258c20fba..4ba79f1fdfc5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the differential entropy of a lognormal distribution
 		y = entropy( mu[i], sigma[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 18.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.js
index e1d60a983a6d..6518a9934d31 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the excess kurtosis of a lognormal distribution', fu
 		y = kurtosis( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.native.js
index 382b3b16a085..823ed9ba1a64 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the excess kurtosis of a lognormal distribution', op
 		y = kurtosis( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 160.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.factory.js
index 9cf713ff048c..58d6edc6f7e3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,23 +54,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns 0' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -104,26 +104,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	logcdf = factory( 0.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -135,19 +135,19 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	logcdf = factory( 2.0, 0.0 );
 
 	y = logcdf( PINF );
-	t.equal( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns 0' );
 
 	y = logcdf( 2.0 );
-	t.equal( y, 0, 'returns 0 for x equal to mu' );
+	t.strictEqual( y, 0, 'returns 0 for x equal to mu' );
 
 	y = logcdf( 1.0 );
-	t.equal( y, -Infinity, 'returns -Infinity' );
+	t.strictEqual( y, -Infinity, 'returns -Infinity' );
 
 	y = logcdf( NINF );
-	t.equal( y, -Infinity, 'returns -Infinity' );
+	t.strictEqual( y, -Infinity, 'returns -Infinity' );
 
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -171,7 +171,7 @@ tape( 'the created function evaluates the logcdf for `x` given parameters `mu` a
 		logcdf = factory( mu[i], sigma[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1500.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.js
index 03e50045659e..c449f931f6c1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.logcdf.js
index 20b6e5980c79..453feff9f0a8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.logcdf.js
@@ -46,38 +46,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -85,22 +85,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', funct
 	var y;
 
 	y = logcdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,19 +109,19 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = logcdf( PINF, 2.0, 0.0 );
-	t.equal( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns 0' );
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity for x equal to mu' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x equal to mu' );
 
 	y = logcdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( NINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function evaluates the logcdf for `x` given parameters `mu` and `sigm
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1500.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.factory.js
index 31030c06e544..9b4d4d4cdc87 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -105,30 +105,30 @@ tape( 'if provided a nonpositive `sigma`, the created function always returns `N
 
 	logpdf = factory( 0.0, 0.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, -1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -153,7 +153,7 @@ tape( 'the created function evaluates the logpdf for `x` given positive `mu`', f
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 20.0 * EPS * abs( expected[ i ] );
@@ -184,7 +184,7 @@ tape( 'the created function evaluates the logpdf for `x` given negative `mu`', f
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 20.0 * EPS * abs( expected[ i ] );
@@ -215,7 +215,7 @@ tape( 'the created function evaluates the logpdf for `x` given large variance (
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.logpdf.js
index 013512d4823f..a57ce9f3d5fe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -111,7 +111,7 @@ tape( 'the function evaluates the logpdf for `x` given positive `mu`', function
 		y = logpdf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 20.0 * EPS * abs( expected[ i ] );
@@ -140,7 +140,7 @@ tape( 'the function evaluates the logpdf for `x` given negative `mu`', function
 		y = logpdf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 20.0 * EPS * abs( expected[ i ] );
@@ -169,7 +169,7 @@ tape( 'the function evaluates the logpdf for `x` given large variance ( = large
 		y = logpdf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.js
index dcf6567be271..05f0658580cf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the expected value of a lognormal distribution', fun
 		y = mean( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.native.js
index 5eaf0c057a65..73811d813c3a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the expected value of a lognormal distribution', opt
 		y = mean( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.js
index 6a18aea885e6..fdb93c59aa5e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = median( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the median of a lognormal distribution', function te
 		y = median( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.native.js
index 9e7bbff0aa50..404e24219638 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = median( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the median of a lognormal distribution', opts, funct
 		y = median( mu[i], sigma[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.js
index 6fe3b2df5cad..2d8a342458c0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the mode of a lognormal distribution', function test
 		y = mode( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.native.js
index a2122b205e67..8829a863d0e3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the mode of a lognormal distribution', opts, functio
 		y = mode( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 18.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.factory.js
index 5cfe0a69ee76..75feb041aefc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -105,30 +105,30 @@ tape( 'if provided a nonpositive `sigma`, the created function always returns `N
 
 	pdf = factory( 0.0, 0.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, -1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -153,7 +153,7 @@ tape( 'the created function evaluates the pdf for `x` given positive `mu`', func
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 550.0 * EPS * abs( expected[ i ] );
@@ -184,7 +184,7 @@ tape( 'the created function evaluates the pdf for `x` given negative `mu`', func
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1050.0 * EPS * abs( expected[ i ] );
@@ -215,7 +215,7 @@ tape( 'the created function evaluates the pdf for `x` given large variance ( = l
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 300.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.native.js
index 5cd822ad3d65..1d792727b719 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function evaluates the pdf for `x` given positive `mu`', opts, functi
 		y = pdf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 550.0 * EPS * abs( expected[ i ] );
@@ -149,7 +149,7 @@ tape( 'the function evaluates the pdf for `x` given negative `mu`', opts, functi
 		y = pdf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1050.0 * EPS * abs( expected[ i ] );
@@ -178,7 +178,7 @@ tape( 'the function evaluates the pdf for `x` given large variance ( = large `si
 		y = pdf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 300.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.pdf.js
index f0279294ecf8..d9be18e5dd47 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -111,7 +111,7 @@ tape( 'the function evaluates the pdf for `x` given positive `mu`', function tes
 		y = pdf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 550.0 * EPS * abs( expected[ i ] );
@@ -140,7 +140,7 @@ tape( 'the function evaluates the pdf for `x` given negative `mu`', function tes
 		y = pdf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1050.0 * EPS * abs( expected[ i ] );
@@ -169,7 +169,7 @@ tape( 'the function evaluates the pdf for `x` given large variance ( = large `si
 		y = pdf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 300.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.factory.js
index 572770417512..61fc19c4bd4e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,31 +98,31 @@ tape( 'if provided a nonpositive `sigma`, the created function always returns `N
 	quantile = factory( 0.0, 0.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -146,7 +146,7 @@ tape( 'the created function evaluates the quantile for `x` when `mu` is positive
 		quantile = factory( mu[i], sigma[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
@@ -175,7 +175,7 @@ tape( 'the created function evaluates the quantile for `x` when `mu` is negative
 		quantile = factory( mu[i], sigma[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
@@ -204,7 +204,7 @@ tape( 'the created function evaluates the quantile for `x` when `sigma` is large
 		quantile = factory( mu[i], sigma[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 100.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.quantile.js
index 17a9f83e8fad..0bb26de10f3e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `mu` and `sigma`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,25 +66,25 @@ tape( 'if provided a nonpositive `sigma`, the function always returns `NaN`', fu
 	var y;
 
 	y = quantile( 2.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function evaluates the quantile for `x` when `mu` is positive', funct
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
@@ -133,7 +133,7 @@ tape( 'the function evaluates the quantile for `x` when `mu` is negative', funct
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
@@ -160,7 +160,7 @@ tape( 'the function evaluates the quantile for `x` when `sigma` is large', funct
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 100.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.js
index f812f24baa1c..42f8d6f1d88d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the skewness of a lognormal distribution', function
 		y = skewness( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.native.js
index e93fea13f9bf..fc4628dee922 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the skewness of a lognormal distribution', opts, fun
 		y = skewness( mu[i], sigma[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.js
index 38b55721de2b..b46ee95e901b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the standard deviation of a lognormal distribution',
 		y = stdev( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.native.js
index e28de422254a..782ff4a61ef6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the standard deviation of a lognormal distribution',
 		y = stdev( mu[i], sigma[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/test/test.js
index 686016fec477..017c1bad119c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains lognormal distribution functions', function test( t ) {
 	var keys = objectKeys( lognormal );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.js
index d838e572496f..dda42c59cca0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the variance of a lognormal distribution', function
 		y = variance( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.native.js
index 9dd73e6aaee6..171f986d4edc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the variance of a lognormal distribution', opts, fun
 		y = variance( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.cdf.js
index d0846365209f..20b45eaa6bc6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.cdf.js
@@ -47,30 +47,30 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 10, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 10, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a `x` equal to `+Infinity`, the function returns `1` (provided `r` and `p` are valid)', function test( t ) {
 	var y = cdf( PINF, 20, 0.5 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `r` and `p`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -10.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -1.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -79,16 +79,16 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var y;
 
 	y = cdf( 2.0, -2.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, -1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 0.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, NINF, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,16 +97,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = cdf( 2.0, 20, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 20, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 20, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function evaluates the cdf for `x` given large `r` and `p`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 80.0 * EPS * abs( expected[i] );
@@ -155,7 +155,7 @@ tape( 'the function evaluates the cdf for `x` given large `r` and small `p`', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 320.0 * EPS * abs( expected[i] );
@@ -182,7 +182,7 @@ tape( 'the function evaluates the cdf for `x` given small `r` and large `p`', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
@@ -209,7 +209,7 @@ tape( 'the function evaluates the cdf for `x` given small `r` and `p`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 80.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.factory.js
index d551a777e2c8..195a52b2ad80 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 20, 0.5 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 0.5 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 20, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	cdf = factory( 20, 0.5 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	cdf = factory( 20, 0.5 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -10.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -116,18 +116,18 @@ tape( 'if provided a `r` which is not a positive number, the created function al
 	cdf = factory( -10.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -4.0, 0.5 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, 0.5 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -139,22 +139,22 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the created functi
 	cdf = factory( 20.0, 1.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 20.0, -0.5 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 20.0, PINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 20.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -178,7 +178,7 @@ tape( 'the created function evaluates the cdf for `x` given large `r` and `p`',
 		cdf = factory( r[i], p[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 60.0 * EPS * abs( expected[i] );
@@ -207,7 +207,7 @@ tape( 'the created function evaluates the cdf for `x` given large `r` and small
 		cdf = factory( r[i], p[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 320.0 * EPS * abs( expected[i] );
@@ -236,7 +236,7 @@ tape( 'the created function evaluates the cdf for `x` given small `r` and large
 		cdf = factory( r[i], p[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
@@ -265,7 +265,7 @@ tape( 'the created function evaluates the cdf for `x` given small `r` and `p`',
 		cdf = factory( r[i], p[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 80.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.js
index 331e593a06c1..60d5269a550a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -54,13 +54,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = kurtosis( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( NINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -69,16 +69,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = kurtosis( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 20, NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 20, PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function returns the excess kurtosis of a negative binomial distribut
 	p = data.p;
 	for ( i = 0; i < r.length; i++ ) {
 		y = kurtosis( r[i], p[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.native.js
index 9c9b786e649d..395a839ce965 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -63,13 +63,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = kurtosis( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( NINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = kurtosis( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 20, NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 20, PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns the excess kurtosis of a negative binomial distribut
 	p = data.p;
 	for ( i = 0; i < r.length; i++ ) {
 		y = kurtosis( r[i], p[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.factory.js
index fd225cd77f12..2f7d11d425b4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 20, 0.5 );
-	t.equal( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpmf = factory( 20.0, 0.5 );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( NaN, 0.5 );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( 20.0, NaN );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( NaN, NaN );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( NaN, NaN );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,16 +84,16 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	logpmf = factory( 20.0, 0.5 );
 	y = logpmf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -20.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -10.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -104,16 +104,16 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	logpmf = factory( 20.0, 0.5 );
 	y = logpmf( -2.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -1.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 1.2 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -125,26 +125,26 @@ tape( 'if provided a success probability `p` outside `(0,1]`, the created functi
 	logpmf = factory( 20, 1.2 );
 
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( 20, 0.0 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( 20, -0.1 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( 20, NINF );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( 20, PINF );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -156,18 +156,18 @@ tape( 'if provided a `r` which is not a positive number, the created function al
 	logpmf = factory( -1.0, 0.5 );
 
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( -2.0, 0.5 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( NINF, 0.5 );
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -191,7 +191,7 @@ tape( 'the created function evaluates the logpmf for `x` given large `r` and `p`
 		logpmf = factory( r[i], p[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 80.0 * EPS * abs( expected[i] );
@@ -220,7 +220,7 @@ tape( 'the created function evaluates the logpmf for `x` given a large parameter
 		logpmf = factory( r[i], p[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
@@ -249,7 +249,7 @@ tape( 'the created function evaluates the logpmf for `x` given small `r` and lar
 		logpmf = factory( r[i], p[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 40.0 * EPS * abs( expected[i] );
@@ -278,7 +278,7 @@ tape( 'the created function evaluates the logpmf for `x` given small `r` and `p`
 		logpmf = factory( r[i], p[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.js
index 373f96b89f76..bb8d4629a397 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpmf` functions', function test( t ) {
-	t.equal( typeof logpmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.logpmf.js
index dada5fb46acb..0d41d65bca08 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.logpmf.js
@@ -47,42 +47,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpmf( NaN, 20.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpmf( 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpmf( 0.0, 20.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `r` and `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( NINF, 20, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -20.0, 20, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -100.0, 20, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -1.0, 20, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `r` and `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( -1.5, 20.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -0.5, 20.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 1.5, 20.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 2.5, 20.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -91,13 +91,13 @@ tape( 'if provided `r` which is not a positive number, the function returns `NaN
 	var y;
 
 	y = logpmf( 2.0, -0.5, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0, -1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 2.0, NINF, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -106,16 +106,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = logpmf( 2.0, 20, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0, 20, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 2.0, 20, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 2.0, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'the function evaluates the logpmf for `x` given large `r` and `p`', funct
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 80.0 * EPS * abs( expected[i] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the logpmf for `x` given large parameter `r` and s
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
@@ -191,7 +191,7 @@ tape( 'the function evaluates the logpmf for `x` given small `r` and large `p`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 40.0 * EPS * abs( expected[i] );
@@ -218,7 +218,7 @@ tape( 'the function evaluates the logpmf for `x` given small `r` and `p`', funct
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.js
index 159c0678246f..c0c85867185a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -54,13 +54,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = mean( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( NINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -69,16 +69,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mean( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 20, NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 20, PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function returns the mean of a negative binomial distribution', funct
 	p = data.p;
 	for ( i = 0; i < r.length; i++ ) {
 		y = mean( r[i], p[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.native.js
index 96171225756a..f8fe195f9c11 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -63,13 +63,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = mean( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( NINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mean( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 20, NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 20, PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns the mean of a negative binomial distribution', opts,
 	p = data.p;
 	for ( i = 0; i < r.length; i++ ) {
 		y = mean( r[i], p[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.factory.js
index 73963943f096..cc40f75d28e3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.factory.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -50,23 +50,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 20, 0.5 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, 0.5 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 20, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -78,18 +78,18 @@ tape( 'if provided a `r` which is not a positive number, the created function al
 	mgf = factory( -10.0, 0.5 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( -4.0, 0.5 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, 0.5 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -101,22 +101,22 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the created functi
 	mgf = factory( 20.0, 1.5 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 20.0, -0.5 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 20.0, PINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 20.0, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -127,11 +127,11 @@ tape( 'the created function returns `NaN` if provided `t >= -ln( p )`', function
 
 	mgf = factory( 10, 0.5 ); // -ln( p ) = ~0.693
 	y = mgf( 0.7 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 10, 0.2 ); // -ln( p ) = ~1.609
 	y = mgf( 1.7 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.mgf.js
index 6a76b4414bb1..6c64a34ca149 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.mgf.js
@@ -40,11 +40,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 10, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 10, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var y;
 
 	y = mgf( 2.0, -2.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, -1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 0.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, NINF, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -70,25 +70,25 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = mgf( 2.0, 20, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 20, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 20, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `t >= -ln( p )`, the function returns `NaN`', function test( t ) {
 	var y = mgf( 0.7, 10.0, 0.5 ); // -ln( p ) = ~0.693
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 1.7, 10.0, 0.2 ); // -ln( p ) = ~1.609
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.native.js
index 6c15db5b8ede..cb34a87db330 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.native.js
@@ -49,11 +49,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 10, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 10, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var y;
 
 	y = mgf( 2.0, -2.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, -1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 0.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, NINF, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,25 +79,25 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = mgf( 2.0, 20, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 20, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 20, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `t >= -ln( p )`, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( 0.7, 10.0, 0.5 ); // -ln( p ) = ~0.693
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 1.7, 10.0, 0.2 ); // -ln( p ) = ~1.609
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.js
index ec3c7bd88dc4..a5397e375c74 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -54,13 +54,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = mode( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( NINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -69,16 +69,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mode( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 20, NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 20, PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function returns the mode of a negative binomial distribution', funct
 	p = data.p;
 	for ( i = 0; i < r.length; i++ ) {
 		y = mode( r[i], p[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.native.js
index 4f48cfa15f40..1be121106754 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -63,13 +63,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = mode( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( NINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mode( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 20, NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 20, PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns the mode of a negative binomial distribution', opts,
 	p = data.p;
 	for ( i = 0; i < r.length; i++ ) {
 		y = mode( r[i], p[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.factory.js
index a4cbfe016cd0..41176c0529ff 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 20, 0.5 );
-	t.equal( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 20.0, 0.5 );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( NaN, 0.5 );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( 20.0, NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( NaN, NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( NaN, NaN );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,16 +84,16 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	pmf = factory( 20.0, 0.5 );
 	y = pmf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -20.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -10.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -104,16 +104,16 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	pmf = factory( 20.0, 0.5 );
 	y = pmf( -2.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 1.2 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -125,26 +125,26 @@ tape( 'if provided a success probability `p` outside `(0,1]`, the created functi
 	pmf = factory( 20, 1.2 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( 20, 0.0 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( 20, -0.1 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( 20, NINF );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( 20, PINF );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -156,18 +156,18 @@ tape( 'if provided a `r` which is not a positive number, the created function al
 	pmf = factory( -1.0, 0.5 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( -2.0, 0.5 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( NINF, 0.5 );
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -191,7 +191,7 @@ tape( 'the created function evaluates the pmf for `x` given large `r` and `p`',
 		pmf = factory( r[i], p[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 650.0 * EPS * abs( expected[i] );
@@ -220,7 +220,7 @@ tape( 'the created function evaluates the pmf for `x` given a large parameter `r
 		pmf = factory( r[i], p[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 450.0 * EPS * abs( expected[i] );
@@ -249,7 +249,7 @@ tape( 'the created function evaluates the pmf for `x` given small `r` and large
 		pmf = factory( r[i], p[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 80.0 * EPS * abs( expected[i] );
@@ -278,7 +278,7 @@ tape( 'the created function evaluates the pmf for `x` given small `r` and `p`',
 		pmf = factory( r[i], p[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 80.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.js
index 686bb53fea47..33c536be2daf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pmf` functions', function test( t ) {
-	t.equal( typeof pmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.pmf.js
index 6fd093179f62..2550cdf48960 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.pmf.js
@@ -47,42 +47,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( NaN, 20.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pmf( 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pmf( 0.0, 20.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `r` and `p`, the function returns `0`', function test( t ) {
 	var y = pmf( NINF, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -20.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -100.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `r` and `p`, the function returns `0`', function test( t ) {
 	var y = pmf( -1.5, 20.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -0.5, 20.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 1.5, 20.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 2.5, 20.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -91,13 +91,13 @@ tape( 'if provided `r` which is not a positive number, the function returns `NaN
 	var y;
 
 	y = pmf( 2.0, -0.5, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0, -1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 2.0, NINF, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -106,16 +106,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = pmf( 2.0, 20, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0, 20, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 2.0, 20, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 2.0, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'the function evaluates the pmf for `x` given large `r` and `p`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 650.0 * EPS * abs( expected[i] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the pmf for `x` given large parameter `r` and smal
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 450.0 * EPS * abs( expected[i] );
@@ -191,7 +191,7 @@ tape( 'the function evaluates the pmf for `x` given small `r` and large `p`', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 80.0 * EPS * abs( expected[i] );
@@ -218,7 +218,7 @@ tape( 'the function evaluates the pmf for `x` given small `r` and `p`', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 80.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.factory.js
index 3d3ce64f8c01..4bf6e4059e01 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 20.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,23 +55,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 20.0, 0.5 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 0.5 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 20.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -82,10 +82,10 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	quantile = factory( 20, 0.5 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,22 +97,22 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the created fun
 	quantile = factory( 20, -1.0 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 20, NINF );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 20, PINF );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 20, 1.5 );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -124,19 +124,19 @@ tape( 'if provided a `r` which is not a positive integer, the created function a
 	quantile = factory( -10.5, 0.5 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, 0.5 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -147,10 +147,10 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which ac
 
 	quantile = factory( 20, 0.5 );
 	y = quantile( 1.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = quantile( 0.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
@@ -171,7 +171,7 @@ tape( 'the created function evaluates the quantile for `k` given large `r` and `
 	for ( i = 0; i < k.length; i++ ) {
 		quantile = factory( r[i], p[i] );
 		y = quantile( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -192,7 +192,7 @@ tape( 'the created function evaluates the quantile for `k` given large `r` and s
 	for ( i = 0; i < k.length; i++ ) {
 		quantile = factory( r[i], p[i] );
 		y = quantile( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -213,7 +213,7 @@ tape( 'the created function evaluates the quantile for `k` given small `r` and l
 	for ( i = 0; i < k.length; i++ ) {
 		quantile = factory( r[i], p[i] );
 		y = quantile( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -234,7 +234,7 @@ tape( 'the created function evaluates the quantile for `k` given small `r` and `
 	for ( i = 0; i < k.length; i++ ) {
 		quantile = factory( r[i], p[i] );
 		y = quantile( k[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.quantile.js
index b60b1b81d3cc..492e57eaf059 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.quantile.js
@@ -45,19 +45,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 20, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 20, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `k` and a valid `r` and `p`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 20, 0.5 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 20, 0.5 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -65,13 +65,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var y;
 
 	y = quantile( 0.5, NINF, 0.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -2.0, 0.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -0.5, 0.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,16 +80,16 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the function retur
 	var y;
 
 	y = quantile( 0.5, 20, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 20, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 20, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 20, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,10 +98,10 @@ tape( 'if provided a valid `r` and `p`, the function accurately computes the 0%
 	var y;
 
 	y = quantile( 1.0, 20, 0.5 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = quantile( 0.0, 20, 0.5 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function evaluates the quantile for `x` given large parameters `r` an
 	p = highHigh.p;
 	for ( i = 0; i < k.length; i++ ) {
 		y = quantile( k[i], r[i], p[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -139,7 +139,7 @@ tape( 'the function evaluates the quantile for `x` given large parameter `r` and
 	p = highSmall.p;
 	for ( i = 0; i < k.length; i++ ) {
 		y = quantile( k[i], r[i], p[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the function evaluates the quantile for `x` given small `r` and large `p`
 	p = smallHigh.p;
 	for ( i = 0; i < k.length; i++ ) {
 		y = quantile( k[i], r[i], p[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -177,7 +177,7 @@ tape( 'the function evaluates the quantile for `x` given small `r` and `p`', fun
 	p = smallSmall.p;
 	for ( i = 0; i < k.length; i++ ) {
 		y = quantile( k[i], r[i], p[i] );
-		t.equal( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'k: '+k[i]+', r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.js
index cca099f2a96b..bc5b8769f1a2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -54,13 +54,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = skewness( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( NINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -69,16 +69,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = skewness( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 20, NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 20, PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function returns the skewness of a negative binomial distribution', f
 	p = data.p;
 	for ( i = 0; i < r.length; i++ ) {
 		y = skewness( r[i], p[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.native.js
index 3186eb85f11b..d85e15bd0912 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -63,13 +63,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = skewness( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( NINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = skewness( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 20, NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 20, PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns the skewness of a negative binomial distribution', o
 	p = data.p;
 	for ( i = 0; i < r.length; i++ ) {
 		y = skewness( r[i], p[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.js
index 1844df6d8043..303064ff2a81 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,13 +56,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = stdev( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( NINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -71,16 +71,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = stdev( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 20, NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 20, PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns the standard deviation of a negative binomial distri
 	for ( i = 0; i < r.length; i++ ) {
 		y = stdev( r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r:'+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r:'+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.native.js
index 9c3ef4bd1c6d..1fb24f323943 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,13 +65,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = stdev( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( NINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,16 +80,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = stdev( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 20, NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 20, PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the standard deviation of a negative binomial distri
 	for ( i = 0; i < r.length; i++ ) {
 		y = stdev( r[i], p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'r:'+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'r:'+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/test/test.js
index 3f551d64a20d..f3d56fe6da41 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains negative binomial distribution functions', function test( t ) {
 	var keys = objectKeys( negativeBinomial );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.js
index f8f7a6f19ca5..226c1a5275d5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -54,13 +54,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = variance( -2, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( -1, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( NINF, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -69,16 +69,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = variance( 20, -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 20, 1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 20, NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 20, PINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function returns the variance of a negative binomial distribution', f
 	p = data.p;
 	for ( i = 0; i < r.length; i++ ) {
 		y = variance( r[i], p[i] );
-		t.equal( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'r: '+r[i]+', p: '+p[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.native.js
index dbc3fef031e7..6a1088407992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 10, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided `r <= 0` or `p <= 0` or `p > 1`, the function returns `NaN`',
 	var y;
 
 	y = variance( -1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 0.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 10.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 10.0, 1.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns the variance of a negative binomial distribution', o
 	for ( i = 0; i < r.length; i++ ) {
 		y = variance( r[ i ], p[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'r: ' + r[ i ] + ', p: ' + p[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'r: ' + r[ i ] + ', p: ' + p[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.cdf.js
index b818f8304d21..62ddad344e8a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `mu` and `sigma`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', funct
 	var y;
 
 	y = cdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,13 +94,13 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to mu' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to mu' );
 
 	y = cdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than mu' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than mu' );
 
 	y = cdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than mu' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than mu' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function evaluates the cdf for `x` (given positive `mu`)', function t
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1600.0 * EPS * abs( expected[ i ] );
@@ -149,7 +149,7 @@ tape( 'the function evaluates the cdf for `x` (given large `sigma`)', function t
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1600.0 * EPS * abs( expected[ i ] );
@@ -176,7 +176,7 @@ tape( 'the function evaluates the cdf for `x` (given negative `mu`)', function t
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.factory.js
index f28d664e8b4a..464c087cac1c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `mu` and `sigma`, the function returns a function whi
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `mu` and `sigma`, the function returns a function whi
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,13 +137,13 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	cdf = factory( 2.0, 0.0 );
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to mu' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to mu' );
 
 	y = cdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than mu' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than mu' );
 
 	y = cdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than mu' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than mu' );
 
 	t.end();
 });
@@ -167,7 +167,7 @@ tape( 'the created function evaluates the cdf (given positive `mu`)', function t
 		cdf = factory( mu[i], sigma[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1600.0 * EPS * abs( expected[ i ] );
@@ -196,7 +196,7 @@ tape( 'the created function evaluates the cdf (given negative `mu`)', function t
 		cdf = factory( mu[i], sigma[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1600.0 * EPS * abs( expected[ i ] );
@@ -225,7 +225,7 @@ tape( 'the created function evaluates the cdf (given large `sigma`)', function t
 		cdf = factory( mu[i], sigma[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.native.js
index 9a33cd7b04ac..607a6ce1f407 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `mu` and `sigma`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `mu` and `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = cdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,13 +103,13 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to mu' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to mu' );
 
 	y = cdf( 3.0, 2.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than mu' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than mu' );
 
 	y = cdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than mu' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than mu' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the function evaluates the cdf for `x` (given positive `mu`)', opts, func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1600.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the function evaluates the cdf for `x` (given negative `mu`)', opts, func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1600.0 * EPS * abs( expected[ i ] );
@@ -185,7 +185,7 @@ tape( 'the function evaluates the cdf for `x` (given large `sigma`)', opts, func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 250.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.js
index 832de4f9b026..1668cf17ebb8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the differential entropy of a normal distribution',
 		y = entropy( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.native.js
index e0b9f80bff40..584bc04bfe12 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = entropy( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the differential entropy of a normal distribution',
 		y = entropy( mu[i], sigma[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.js
index 9fb74c50ce56..3841acad3b16 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the excess kurtosis of a normal distribution', funct
 		y = kurtosis( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.native.js
index a71a60e1aefc..06da10f6fac7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = kurtosis( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the excess kurtosis of a normal distribution', opts,
 		y = kurtosis( mu[i], sigma[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.factory.js
index 9cf713ff048c..58d6edc6f7e3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,23 +54,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns 0' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -104,26 +104,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	logcdf = factory( 0.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -135,19 +135,19 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	logcdf = factory( 2.0, 0.0 );
 
 	y = logcdf( PINF );
-	t.equal( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns 0' );
 
 	y = logcdf( 2.0 );
-	t.equal( y, 0, 'returns 0 for x equal to mu' );
+	t.strictEqual( y, 0, 'returns 0 for x equal to mu' );
 
 	y = logcdf( 1.0 );
-	t.equal( y, -Infinity, 'returns -Infinity' );
+	t.strictEqual( y, -Infinity, 'returns -Infinity' );
 
 	y = logcdf( NINF );
-	t.equal( y, -Infinity, 'returns -Infinity' );
+	t.strictEqual( y, -Infinity, 'returns -Infinity' );
 
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -171,7 +171,7 @@ tape( 'the created function evaluates the logcdf for `x` given parameters `mu` a
 		logcdf = factory( mu[i], sigma[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1500.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.js
index 03e50045659e..c449f931f6c1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.logcdf.js
index 453e3233a373..d817be43d57e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.logcdf.js
@@ -46,38 +46,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -85,22 +85,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', funct
 	var y;
 
 	y = logcdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,19 +109,19 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = logcdf( PINF, 2.0, 0.0 );
-	t.equal( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns 0' );
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 0, 'returns 0 for x equal to mu' );
+	t.strictEqual( y, 0, 'returns 0 for x equal to mu' );
 
 	y = logcdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( NINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function evaluates the logcdf for `x` given parameters `mu` and `sigm
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1500.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.native.js
index 1676f5a99d08..1169e318e142 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.native.js
@@ -55,38 +55,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( NaN, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -94,22 +94,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', opts,
 	var y;
 
 	y = logcdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,19 +118,19 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = logcdf( PINF, 2.0, 0.0 );
-	t.equal( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns 0' );
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( y, 0, 'returns 0 for x equal to mu' );
+	t.strictEqual( y, 0, 'returns 0 for x equal to mu' );
 
 	y = logcdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( NINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function evaluates the logcdf for `x` given parameters `mu` and `sigm
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1500.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.factory.js
index f1075daac993..5e365d23c288 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,23 +54,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -104,26 +104,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -135,19 +135,19 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	logpdf = factory( 2.0, 0.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to mu' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = logpdf( 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -171,7 +171,7 @@ tape( 'the created function evaluates the logpdf for `x` given parameters `mu` a
 		logpdf = factory( mu[i], sigma[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5300.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.logpdf.js
index bba39857f45f..cadd70415aa2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.logpdf.js
@@ -46,38 +46,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -85,22 +85,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', funct
 	var y;
 
 	y = logpdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,19 +109,19 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( y, PINF, 'returns Infinity for x equal to mu' );
+	t.strictEqual( y, PINF, 'returns Infinity for x equal to mu' );
 
 	y = logpdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( PINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( NINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function evaluates the logpdf for `x` given parameters `mu` and `sigm
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.native.js
index ef8b7a6f11b9..bd0df222b7c2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.native.js
@@ -55,38 +55,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -94,22 +94,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', opts,
 	var y;
 
 	y = logpdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,19 +118,19 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( y, PINF, 'returns Infinity for x equal to mu' );
+	t.strictEqual( y, PINF, 'returns Infinity for x equal to mu' );
 
 	y = logpdf( 1.0, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( PINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( NINF, 2.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function evaluates the logpdf for `x` given parameters `mu` and `sigm
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.js
index 33d94ad71e65..d165e9c9c411 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the expected value of a normal distribution', functi
 		y = mean( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.native.js
index 6eacd6817c8f..94b087a452ac 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mean( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the expected value of a normal distribution', opts,
 		y = mean( mu[i], sigma[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.js
index 232855fbaf8b..cd68edd06d9d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = median( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the median of a normal distribution', function test(
 		y = median( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.native.js
index d9d197f49634..c392a7c6c9b7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = median( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the median of a normal distribution', opts, function
 		y = median( mu[i], sigma[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.factory.js
index 90c67bf0b8c4..0c1d4f0e1f04 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0, 1.0 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,30 +83,30 @@ tape( 'if provided a nonpositive `sigma`, the created function always returns `N
 
 	mgf = factory( 0.0, 0.0 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0, -1.0 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the created function evaluates the MGF for `x` given positive `mu`', func
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1200.0 * EPS * abs( expected[ i ] );
@@ -162,7 +162,7 @@ tape( 'the created function evaluates the MGF for `x` given negative `mu`', func
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1050.0 * EPS * abs( expected[ i ] );
@@ -193,7 +193,7 @@ tape( 'the created function evaluates the MGF for `x` given large variance ( = l
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 700.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.mgf.js
index 47616ec2f23a..904b2aab0541 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.mgf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,25 +58,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'the function evaluates the MGF for `x` given positive `mu`', function tes
 		y = mgf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1200.0 * EPS * abs( expected[ i ] );
@@ -128,7 +128,7 @@ tape( 'the function evaluates the MGF for `x` given negative `mu`', function tes
 		y = mgf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1050.0 * EPS * abs( expected[ i ] );
@@ -157,7 +157,7 @@ tape( 'the function evaluates the MGF for `x` given large variance ( = large `si
 		y = mgf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 700.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.native.js
index 15578309ac8a..4ddc37544666 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.native.js
@@ -55,11 +55,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -67,25 +67,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -108,7 +108,7 @@ tape( 'the function evaluates the MGF for `x` given positive `mu`', opts, functi
 		y = mgf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1200.0 * EPS * abs( expected[ i ] );
@@ -137,7 +137,7 @@ tape( 'the function evaluates the MGF for `x` given negative `mu`', opts, functi
 		y = mgf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1050.0 * EPS * abs( expected[ i ] );
@@ -166,7 +166,7 @@ tape( 'the function evaluates the MGF for `x` given large variance ( = large `si
 		y = mgf( x[i], mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 700.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.js
index 3c5ffd03696f..8424a461ee81 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'the function returns the mode of a normal distribution', function test( t
 	sigma = data.sigma;
 	for ( i = 0; i < mu.length; i++ ) {
 		y = mode( mu[i], sigma[i] );
-		t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.native.js
index fcbc6c42d7a6..8e4dcfd5ed46 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mode( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -96,7 +96,7 @@ tape( 'the function returns the mode of a normal distribution', opts, function t
 	sigma = data.sigma;
 	for ( i = 0; i < mu.length; i++ ) {
 		y = mode( mu[i], sigma[i] );
-		t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.factory.js
index 3e1143a66248..7359da581c1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,23 +54,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -104,26 +104,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -135,19 +135,19 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	pdf = factory( 2.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to mu' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = pdf( 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -171,7 +171,7 @@ tape( 'the created function evaluates the pdf for `x` given parameters `mu` and
 		pdf = factory( mu[i], sigma[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu: '+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5300.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.native.js
index c3abd6245065..74228061a239 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.native.js
@@ -55,38 +55,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -94,22 +94,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', opts,
 	var y;
 
 	y = pdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,19 +118,19 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to mu' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = pdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( PINF, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NINF, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function evaluates the pdf for `x` given parameters `mu` and `sigma`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5300.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.pdf.js
index ce38ec9ca96b..946a36d434b7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.pdf.js
@@ -46,38 +46,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN, NaN, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -85,22 +85,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', funct
 	var y;
 
 	y = pdf( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,19 +109,19 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to mu' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = pdf( 1.0, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( PINF, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NINF, 2.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NaN, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function evaluates the pdf for `x` given parameters `mu` and `sigma`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5300.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.factory.js
index 3f215d8f20a5..ef51b6251811 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.factory.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -63,23 +63,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -90,10 +90,10 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -105,26 +105,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -136,16 +136,16 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	quantile = factory( 2.0, 0.0 );
 
 	y = quantile( 0.3 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 0.9 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	t.end();
 });
@@ -169,7 +169,7 @@ tape( 'the created function evaluates the quantile for `x` given parameters `mu`
 		quantile = factory( mu[i], sigma[i] );
 		y = quantile( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2100.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.native.js
index 2930d3e142e0..5ed46da4f199 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.native.js
@@ -62,19 +62,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `mu` and `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -82,22 +82,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', opts,
 	var y;
 
 	y = quantile( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -106,16 +106,16 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = quantile( 0.3, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 0.9, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 1.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	y = quantile( -0.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'the function evaluates the quantile for `x` given parameters `mu` and `si
 	for ( i = 0; i < x.length; i++ ) {
 		y = quantile( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2100.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.quantile.js
index 4e0bbd715eb7..0077bb502d10 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.quantile.js
@@ -53,19 +53,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `mu` and `sigma`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -73,22 +73,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', funct
 	var y;
 
 	y = quantile( 2.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, 0.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,16 +97,16 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = quantile( 0.3, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 0.9, 2.0, 0.0 );
-	t.equal( y, 2.0, 'returns mu for p inside [0,1]' );
+	t.strictEqual( y, 2.0, 'returns mu for p inside [0,1]' );
 
 	y = quantile( 1.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	y = quantile( -0.1, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function evaluates the quantile for `x` given parameters `mu` and `si
 	for ( i = 0; i < x.length; i++ ) {
 		y = quantile( x[i], mu[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2100.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.js
index 387e48830857..689e1ea7c258 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'the function returns the skewness of a normal distribution', function tes
 	sigma = data.sigma;
 	for ( i = 0; i < mu.length; i++ ) {
 		y = skewness( mu[i], sigma[i] );
-		t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.native.js
index d7bb5a9b751a..6d8a97171a6c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = skewness( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -96,7 +96,7 @@ tape( 'the function returns the skewness of a normal distribution', opts, functi
 	sigma = data.sigma;
 	for ( i = 0; i < mu.length; i++ ) {
 		y = skewness( mu[i], sigma[i] );
-		t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.js
index 68c61bf18ab7..ef08951b0515 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,22 +54,22 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns the standard deviation of a normal distribution', fu
 		y = stdev( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.native.js
index 7b7fa1a704fe..af044bc29c86 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = stdev( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the standard deviation of a normal distribution', op
 		y = stdev( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/test/test.js
index 8b8ca10e38ed..b03442abd4e9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains normal distribution functions', function test( t ) {
 	var keys = objectKeys( normal );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.js
index ec01fafa720f..50272fe412bb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns the variance of a normal distribution', function tes
 		y = variance( mu[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.native.js
index d99438a7cf5e..28ff25a0e2c8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = variance( 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns the variance of a normal distribution', opts, functi
 		y = variance( mu[i], sigma[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'mu:'+mu[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.cdf.js
index 3a7c76150e6f..5a52cbeb5a1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.cdf.js
@@ -46,29 +46,29 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns `1.0` if provided `+Infinity` and valid parameters', function test( t ) {
 	var y = cdf( PINF, 2.0, 2.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 0.5, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 0.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -77,25 +77,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -104,25 +104,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha` and `beta`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -171,7 +171,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha` parameter', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -198,7 +198,7 @@ tape( 'the function evaluates the cdf for `x` given large rate parameter `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.factory.js
index cbcb1ef59580..b146c3516019 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 1.0, 10.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -100.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -10.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 9.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 10.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -121,31 +121,31 @@ tape( 'if provided a nonpositive `alpha`, the created function always returns `N
 	cdf = factory( 0.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -157,31 +157,31 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	cdf = factory( 1.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -205,7 +205,7 @@ tape( 'the created function evaluates the cdf for `x` given large `alpha` and `b
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -234,7 +234,7 @@ tape( 'the created function evaluates the cdf for `x` given large `alpha` parame
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -263,7 +263,7 @@ tape( 'the created function evaluates the cdf for `x` given large `beta` paramet
 		cdf = factory( alpha[i], beta[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.native.js
index a56ca7345550..cf1a5ba64ac7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.native.js
@@ -55,29 +55,29 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns `1.0` if provided `+Infinity` and valid parameters', opts, function test( t ) {
 	var y = cdf( PINF, 2.0, 2.0 );
-	t.equal( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns 1.0' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 0.5, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( 0.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -86,25 +86,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,25 +113,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -153,7 +153,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha` and `beta`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -180,7 +180,7 @@ tape( 'the function evaluates the cdf for `x` given large `alpha` parameter', op
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -207,7 +207,7 @@ tape( 'the function evaluates the cdf for `x` given large rate parameter `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.js
index 7057a1314aec..3f60981f16f7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the differential entropy of a Pareto (Type I) distri
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.native.js
index 682cfdf4ad16..e9ba4c848577 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the differential entropy of a Pareto (Type I) distri
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.js
index 1374ac9280f6..b1c2593c403c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided `alpha <= 4`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( 4.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the excess kurtosis of a Pareto (Type I) distributio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.native.js
index 779b336bdd24..e9bdc51863cc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,28 +65,28 @@ tape( 'if provided `alpha <= 4`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = kurtosis( 4.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,19 +95,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function returns the excess kurtosis of a Pareto (Type I) distributio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.factory.js
index 75cec435c54e..02d5cb836eee 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logcdf = factory( 1.0, 10.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( -100.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( -10.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( -1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( 9.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( 10.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -121,31 +121,31 @@ tape( 'if provided a nonpositive `alpha`, the created function always returns `N
 	logcdf = factory( 0.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( -1.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, 1.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, PINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NaN );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -157,31 +157,31 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	logcdf = factory( 1.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -205,7 +205,7 @@ tape( 'the created function evaluates the logcdf for `x` given large `alpha` and
 		logcdf = factory( alpha[i], beta[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -234,7 +234,7 @@ tape( 'the created function evaluates the logcdf for `x` given large `alpha` par
 		logcdf = factory( alpha[i], beta[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -263,7 +263,7 @@ tape( 'the created function evaluates the logcdf for `x` given large `beta` para
 		logcdf = factory( alpha[i], beta[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.logcdf.js
index 12928e6f00fa..d9738f01b0fc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.logcdf.js
@@ -46,29 +46,29 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns `0.0` if provided `+Infinity` and valid parameters', function test( t ) {
 	var y = logcdf( PINF, 2.0, 2.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( 0.5, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( 0.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -77,25 +77,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -104,25 +104,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'the function evaluates the logcdf for `x` given large `alpha` and `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -171,7 +171,7 @@ tape( 'the function evaluates the logcdf for `x` given large `alpha` parameter',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -198,7 +198,7 @@ tape( 'the function evaluates the logcdf for `x` given large rate parameter `bet
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.native.js
index 827133e0288e..15e4b309ba78 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.native.js
@@ -55,29 +55,29 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'the function returns `0.0` if provided `+Infinity` and valid parameters', opts, function test( t ) {
 	var y = logcdf( PINF, 2.0, 2.0 );
-	t.equal( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0.0' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( 0.5, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logcdf( 0.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -86,25 +86,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,25 +113,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -153,7 +153,7 @@ tape( 'the function evaluates the logcdf for `x` given large `alpha` and `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -180,7 +180,7 @@ tape( 'the function evaluates the logcdf for `x` given large `alpha` parameter',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -207,7 +207,7 @@ tape( 'the function evaluates the logcdf for `x` given large rate parameter `bet
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.factory.js
index 718addbe0028..479bd1a3ccfb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided a valid `alpha` and `beta`, the function returns a function w
 
 	logpdf = factory( 1.0, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( -100.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( -1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( -0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -107,26 +107,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -138,26 +138,26 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 	logpdf = factory( -1.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -181,7 +181,7 @@ tape( 'the created function evaluates the logpdf for `x` given large `alpha` and
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -210,7 +210,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large parameter
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -239,7 +239,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large parameter
 		logpdf = factory( alpha[i], beta[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.logpdf.js
index cfdaa5c046b4..d20c0b62bbd5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.logpdf.js
@@ -46,29 +46,29 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( -100.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( -10.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( -0.5, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 0.5, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -77,22 +77,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -101,22 +101,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha` and `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -165,7 +165,7 @@ tape( 'the function evaluates the logpdf for `x` given large parameter `alpha`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -192,7 +192,7 @@ tape( 'the function evaluates the logpdf for `x` given large parameter `beta`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.native.js
index 9f7dccd42f49..d1eb546ca552 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.native.js
@@ -55,29 +55,29 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( -100.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( -10.0, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( -0.5, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( 0.5, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -86,22 +86,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -110,22 +110,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function evaluates the logpdf for `x` given large `alpha` and `beta`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5000.0 * EPS * abs( expected[ i ] );
@@ -174,7 +174,7 @@ tape( 'the function evaluates the logpdf for `x` given large parameter `alpha`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5000.0 * EPS * abs( expected[ i ] );
@@ -201,7 +201,7 @@ tape( 'the function evaluates the logpdf for `x` given large parameter `beta`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5000.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mean/test/test.js
index 98267f8df153..06b5a50ec88e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,13 +77,13 @@ tape( 'if provided `0 < alpha <= 1`, the function returns `+Infinity`', function
 	var y;
 
 	y = mean( 0.2, 2.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = mean( 0.5, 2.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = mean( 0.9, 2.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -92,19 +92,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns the mean of a Pareto (Type I) distribution', functio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mean/test/test.native.js
index 79b9420a02df..7c29abdaf3b4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mean/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 2.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,22 +63,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -87,16 +87,16 @@ tape( 'if provided `0 < alpha <= 1`, the function returns `+Infinity`', opts, fu
 	var y;
 
 	y = mean( 0.2, 2.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = mean( 0.5, 2.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = mean( 0.9, 2.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = mean( 1.0, 1.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -105,22 +105,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -140,7 +140,7 @@ tape( 'the function evaluates the mean for a Pareto Type I distribution', opts,
 	for ( i = 0; i < alpha.length; i++ ) {
 		y = mean( alpha[ i ], beta[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'alpha: ' + alpha[ i ] + ', beta: ' + beta[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'alpha: ' + alpha[ i ] + ', beta: ' + beta[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/median/test/test.js
index 2283e1627238..8c3ce7c87359 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/median/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = median( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the median of a Pareto (Type I) distribution', funct
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.js
index 0aa6de384751..b066ca2dc4cd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the mode of a Pareto (Type I) distribution', functio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.native.js
index 0d8afd024dc6..9f879088c874 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the mode of a Pareto (Type I) distribution', opts, f
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.factory.js
index 82f5beef4738..536d909adc18 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided a valid `alpha` and `beta`, the function returns a function w
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -100.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -107,26 +107,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -138,26 +138,26 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 	pdf = factory( -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -181,7 +181,7 @@ tape( 'the created function evaluates the pdf for `x` given large `alpha` and `b
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -210,7 +210,7 @@ tape( 'the created function evaluates the pdf for `x` given a large parameter `a
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -239,7 +239,7 @@ tape( 'the created function evaluates the pdf for `x` given a large parameter `b
 		pdf = factory( alpha[i], beta[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.native.js
index cbf0ec45b6af..d158fd2da663 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.native.js
@@ -56,29 +56,29 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -100.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -10.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -0.5, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 0.5, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -87,22 +87,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -111,22 +111,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -148,7 +148,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha` and `beta`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -175,7 +175,7 @@ tape( 'the function evaluates the pdf for `x` given large parameter `alpha`', op
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -202,7 +202,7 @@ tape( 'the function evaluates the pdf for `x` given large parameter `beta`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.pdf.js
index c992e93adb72..59f3789b9702 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.pdf.js
@@ -46,29 +46,29 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -100.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -10.0, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -0.5, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 0.5, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -77,22 +77,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -101,22 +101,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the function evaluates the pdf for `x` given large `alpha` and `beta`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -165,7 +165,7 @@ tape( 'the function evaluates the pdf for `x` given large parameter `alpha`', fu
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -192,7 +192,7 @@ tape( 'the function evaluates the pdf for `x` given large parameter `beta`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.factory.js
index cd92624b7d98..9aa1c535c6fd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 1.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a valid `alpha` and `beta`, the function returns a function w
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,26 +98,26 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -129,31 +129,31 @@ tape( 'if provided a nonpositive `alpha`, the created function always returns `N
 	quantile = factory( 0.0, 0.5 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -177,7 +177,7 @@ tape( 'the created function evaluates the quantile for `p` given large `alpha` a
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -206,7 +206,7 @@ tape( 'the created function evaluates the quantile for `p` given large parameter
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -235,7 +235,7 @@ tape( 'the created function evaluates the quantile for `p` given large parameter
 		quantile = factory( alpha[i], beta[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.native.js
index e972b97fae1e..bab38fb6d50c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.1, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.1, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `alpha` and `beta`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -75,25 +75,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = quantile( 0.5, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,25 +102,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -142,7 +142,7 @@ tape( 'the function evaluates the quantile for `x` given large parameters `alpha
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -169,7 +169,7 @@ tape( 'the function evaluates the quantile for `x` given large parameter `alpha`
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -196,7 +196,7 @@ tape( 'the function evaluates the quantile for `x` given large parameter `beta`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.quantile.js
index d4897b89c904..71a5ee7ae3c7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.1, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.1, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `alpha` and `beta`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,25 +66,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = quantile( 0.5, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,25 +93,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the function evaluates the quantile for `x` given large parameters `alpha
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -160,7 +160,7 @@ tape( 'the function evaluates the quantile for `x` given large parameter `alpha`
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -187,7 +187,7 @@ tape( 'the function evaluates the quantile for `x` given large parameter `beta`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.js
index 62ed91bfc5fe..ddecc88d1882 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided `alpha <= 3`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the skewness of a Pareto (Type I) distribution', fun
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.native.js
index cd868131cbde..e1b529418625 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,28 +65,28 @@ tape( 'if provided `alpha <= 3`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,19 +95,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function returns the skewness of a Pareto (Type I) distribution', opt
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.js
index 523e4fa06b38..08e2a9a4028f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,13 +77,13 @@ tape( 'if provided `0 < alpha <= 2` and `beta > 0`, the function returns `+Infin
 	var y;
 
 	y = stdev( 2.0, 2.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = stdev( 0.1, 1.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = stdev( 0.5, PINF );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	t.end();
 });
@@ -92,19 +92,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns the standard deviation of a Pareto (Type I) distribu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.native.js
index b071b6f3ce72..0b060877cef8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,13 +86,13 @@ tape( 'if provided `0 < alpha <= 2` and `beta > 0`, the function returns `+Infin
 	var y;
 
 	y = stdev( 2.0, 2.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = stdev( 0.1, 1.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = stdev( 0.5, PINF );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	t.end();
 });
@@ -101,19 +101,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the function returns the standard deviation of a Pareto (Type I) distribu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/test/test.js
index 0311f5c19ce0..ba051a49d0d0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Pareto (Type I) distribution functions', function test( t ) {
 	var keys = objectKeys( pareto1 );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.js
index f205aa39c40a..8aada0688651 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,13 +77,13 @@ tape( 'if provided `0 < alpha <= 2` and `beta > 0`, the function returns `+Infin
 	var y;
 
 	y = variance( 2.0, 2.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = variance( 0.1, 1.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = variance( 0.5, PINF );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	t.end();
 });
@@ -92,19 +92,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns the variance of a Pareto (Type I) distribution', fun
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.native.js
index daeb806743b7..f25f608795fc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,13 +86,13 @@ tape( 'if provided `0 < alpha <= 2` and `beta > 0`, the function returns `+Infin
 	var y;
 
 	y = variance( 2.0, 2.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = variance( 0.1, 1.0 );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	y = variance( 0.5, PINF );
-	t.equal( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns +Infinity' );
 
 	t.end();
 });
@@ -101,19 +101,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the function returns the variance of a Pareto (Type I) distribution', opt
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( alpha[i], beta[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'alpha: '+alpha[i]+', beta: '+beta[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.cdf.js
index 2f74737e8cf0..94b702379571 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.cdf.js
@@ -45,24 +45,24 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `lambda`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -4.0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -71,13 +71,13 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var y;
 
 	y = cdf( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function evaluates the CDF for `x` given small parameter `lambda`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -122,7 +122,7 @@ tape( 'the function evaluates the CDF for `x` given large parameter `lambda`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.factory.js
index 2c0ef47e6ee3..815f7f933f3c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.5 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a valid `lambda`, the function returns a function which retur
 
 	cdf = factory( 0.5 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -81,10 +81,10 @@ tape( 'if provided a valid `lambda`, the function returns a function which retur
 
 	cdf = factory( 0.5 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -20.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -95,21 +95,21 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the created
 
 	cdf = factory( 0.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -1.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -131,7 +131,7 @@ tape( 'the created function evaluates the CDF for `x` given small parameter `lam
 		cdf = factory( lambda[ i ] );
 		y = cdf( x[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -158,7 +158,7 @@ tape( 'the created function evaluates the CDF for `x` given large parameter `lam
 		cdf = factory( lambda[ i ] );
 		y = cdf( x[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.js
index 394217b65976..5849e2ee2751 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a `factory` method for generating CDF functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.native.js
index 0f3043d830f5..7f8a5edc70a5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.native.js
@@ -54,24 +54,24 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -4.0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -80,13 +80,13 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var y;
 
 	y = cdf( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function evaluates the CDF for `x` given small parameter `lambda`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -131,7 +131,7 @@ tape( 'the function evaluates the CDF for `x` given large parameter `lambda`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/entropy/test/test.js
index 16326ab2bcb4..ece815a2c96b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/entropy/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,10 +50,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = entropy( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'the function returns the differential entropy of a Planck distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/entropy/test/test.native.js
index 1c04a206c328..42e5183ac5bf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/entropy/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,10 +59,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = entropy( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'the function returns the differential entropy of a Planck distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.js
index e6fa6f90296f..04bb9fc710bc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -50,10 +50,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = kurtosis( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( -1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'the function returns the excess kurtosis of a Planck distribution', funct
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.native.js
index b398cec16424..a8c94cb8af72 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -59,10 +59,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = kurtosis( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( -1.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'the function returns the excess kurtosis of a Planck distribution', opts,
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.factory.js
index 441fef2169b3..5d0f4a6929b8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.5 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the returned function returns `NaN`'
 
 	logcdf = factory( 0.5 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a valid `lambda`, the function returns a function which retur
 
 	logcdf = factory( 0.5 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -81,15 +81,15 @@ tape( 'if provided a valid `lambda`, the function returns a function which retur
 
 	logcdf = factory( 0.5 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -20.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -2.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	y = logcdf( -0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -101,18 +101,18 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the returned
 	logcdf = factory( 0.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -1.5 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'the returned function evaluates the logcdf for `x` given small parameter
 		logcdf = factory( lambda[ i ] );
 		y = logcdf( x[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -161,7 +161,7 @@ tape( 'the returned function evaluates the logcdf for `x` given small parameter
 		logcdf = factory( lambda[ i ] );
 		y = logcdf( x[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.js
index fe65bdf1a764..2899e640d270 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.logcdf.js
index 4a3770dde3a6..82ac3e6b1a69 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.logcdf.js
@@ -45,27 +45,27 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -4.0, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -0.5, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -74,10 +74,10 @@ tape( 'if provided a value shape parameter `lambda` which nonpositive, the funct
 	var y;
 
 	y = logcdf( 3.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 3.0, -1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function evaluates the logcdf for `x` given small parameter `lambda`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -122,7 +122,7 @@ tape( 'the function evaluates the logcdf for `x` given large parameter `lambda`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.native.js
index 297203a82367..3ac0e452c4f8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.native.js
@@ -54,27 +54,27 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -4.0, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -0.5, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a value shape parameter `lambda` which nonpositive, the funct
 	var y;
 
 	y = logcdf( 3.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 3.0, -1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function evaluates the logcdf for `x` given small parameter `lambda`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -131,7 +131,7 @@ tape( 'the function evaluates the logcdf for `x` given large parameter `lambda`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.factory.js
index c697773630ab..acd0e81f120d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 0.5 );
-	t.equal( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the returned function returns `NaN`'
 
 	logpmf = factory( 0.5 );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logpmf = factory( 1.0 );
 	y = logpmf( PINF );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -81,10 +81,10 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logpmf = factory( 0.4 );
 	y = logpmf( -4.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.0 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -95,19 +95,19 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logpmf = factory( 0.4 );
 	y = logpmf( 1.3 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 1.4 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 3.2 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 4.8 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.2 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -119,18 +119,18 @@ tape( 'if provided a `lambda` which is nonpositive, the returned function always
 	logpmf = factory( 0.0 );
 
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( -1.5 );
 
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the returned function evaluates the logpmf for `x` given small `lambda`',
 		logpmf = factory( lambda[ i ] );
 		y = logpmf( x[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[i], 'x: '+x[ i ]+'. lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[i], 'x: '+x[ i ]+'. lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -179,7 +179,7 @@ tape( 'the returned function evaluates the logpmf for `x` given large `lambda`',
 		logpmf = factory( lambda[ i ] );
 		y = logpmf( x[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[i], 'x: '+x[ i ]+'. lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[i], 'x: '+x[ i ]+'. lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.js
index 5d2d6e2f6a68..3adfbfd410c7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpmf` functions', function test( t ) {
-	t.equal( typeof logpmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.logpmf.js
index 42721405ea14..578ca310e170 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.logpmf.js
@@ -45,34 +45,34 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpmf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( PINF, 0.01 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( -20.0, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -4.0, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( -1.3, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 2.4, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -81,10 +81,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var y;
 
 	y = logpmf( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, -1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function evaluates the logpmf for `x` given small parameter `lambda`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -129,7 +129,7 @@ tape( 'the function evaluates the logpmf for `x` given large parameter `lambda`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.native.js
index 3bb136b9e325..3f79ab371804 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.native.js
@@ -54,34 +54,34 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpmf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( PINF, 0.01 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( -20.0, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -4.0, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( -1.3, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 2.4, 0.5 );
-	t.equal( y, NINF, 'returns expected value' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -90,10 +90,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var y;
 
 	y = logpmf( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, -1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function evaluates the logpmf for `x` given small parameter `lambda`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -138,7 +138,7 @@ tape( 'the function evaluates the logpmf for `x` given large parameter `lambda`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/mean/test/test.js
index 17e25cf913ba..5b2f1626804d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/mean/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,10 +50,10 @@ tape( 'if provided a success probability `lambda` which is nonpositive, the func
 	var v;
 
 	v = mean( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'the function returns the mean of a Planck distribution', function test( t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/mean/test/test.native.js
index 7481e274a0cc..200d3fe52336 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/mean/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,10 +59,10 @@ tape( 'if provided a success probability `lambda` which is nonpositive, the func
 	var v;
 
 	v = mean( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'the function returns the mean of a Planck distribution', opts, function t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/median/test/test.js
index 7f7ad9d77436..0e0e253c9de6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/median/test/test.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -48,10 +48,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = median( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( -1.1 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,7 +66,7 @@ tape( 'the function returns the median of a Planck distribution', function test(
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( lambda[ i ] );
-		t.equal( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/median/test/test.native.js
index 9863daf5344f..f07f1da0acd9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/median/test/test.native.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,10 +57,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = median( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( -1.1 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns the median of a Planck distribution', opts, function
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( lambda[ i ] );
-		t.equal( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.factory.js
index ba3ecad8e09e..022cb24b1b3d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.factory.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.5 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -53,11 +53,11 @@ tape( 'if provided `NaN` for any parameter, the returned function returns `NaN`'
 
 	mgf = factory( 0.5 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -68,15 +68,15 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the returned
 
 	mgf = factory( 0.0 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( -1.0 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the returned function evaluates the mgf for `x` given small parameter `la
 		mgf = factory( lambda[ i ] );
 		y = mgf( x[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -125,7 +125,7 @@ tape( 'the returned function evaluates the mgf for `x` given large parameter `la
 		mgf = factory( lambda[ i ] );
 		y = mgf( x[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.js
index 9b8d315bdad7..4e6ec27e4069 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.mgf.js
index 7869c11968a8..add69ad5df21 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.mgf.js
@@ -43,9 +43,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -53,10 +53,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var y;
 
 	y = mgf( 3.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 3.0, -0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function evaluates the mgf for `x` given small parameter `lambda`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -101,7 +101,7 @@ tape( 'the function evaluates the mgf for `x` given large parameter `lambda`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.native.js
index 1f59fb92f6f9..8aec6cad4700 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.native.js
@@ -52,9 +52,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 4.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -62,10 +62,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var y;
 
 	y = mgf( 3.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 3.0, -0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function evaluates the mgf for `x` given small parameter `lambda`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -110,7 +110,7 @@ tape( 'the function evaluates the mgf for `x` given large parameter `lambda`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/mode/test/test.js
index 1a9f3da7a9e6..3e7a5550586b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/mode/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -44,10 +44,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = mode( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -61,7 +61,7 @@ tape( 'the function returns `0.0` as the mode of a Planck distribution', functio
 
 	for ( i = 0; i < lambda.length; i++ ) {
 		y = mode( lambda[ i ] );
-		t.equal( y, 0.0, 'returns expected value' );
+		t.strictEqual( y, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/mode/test/test.native.js
index a97f9d5b7159..10facc7499f9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/mode/test/test.native.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -53,10 +53,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = mode( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'the function returns `0.0` as the mode of a Planck distribution', opts, f
 
 	for ( i = 0; i < lambda.length; i++ ) {
 		y = mode( lambda[ i ] );
-		t.equal( y, 0.0, 'returns expected value' );
+		t.strictEqual( y, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.factory.js
index 9026eb0d3ef7..61ee4ba83bf6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 0.5 );
-	t.equal( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 0.5 );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	pmf = factory( 1.0 );
 	y = pmf( PINF );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -80,10 +80,10 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	pmf = factory( 0.4 );
 	y = pmf( -4.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,19 +94,19 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	pmf = factory( 0.4 );
 	y = pmf( 1.3 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 1.4 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 3.2 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 4.8 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.2 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -118,10 +118,10 @@ tape( 'if provided a `lambda` which is nonpositive, the created function always
 	pmf = factory( -1.5 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the created function evaluates the pmf for `x` given small `lambda`', fun
 		pmf = factory( lambda[ i ] );
 		y = pmf( x[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+'. lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+'. lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -170,7 +170,7 @@ tape( 'the created function evaluates the pmf for `x` given large `lambda`', fun
 		pmf = factory( lambda[ i ] );
 		y = pmf( x[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+'. lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+'. lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.js
index bbf5e7fc9af3..8fdf76a1e04a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pmf` functions', function test( t ) {
-	t.equal( typeof pmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.native.js
index a8125dee220b..0d599351c326 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.native.js
@@ -53,40 +53,40 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pmf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( PINF, 0.01 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( -20.0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -4.0, 1.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0, 2.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( -1.3, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 2.4, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 0.5, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -95,10 +95,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var y;
 
 	y = pmf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, -1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function evaluates the pmf for `x` given small parameter `lambda`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the pmf for `x` given large parameter `lambda`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.pmf.js
index 9c4d72dd2c53..af8e637c7f4e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.pmf.js
@@ -44,40 +44,40 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `0`', function test( t ) {
 	var y = pmf( PINF, 0.01 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `lambda`, the function returns `0`', function test( t ) {
 	var y = pmf( -20.0, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -4.0, 1.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0, 2.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `lambda`, the function returns `0`', function test( t ) {
 	var y = pmf( -1.3, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 2.4, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 0.5, 0.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -86,10 +86,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var y;
 
 	y = pmf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, -1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function evaluates the pmf for `x` given small parameter `lambda`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -134,7 +134,7 @@ tape( 'the function evaluates the pmf for `x` given large parameter `lambda`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: '+x[ i ]+'. lambda:'+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.factory.js
index c2d4f8ddfa2b..5970210985ec 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.factory.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -52,11 +52,11 @@ tape( 'if provided `NaN` for any parameter, the returned function returns `NaN`'
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -67,10 +67,10 @@ tape( 'if provided a valid shape parameter `lambda`, the function returns a func
 
 	quantile = factory( 0.8 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a valid shape parameter `lambda`, the function returns a func
 
 	quantile = factory( 0.5 );
 	y = quantile( 1.0 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -93,18 +93,18 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the returned
 	quantile = factory( -1.0 );
 
 	y = quantile( 0.4 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0 );
 
 	y = quantile( 0.4 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'the returned function evaluates the quantile for `p` given small paramete
 	for ( i = 0; i < p.length; i++ ) {
 		quantile = factory( lambda[ i ] );
 		y = quantile( p[ i ] );
-		t.equal( y, expected[ i ], 'p: '+p[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'p: '+p[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -142,7 +142,7 @@ tape( 'the returned function evaluates the quantile for `p` given large paramete
 	for ( i = 0; i < p.length; i++ ) {
 		quantile = factory( lambda[ i ] );
 		y = quantile( p[ i ] );
-		t.equal( y, expected[ i ], 'p: '+p[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'p: '+p[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.js
index 6ad40b0c38e2..4e43d913089e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.native.js
index 4485a4a8bf64..97e97b213345 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.native.js
@@ -51,25 +51,25 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 2.2, 0.8 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.2, 0.8 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `1.0` for `p` and a valid `lambda`, the function returns `+Infinity`', opts, function test( t ) {
 	var y = quantile( 1.0, 0.5 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	y = quantile( 1.0, 1.5 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -77,10 +77,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var y;
 
 	y = quantile( 0.8, -1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.9, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function evaluates the quantile for `p` given small parameter `lambda
 	lambda = smallLambda.lambda;
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[ i ], lambda[ i ] );
-		t.equal( y, expected[ i ], 'p: '+p[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'p: '+p[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function evaluates the quantile for `p` given large parameter `lambda
 	lambda = largeLambda.lambda;
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[ i ], lambda[ i ] );
-		t.equal( y, expected[ i ], 'p: '+p[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'p: '+p[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.quantile.js
index a76f7130beaa..f7a0122742d3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.quantile.js
@@ -42,25 +42,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `lambda`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 2.2, 0.8 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.2, 0.8 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `1.0` for `p` and a valid `lambda`, the function returns `+Infinity`', function test( t ) {
 	var y = quantile( 1.0, 0.5 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	y = quantile( 1.0, 1.5 );
-	t.equal( y, PINF, 'returns expected value' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -68,10 +68,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var y;
 
 	y = quantile( 0.8, -1.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.9, 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function evaluates the quantile for `p` given small parameter `lambda
 	lambda = smallLambda.lambda;
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[ i ], lambda[ i ] );
-		t.equal( y, expected[ i ], 'p: '+p[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'p: '+p[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -105,7 +105,7 @@ tape( 'the function evaluates the quantile for `p` given large parameter `lambda
 	lambda = largeLambda.lambda;
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[ i ], lambda[ i ] );
-		t.equal( y, expected[ i ], 'p: '+p[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'p: '+p[ i ]+', lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/skewness/test/test.js
index 9d861efdcb00..c7d06df9f620 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/skewness/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,10 +50,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = skewness( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( -1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'the function returns the skewness of a Planck distribution', function tes
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/skewness/test/test.native.js
index f3a2c6a80d5b..597447a68175 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/skewness/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,10 +59,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = skewness( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( -1.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'the function returns the skewness of a Planck distribution', opts, functi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/stdev/test/test.js
index 497f0b5f795c..815c5d611bdb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/stdev/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,10 +50,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = stdev( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( -1.1 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -70,7 +70,7 @@ tape( 'the function returns the standard deviation of a Planck distribution', fu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/stdev/test/test.native.js
index 2bcecbe68ad5..bc494c4b94fb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/stdev/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,10 +59,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = stdev( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( -1.1 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -79,7 +79,7 @@ tape( 'the function returns the standard deviation of a Planck distribution', op
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/variance/test/test.js
index 369cb840e8d9..58ea9f4caede 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/variance/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,10 +50,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = variance( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -70,7 +70,7 @@ tape( 'the function returns the variance of a Planck distribution', function tes
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/variance/test/test.native.js
index 33395d4686b9..8b4207032eb3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/variance/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,10 +59,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = variance( 0.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -79,7 +79,7 @@ tape( 'the function returns the variance of a Planck distribution', opts, functi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[ i ]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.cdf.js
index 70b8ec7d2199..cc3fe4c850aa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.cdf.js
@@ -46,30 +46,30 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided a nonpositive number for `x` and a valid `lambda`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -10.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -2.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -78,13 +78,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,13 +93,13 @@ tape( 'if provided a `lambda` equal to `0`, the function evaluates a degenerate
 	var y;
 
 	y = cdf( 0.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = cdf( 3.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than 0' );
 
 	y = cdf( -1.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than 0' );
 
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function evaluates the cdf for `x` given small parameter `lambda`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -144,7 +144,7 @@ tape( 'the function evaluates the cdf for `x` given medium parameter `lambda`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -169,7 +169,7 @@ tape( 'the function evaluates the cdf for `x` given large parameter `lambda`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 60.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.factory.js
index f0cd36d255a0..7403dac745e6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'if provided a valid `lambda`, the function returns a function which retur
 
 	cdf = factory( 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -82,16 +82,16 @@ tape( 'if provided a valid `lambda`, the function returns a function which retur
 
 	cdf = factory( 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -100.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -2.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -103,10 +103,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	cdf = factory( -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,13 +118,13 @@ tape( 'if `lambda` equals `0`, the created function evaluates a degenerate distr
 	cdf = factory( 0.0 );
 
 	y = cdf( 0.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = cdf( 3.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than 0' );
 
 	y = cdf( -1.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than 0' );
 
 	t.end();
 });
@@ -146,7 +146,7 @@ tape( 'the created function evaluates the cdf for `x` given small parameter `lam
 		cdf = factory( lambda[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the created function evaluates the cdf for `x` given small parameter `lam
 		cdf = factory( lambda[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -200,7 +200,7 @@ tape( 'the created function evaluates the cdf for `x` given large parameter `lam
 		cdf = factory( lambda[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 60.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.native.js
index 1762a16881eb..334c115ebf88 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.native.js
@@ -49,7 +49,7 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof cdf, 'function', 'main export is a function' );
+	t.strictEqual( typeof cdf, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -57,32 +57,32 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = cdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided a nonpositive number for `x` and a valid `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -10.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -2.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -91,13 +91,13 @@ tape( 'if provided a negative `lambda`, the function returns `NaN`', opts, funct
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -106,13 +106,13 @@ tape( 'if provided a `lambda` equal to `0`, the function evaluates a degenerate
 	var y;
 
 	y = cdf( 0.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = cdf( 3.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than 0' );
 
 	y = cdf( -1.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than 0' );
 
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'the function evaluates the cdf for `x` given small parameter `lambda`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -157,7 +157,7 @@ tape( 'the function evaluates the cdf for `x` given medium parameter `lambda`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -182,7 +182,7 @@ tape( 'the function evaluates the cdf for `x` given large parameter `lambda`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 60.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/entropy/test/test.js
index 679d3a40b8fc..43b7acec9f85 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/entropy/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -63,7 +63,7 @@ tape( 'if provided a `lambda` equal to `0`, the function returns `0`', function
 	var v;
 
 	v = entropy( 0.0 );
-	t.equal( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the entropy of a Poisson distribution', function tes
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 15.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.js
index 90b295d647cb..0669c878d54e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,13 +49,13 @@ tape( 'if provided a mean parameter `lambda` that is not a positive number, the
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'the function returns the excess kurtosis of a Poisson distribution', func
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.native.js
index 03ba83662b77..09ba95e69a61 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,13 +58,13 @@ tape( 'if provided a mean parameter `lambda` that is not a positive number, the
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the excess kurtosis of a Poisson distribution', opts
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.factory.js
index 6c602d288ae8..9d42a44a5f58 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 0.5 );
-	t.equal( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpmf = factory( 0.5 );
 	y = logpmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpmf = factory( NaN );
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logpmf = factory( 1.0 );
 	y = logpmf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -82,10 +82,10 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logpmf = factory( 0.4 );
 	y = logpmf( -4.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -96,19 +96,19 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logpmf = factory( 0.4 );
 	y = logpmf( 1.3 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 1.4 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 3.2 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 4.8 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -1.2 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -120,10 +120,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	logpmf = factory( -1.0 );
 
 	y = logpmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -134,13 +134,13 @@ tape( 'if provided `lambda` equals `0`, the created function evaluates a degener
 
 	logpmf = factory( 0.0 );
 	y = logpmf( 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x equal to 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x equal to 0' );
 
 	y = logpmf( 3.0 );
-	t.equal( y, NINF, 'returns -Infinity for x greater than 0' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x greater than 0' );
 
 	y = logpmf( -1.0 );
-	t.equal( y, NINF, 'returns -Infinity for x smaller than 0' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x smaller than 0' );
 
 	t.end();
 });
@@ -162,7 +162,7 @@ tape( 'the created function evaluates the logpmf for `x` given small `lambda`',
 		logpmf = factory( lambda[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -189,7 +189,7 @@ tape( 'the function evaluates the logpmf for `x` given medium `lambda`', functio
 		logpmf = factory( lambda[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
@@ -216,7 +216,7 @@ tape( 'the function evaluates the logpmf for `x` given large `lambda`', function
 		logpmf = factory( lambda[i] );
 		y = logpmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.js
index 373f96b89f76..bb8d4629a397 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpmf` functions', function test( t ) {
-	t.equal( typeof logpmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.logpmf.js
index 6108fdc2f8ea..e2dc7a569bae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.logpmf.js
@@ -46,40 +46,40 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpmf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( PINF, 0.01 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( -20.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -4.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -1.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( -1.3, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 2.4, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 0.5, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -88,13 +88,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = logpmf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,13 +103,13 @@ tape( 'if provided `lambda` equals `0`, the function evaluates a degenerate dist
 	var y;
 
 	y = logpmf( 0.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x equal to 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x equal to 0' );
 
 	y = logpmf( 3.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity for x greater than 0' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x greater than 0' );
 
 	y = logpmf( -1.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity for x smaller than 0' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x smaller than 0' );
 
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function evaluates the logpmf for `x` given a small parameter `lambda
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -154,7 +154,7 @@ tape( 'the function evaluates the logpmf for `x` given a medium parameter `lambd
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
@@ -179,7 +179,7 @@ tape( 'the function evaluates the logpmf for `x` given a large parameter `lambda
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.native.js
index 31e5edd2ee89..15c928ffe451 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.native.js
@@ -55,40 +55,40 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpmf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( PINF, 0.01 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( -20.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -4.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( -1.0, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( -1.3, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 2.4, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpmf( 0.5, 0.5 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -97,13 +97,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', opts
 	var y;
 
 	y = logpmf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpmf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -112,13 +112,13 @@ tape( 'if provided `lambda` equals `0`, the function evaluates a degenerate dist
 	var y;
 
 	y = logpmf( 0.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x equal to 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x equal to 0' );
 
 	y = logpmf( 3.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity for x greater than 0' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x greater than 0' );
 
 	y = logpmf( -1.0, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity for x smaller than 0' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x smaller than 0' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the function evaluates the logpmf for `x` given a small parameter `lambda
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
@@ -163,7 +163,7 @@ tape( 'the function evaluates the logpmf for `x` given a medium parameter `lambd
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
@@ -188,7 +188,7 @@ tape( 'the function evaluates the logpmf for `x` given a large parameter `lambda
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpmf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.js
index bb48e31d83cb..38f65766cd4b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the expected value of a Poisson distribution', funct
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.native.js
index c415aee584d1..a8980ad2bb1d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a mean parameter `lambda` less than `0`, the function returns
 	var v;
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the expected value of a Poisson distribution', opts,
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.js
index 76b4981f44d9..4bb5bb2ea781 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -55,10 +55,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = median( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'the function returns the median of a Poisson distribution', function test
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.native.js
index 96d769692fd2..2f244ac6c119 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -64,10 +64,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = median( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -82,7 +82,7 @@ tape( 'the function returns the median of a Poisson distribution', opts, functio
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.factory.js
index f4c73461cebf..07eb209bb66b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 1.0 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -70,18 +70,18 @@ tape( 'if provided a nonpositive `lambda`, the created function always returns `
 	mgf = factory( -1.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the created function evaluates the mgf for `x` given small `lambda` value
 		mgf = factory( lambda[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = EPS * abs( expected[i] );
@@ -130,7 +130,7 @@ tape( 'the created function evaluates the mgf for `x` given medium `lambda` valu
 		mgf = factory( lambda[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = EPS * abs( expected[i] );
@@ -157,7 +157,7 @@ tape( 'the created function evaluates the mgf for `x` given large `lambda` value
 		mgf = factory( lambda[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. λ: '+lambda[i]+'. y: '+y+'. E: '+expected[i] );
 		} else {
 			delta = abs( y - expected[i] );
 			tol = EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.mgf.js
index a5b6ed07183e..b19a27afa988 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.mgf.js
@@ -47,9 +47,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -57,23 +57,23 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mgf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `t` and a valid `lambda`, the function returns `+infinity`', function test( t ) {
 	var y = mgf( PINF, 0.5 );
-	t.equal( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns +infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `t` and a valid `lambda`, the function returns `exp(-lambda)`', function test( t ) {
 	var y = mgf( NINF, 0.5 );
-	t.equal( y, exp(-0.5), 'returns exp(-lambda)' );
+	t.strictEqual( y, exp(-0.5), 'returns exp(-lambda)' );
 	t.end();
 });
 
@@ -92,7 +92,7 @@ tape( 'the function evaluates the mgf for `t` given a small `lambda`', function
 	for ( i = 0; i < values.length; i++ ) {
 		y = mgf( values[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 't: ' + values[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 't: ' + values[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -117,7 +117,7 @@ tape( 'the function evaluates the mgf for `t` given a medium `lambda`', function
 	for ( i = 0; i < values.length; i++ ) {
 		y = mgf( values[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 't: ' + values[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 't: ' + values[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -142,7 +142,7 @@ tape( 'the function evaluates the mgf for `t` given a large range `lambda`', fun
 	for ( i = 0; i < values.length; i++ ) {
 		y = mgf( values[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 't: ' + values[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 't: ' + values[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.native.js
index 4aa47ab31821..c73b02bac70b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.native.js
@@ -56,9 +56,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -66,23 +66,23 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = mgf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `t` and a valid `lambda`, the function returns `+infinity`', opts, function test( t ) {
 	var y = mgf( PINF, 0.5 );
-	t.equal( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns +infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `t` and a valid `lambda`, the function returns `exp(-lambda)`', opts, function test( t ) {
 	var y = mgf( NINF, 0.5 );
-	t.equal( y, exp(-0.5), 'returns exp(-lambda)' );
+	t.strictEqual( y, exp(-0.5), 'returns exp(-lambda)' );
 	t.end();
 });
 
@@ -101,7 +101,7 @@ tape( 'the function evaluates the mgf for `t` given a small `lambda`', opts, fun
 	for ( i = 0; i < values.length; i++ ) {
 		y = mgf( values[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 't: ' + values[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 't: ' + values[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -126,7 +126,7 @@ tape( 'the function evaluates the mgf for `t` given a medium `lambda`', opts, fu
 	for ( i = 0; i < values.length; i++ ) {
 		y = mgf( values[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 't: ' + values[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 't: ' + values[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -151,7 +151,7 @@ tape( 'the function evaluates the mgf for `t` given a large range `lambda`', opt
 	for ( i = 0; i < values.length; i++ ) {
 		y = mgf( values[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 't: ' + values[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 't: ' + values[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.js
index 6d6c09924375..3dde516998b9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the mode of a Poisson distribution', function test(
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.native.js
index 8e364f54cad2..cdfacb6dd301 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the mode of a Poisson distribution', opts, function
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.factory.js
index 9fd65882158f..5ae219cffbaf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 0.5 );
-	t.equal( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 0.5 );
 	y = pmf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pmf = factory( NaN );
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	pmf = factory( 1.0 );
 	y = pmf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -81,10 +81,10 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	pmf = factory( 0.4 );
 	y = pmf( -4.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -95,19 +95,19 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	pmf = factory( 0.4 );
 	y = pmf( 1.3 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 1.4 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 3.2 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 4.8 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.2 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -119,10 +119,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	pmf = factory( -1.0 );
 
 	y = pmf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -133,13 +133,13 @@ tape( 'if provided `lambda` equals `0`, the created function evaluates a degener
 
 	pmf = factory( 0.0 );
 	y = pmf( 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = pmf( 3.0 );
-	t.equal( y, 0.0, 'returns 0 for x greater than 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x greater than 0' );
 
 	y = pmf( -1.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than 0' );
 
 	t.end();
 });
@@ -161,7 +161,7 @@ tape( 'the created function evaluates the pmf for `x` given small `lambda`', fun
 		pmf = factory( lambda[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 280.0 * EPS * abs( expected[ i ] );
@@ -188,7 +188,7 @@ tape( 'the function evaluates the pmf for `x` given medium `lambda`', function t
 		pmf = factory( lambda[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 160.0 * EPS * abs( expected[ i ] );
@@ -215,7 +215,7 @@ tape( 'the function evaluates the pmf for `x` given large `lambda`', function te
 		pmf = factory( lambda[i] );
 		y = pmf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 160.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.js
index 686bb53fea47..33c536be2daf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pmf` functions', function test( t ) {
-	t.equal( typeof pmf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pmf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.pmf.js
index 0520fe0330f4..7580d995d0ce 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.pmf.js
@@ -46,40 +46,40 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pmf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `0`', function test( t ) {
 	var y = pmf( PINF, 0.01 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `lambda`, the function returns `0`', function test( t ) {
 	var y = pmf( -20.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -4.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( -1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `lambda`, the function returns `0`', function test( t ) {
 	var y = pmf( -1.3, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 2.4, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pmf( 0.5, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -88,13 +88,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = pmf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pmf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,13 +103,13 @@ tape( 'if provided `lambda` equals `0`, the function evaluates a degenerate dist
 	var y;
 
 	y = pmf( 0.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = pmf( 3.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x greater than 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x greater than 0' );
 
 	y = pmf( -1.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than 0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than 0' );
 
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function evaluates the pmf for `x` given a small parameter `lambda`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 280.0 * EPS * abs( expected[ i ] );
@@ -154,7 +154,7 @@ tape( 'the function evaluates the pmf for `x` given a medium parameter `lambda`'
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 160.0 * EPS * abs( expected[ i ] );
@@ -179,7 +179,7 @@ tape( 'the function evaluates the pmf for `x` given a large parameter `lambda`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = pmf( x[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 160.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.factory.js
index 2c8034c71382..62229bde2604 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.factory.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -53,11 +53,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -68,10 +68,10 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	quantile = factory( 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	quantile = factory( -1.0 );
 
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,11 +94,11 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 tape( 'if provided a finite `lambda`, the created function returns `0` for `p = 0`', function test( t ) {
 	var quantile = factory( 3.0 );
 	var y = quantile( 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	quantile = factory( 6.9 );
 	y = quantile( 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,11 +106,11 @@ tape( 'if provided a finite `lambda`, the created function returns `0` for `p =
 tape( 'if provided a finite `lambda`, the created function returns `+infinity` for `p = 1`', function test( t ) {
 	var quantile = factory( 3.0 );
 	var y = quantile( 1.0 );
-	t.equal( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns +infinity' );
 
 	quantile = factory( 6.9 );
 	y = quantile( 1.0 );
-	t.equal( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns +infinity' );
 
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the created function evaluates the quantile for `p` given small parameter
 	for ( i = 0; i < p.length; i++ ) {
 		quantile = factory( lambda[i] );
 		y = quantile( p[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -148,7 +148,7 @@ tape( 'the created function evaluates the quantile for `p` given medium paramete
 	for ( i = 0; i < p.length; i++ ) {
 		quantile = factory( lambda[i] );
 		y = quantile( p[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -167,7 +167,7 @@ tape( 'the created function evaluates the quantile for `p` given large parameter
 	for ( i = 0; i < p.length; i++ ) {
 		quantile = factory( lambda[i] );
 		y = quantile( p[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.quantile.js
index da6dc61edf2c..d1ea31a328b3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.quantile.js
@@ -44,33 +44,33 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `lambda`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 2.2, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.2, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'if provided `p = 0` and a finite `lambda`, the function returns `0`', function test( t ) {
 	var y = quantile( 0.0, 3.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	y = quantile( 0.0, 6.9 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `p = 1` and a finite `lambda`, the function returns `+infinity`', function test( t ) {
 	var y = quantile( 1.0, 3.0 );
-	t.equal( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns +infinity' );
 	y = quantile( 1.0, 6.9 );
-	t.equal( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns +infinity' );
 	t.end();
 });
 
@@ -78,13 +78,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = quantile( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,13 +93,13 @@ tape( 'if provided a `lambda` equal to `0`, the function always returns `0`', fu
 	var y;
 
 	y = quantile( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 3.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 5.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function evaluates the quantile for `p` given small parameter `lambda
 	lambda = smallMean.lambda;
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], lambda[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the function evaluates the quantile for `p` given medium parameter `lambd
 	lambda = mediumMean.lambda;
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], lambda[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -150,7 +150,7 @@ tape( 'the function evaluates the quantile for `p` given large parameter `lambda
 	lambda = largeMean.lambda;
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], lambda[i] );
-		t.equal( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.js
index 5c4ee2ad328e..61ca047f4169 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,13 +49,13 @@ tape( 'if provided a mean parameter `lambda` that is not a positive number, the
 	var v;
 
 	v = skewness( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'the function returns the skewness of a Poisson distribution', function te
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.native.js
index 2bab427866f0..94ce5cea0920 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,13 +58,13 @@ tape( 'if provided a mean parameter `lambda` that is not a positive number, the
 	var v;
 
 	v = skewness( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the skewness of a Poisson distribution', opts, funct
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.js
index c8767dbb16d0..f81a9134019f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a mean parameter `lambda` that is a negative number, the func
 	var v;
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the standard deviation of a Poisson distribution', f
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.native.js
index 1e20635e9c3b..c6783692c941 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a mean parameter `lambda` that is a negative number, the func
 	var v;
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the standard deviation of a Poisson distribution', o
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/test/test.js
index 1d22bace44f3..8ca0e3a9382c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Poisson distribution functions', function test( t ) {
 	var keys = objectKeys( poisson );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.js
index c3791039770a..15bd87226997 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the variance of a Poisson distribution', function te
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.native.js
index 1d099312f0a2..7ba7e73ab7ac 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the variance of a Poisson distribution', opts, funct
 	lambda = data.lambda;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( lambda[i] );
-		t.equal( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.cdf.js
index 19b06f8ce2f0..2ade7edb1477 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.cdf.js
@@ -46,21 +46,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -68,10 +68,10 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', function tes
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,13 +80,13 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = cdf( 0.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0.0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0.0' );
 
 	y = cdf( 3.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than 0.0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than 0.0' );
 
 	y = cdf( -0.2, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than 0.0' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function evaluates the cdf for `x` given small scale parameter `sigma
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -131,7 +131,7 @@ tape( 'the function evaluates the cdf for `x` given medium scale parameter `sigm
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -156,7 +156,7 @@ tape( 'the function evaluates the cdf for `x` given large scale parameter `sigma
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.factory.js
index 5b2c2c5e143c..7b1d318e654d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.5 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	cdf = factory( 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -82,7 +82,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	cdf = factory( 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,14 +94,14 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	cdf = factory( -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,13 +113,13 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	cdf = factory( 0.0 );
 
 	y = cdf( 0.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0.0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0.0' );
 
 	y = cdf( 1.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than 0.0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than 0.0' );
 
 	y = cdf( -0.2, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than 0.0' );
 
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the created function evaluates the cdf for `x` given small scale paramete
 		cdf = factory( sigma[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -168,7 +168,7 @@ tape( 'the created function evaluates the cdf for `x` given medium scale paramet
 		cdf = factory( sigma[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -195,7 +195,7 @@ tape( 'the created function evaluates the cdf for `x` given large scale paramete
 		cdf = factory( sigma[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.native.js
index 173ab51f4cd4..f26acaea931e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.native.js
@@ -55,21 +55,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -77,10 +77,10 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,13 +89,13 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = cdf( 0.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x equal to 0.0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0.0' );
 
 	y = cdf( 3.0, 0.0 );
-	t.equal( y, 1.0, 'returns 1 for x greater than 0.0' );
+	t.strictEqual( y, 1.0, 'returns 1 for x greater than 0.0' );
 
 	y = cdf( -0.2, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x smaller than 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x smaller than 0.0' );
 
 	t.end();
 });
@@ -115,7 +115,7 @@ tape( 'the function evaluates the cdf for `x` given small scale parameter `sigma
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -140,7 +140,7 @@ tape( 'the function evaluates the cdf for `x` given medium scale parameter `sigm
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -165,7 +165,7 @@ tape( 'the function evaluates the cdf for `x` given large scale parameter `sigma
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.js
index 0d47fc531bd6..3b3153e968c7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = entropy( NaN );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -51,13 +51,13 @@ tape( 'if provided a scale `sigma` that is not a positive number, the function r
 	var sigma;
 
 	sigma = entropy( 0.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = entropy( -1.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = entropy( NINF );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns the differential entropy of a Rayleigh distribution'
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'sigma:'+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'sigma:'+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.native.js
index 0996f59f3347..5bb6fe9ca323 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var sigma = entropy( NaN );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,13 +60,13 @@ tape( 'if provided a scale `sigma` that is not a positive number, the function r
 	var sigma;
 
 	sigma = entropy( 0.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = entropy( -1.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = entropy( NINF );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'the function returns the differential entropy of a Rayleigh distribution'
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'sigma:'+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'sigma:'+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.js
index f3dd8710878b..00c8fd1e4b6f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = kurtosis( NaN );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = kurtosis( -1.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = kurtosis( NINF );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the excess kurtosis of a Rayleigh distribution', fun
 	sigma = data.sigma;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( sigma[i] );
-		t.equal( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.native.js
index dbbe85c98002..4f5359ba00cc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var sigma = kurtosis( NaN );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = kurtosis( -1.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = kurtosis( NINF );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the excess kurtosis of a Rayleigh distribution', opt
 	sigma = data.sigma;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( sigma[i] );
-		t.equal( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.factory.js
index def891f51e74..ade770b89247 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.5 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	logcdf = factory( 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -82,7 +82,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	logcdf = factory( 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -94,14 +94,14 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	logcdf = factory( -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,13 +113,13 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	logcdf = factory( 0.0 );
 
 	y = logcdf( 0.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x equal to 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x equal to 0.0' );
 
 	y = logcdf( 1.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x greater than 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x greater than 0.0' );
 
 	y = logcdf( -0.2, 0.0 );
-	t.equal( y, NINF, 'returns NINF for x smaller than 0.0' );
+	t.strictEqual( y, NINF, 'returns NINF for x smaller than 0.0' );
 
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the created function evaluates the logcdf for `x` given small scale param
 		logcdf = factory( sigma[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -168,7 +168,7 @@ tape( 'the created function evaluates the logcdf for `x` given medium scale para
 		logcdf = factory( sigma[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -195,7 +195,7 @@ tape( 'the created function evaluates the logcdf for `x` given large scale param
 		logcdf = factory( sigma[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.logcdf.js
index 301f7c6c9b8c..2db379558b38 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.logcdf.js
@@ -46,21 +46,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -68,10 +68,10 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', function tes
 	var y;
 
 	y = logcdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,13 +80,13 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = logcdf( 0.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x equal to 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x equal to 0.0' );
 
 	y = logcdf( 3.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x greater than 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x greater than 0.0' );
 
 	y = logcdf( -0.2, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity for x smaller than 0.0' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x smaller than 0.0' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function evaluates the logcdf for `x` given small scale parameter `si
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -131,7 +131,7 @@ tape( 'the function evaluates the logcdf for `x` given medium scale parameter `s
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -156,7 +156,7 @@ tape( 'the function evaluates the logcdf for `x` given large scale parameter `si
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.native.js
index 0bd9eb97483d..0754c1ae1bff 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.native.js
@@ -55,21 +55,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -77,10 +77,10 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = logcdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,13 +89,13 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = logcdf( 0.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x equal to 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x equal to 0.0' );
 
 	y = logcdf( 3.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for x greater than 0.0' );
+	t.strictEqual( y, 0.0, 'returns 0 for x greater than 0.0' );
 
 	y = logcdf( -0.2, 0.0 );
-	t.equal( y, NINF, 'returns -Infinity for x smaller than 0.0' );
+	t.strictEqual( y, NINF, 'returns -Infinity for x smaller than 0.0' );
 
 	t.end();
 });
@@ -115,7 +115,7 @@ tape( 'the function evaluates the logcdf for `x` given small scale parameter `si
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -140,7 +140,7 @@ tape( 'the function evaluates the logcdf for `x` given medium scale parameter `s
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -165,7 +165,7 @@ tape( 'the function evaluates the logcdf for `x` given large scale parameter `si
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.factory.js
index 776550c63e82..4371ee9c7572 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	logpdf = factory( 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -82,7 +82,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -94,10 +94,10 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	logpdf = factory( -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,19 +109,19 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	logpdf = factory( 0.0 );
 
 	y = logpdf( 0.0 );
-	t.equal( y, PINF, 'returns +Infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +Infinity for x equal to 0' );
 
 	y = logpdf( 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'the created function evaluates the logpdf for `x` given small scale param
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 15.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the created function evaluates the logpdf for `x` given medium scale para
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -202,7 +202,7 @@ tape( 'the created function evaluates the logpdf for `x` given large scale param
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.logpdf.js
index 34257add57a2..3d49e7051e76 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.logpdf.js
@@ -46,21 +46,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -68,13 +68,13 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', function tes
 	var y;
 
 	y = logpdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided `sigma` equal to `0`, the function evaluates a degenerate dis
 	var y;
 
 	y = logpdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = logpdf( 1.0, 0.0 );
-	t.equal( y, NINF, 'returns -infinity ' );
+	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( PINF, 0.0 );
-	t.equal( y, NINF, 'returns -infinity ' );
+	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( NINF, 0.0 );
-	t.equal( y, NINF, 'returns -infinity ' );
+	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function evaluates the logpdf for `x` given small scale parameter `si
 		y = logpdf( x[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 15.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the logpdf for `x` given medium scale parameter `s
 		y = logpdf( x[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -170,7 +170,7 @@ tape( 'the function evaluates the logpdf for `x` given large scale parameter `si
 		y = logpdf( x[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.native.js
index 38f8758d2c0c..6cbd40eebbe7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.native.js
@@ -55,21 +55,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -77,13 +77,13 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = logpdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -92,19 +92,19 @@ tape( 'if provided `sigma` equal to `0`, the function evaluates a degenerate dis
 	var y;
 
 	y = logpdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = logpdf( 1.0, 0.0 );
-	t.equal( y, NINF, 'returns -infinity ' );
+	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( PINF, 0.0 );
-	t.equal( y, NINF, 'returns -infinity ' );
+	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( NINF, 0.0 );
-	t.equal( y, NINF, 'returns -infinity ' );
+	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function evaluates the logpdf for `x` given small scale parameter `si
 		y = logpdf( x[i], sigma[i] );
 		if ( expected[i] !== null) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 15.0 * EPS * abs( expected[ i ] );
@@ -152,7 +152,7 @@ tape( 'the function evaluates the logpdf for `x` given medium scale parameter `s
 		y = logpdf( x[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -179,7 +179,7 @@ tape( 'the function evaluates the logpdf for `x` given large scale parameter `si
 		y = logpdf( x[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.js
index 1dc344cf5f44..c43cbb277c2e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var v;
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the expected value of a Rayleigh distribution', func
 	sigma = data.sigma;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( sigma[i] );
-		t.equal( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.native.js
index 8f2eca3606d1..eeed71601bee 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.native.js
@@ -50,16 +50,16 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var mu = mean( NaN );
-	t.equal( isnan( mu ), true, 'returns NaN' );
+	t.strictEqual( isnan( mu ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a scale `sigma` that is not a nonnegative number, the function returns `NaN`', opts, function test( t ) {
 	var mu = mean( -1.0 );
-	t.equal( isnan( mu ), true, 'returns NaN' );
+	t.strictEqual( isnan( mu ), true, 'returns NaN' );
 
 	mu = mean( NINF );
-	t.equal( isnan( mu ), true, 'returns NaN' );
+	t.strictEqual( isnan( mu ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns the expected value of a Rayleigh distribution', opts
 	sigma = data.sigma;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( sigma[i] );
-		t.equal( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.js
index 93e625e0ab75..fd9febf8fb27 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = median( NaN );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = median( -1.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = median( NINF );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the median of a Rayleigh distribution', function tes
 	sigma = data.sigma;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( sigma[i] );
-		t.equal( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.native.js
index 91d43670c030..771b504cf9ab 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var result = median( NaN );
-	t.equal( isnan( result ), true, 'returns NaN' );
+	t.strictEqual( isnan( result ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var result;
 
 	result = median( -1.0 );
-	t.equal( isnan( result ), true, 'returns NaN' );
+	t.strictEqual( isnan( result ), true, 'returns NaN' );
 
 	result = median( NINF );
-	t.equal( isnan( result ), true, 'returns NaN' );
+	t.strictEqual( isnan( result ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the median of a Rayleigh distribution', opts, functi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.factory.js
index ea38850139ac..abc68a8cae91 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.factory.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 2.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -48,11 +48,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.5 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -64,14 +64,14 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	mgf = factory( -1.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.mgf.js
index 9f1b1b64799d..fc24b61ab4fd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.mgf.js
@@ -38,9 +38,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -48,10 +48,10 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', function tes
 	var y;
 
 	y = mgf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.native.js
index 7bbef9d732a4..ece71463fb29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.native.js
@@ -47,9 +47,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -57,10 +57,10 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = mgf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.js
index 39c2f23b04a9..864ed7b7a6bf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = mode( NaN );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = mode( -1.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = mode( NINF );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the mode of a Rayleigh distribution', function test(
 	sigma = data.sigma;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( sigma[i] );
-		t.equal( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.native.js
index db45163038b5..87d365b09ec4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var sigma = mode( NaN );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = mode( -1.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = mode( NINF );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the mode of a Rayleigh distribution', opts, function
 	sigma = data.sigma;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( sigma[i] );
-		t.equal( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.factory.js
index 4b4dd1e26626..5eae03a27332 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	pdf = factory( 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -82,7 +82,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	pdf = factory( 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,10 +94,10 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	pdf = factory( -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,19 +109,19 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	pdf = factory( 0.0 );
 
 	y = pdf( 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'the created function evaluates the pdf for `x` given small scale paramete
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the created function evaluates the pdf for `x` given medium scale paramet
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -202,7 +202,7 @@ tape( 'the created function evaluates the pdf for `x` given large scale paramete
 		y = pdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.native.js
index 6c71091b7402..698fac18b071 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.native.js
@@ -55,21 +55,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -77,13 +77,13 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -92,19 +92,19 @@ tape( 'if provided `sigma` equal to `0`, the function evaluates a degenerate dis
 	var y;
 
 	y = pdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 1.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( PINF, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NINF, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function evaluates the pdf for `x` given small scale parameter `sigma
 		y = pdf( x[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -152,7 +152,7 @@ tape( 'the function evaluates the pdf for `x` given medium scale parameter `sigm
 		y = pdf( x[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -179,7 +179,7 @@ tape( 'the function evaluates the pdf for `x` given large scale parameter `sigma
 		y = pdf( x[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.pdf.js
index 717e2bb743e7..24455f41e624 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.pdf.js
@@ -46,21 +46,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -68,13 +68,13 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', function tes
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided `sigma` equal to `0`, the function evaluates a degenerate dis
 	var y;
 
 	y = pdf( 0.0, 0.0 );
-	t.equal( y, PINF, 'returns +infinity for x equal to 0' );
+	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 1.0, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( PINF, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NINF, 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function evaluates the pdf for `x` given small scale parameter `sigma
 		y = pdf( x[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the pdf for `x` given medium scale parameter `sigm
 		y = pdf( x[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
@@ -170,7 +170,7 @@ tape( 'the function evaluates the pdf for `x` given large scale parameter `sigma
 		y = pdf( x[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.factory.js
index beb256ef75ba..b3132862e666 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -70,10 +70,10 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	quantile = factory( 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,14 +85,14 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	quantile = factory( -1.0 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -104,16 +104,16 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	quantile = factory( 0.0 );
 
 	y = quantile( 0.3 );
-	t.equal( y, 0.0, 'returns 0 for p inside [0,1]' );
+	t.strictEqual( y, 0.0, 'returns 0 for p inside [0,1]' );
 
 	y = quantile( 0.9 );
-	t.equal( y, 0.0, 'returns 0 for p inside [0,1]' );
+	t.strictEqual( y, 0.0, 'returns 0 for p inside [0,1]' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	t.end();
 });
@@ -136,7 +136,7 @@ tape( 'the created function evaluates the quantile function at `p` given small s
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -165,7 +165,7 @@ tape( 'the created function evaluates the quantile function at `p` given medium
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -194,7 +194,7 @@ tape( 'the created function evaluates the quantile function at `p` given large s
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.native.js
index fee98a0d0873..d75c69c049b2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.native.js
@@ -54,17 +54,17 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -72,13 +72,13 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = quantile( 0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,16 +87,16 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = quantile( 0.3, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for p inside [0,1]' );
+	t.strictEqual( y, 0.0, 'returns 0 for p inside [0,1]' );
 
 	y = quantile( 0.9, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for p inside [0,1]' );
+	t.strictEqual( y, 0.0, 'returns 0 for p inside [0,1]' );
 
 	y = quantile( 1.1, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	y = quantile( -0.1, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	t.end();
 });
@@ -117,7 +117,7 @@ tape( 'the function evaluates the quantile function at `p` given small scale par
 		y = quantile( p[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -144,7 +144,7 @@ tape( 'the function evaluates the quantile function at `p` given medium scale pa
 		y = quantile( p[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -171,7 +171,7 @@ tape( 'the function evaluates the quantile function at `p` given large scale par
 		y = quantile( p[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.quantile.js
index a285114667e4..7dc08f3d791a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.quantile.js
@@ -45,17 +45,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `sigma`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -63,13 +63,13 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', function tes
 	var y;
 
 	y = quantile( 0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = quantile( 0.3, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for p inside [0,1]' );
+	t.strictEqual( y, 0.0, 'returns 0 for p inside [0,1]' );
 
 	y = quantile( 0.9, 0.0 );
-	t.equal( y, 0.0, 'returns 0 for p inside [0,1]' );
+	t.strictEqual( y, 0.0, 'returns 0 for p inside [0,1]' );
 
 	y = quantile( 1.1, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	y = quantile( -0.1, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN for p outside [0,1]' );
+	t.strictEqual( isnan( y ), true, 'returns NaN for p outside [0,1]' );
 
 	t.end();
 });
@@ -108,7 +108,7 @@ tape( 'the function evaluates the quantile function at `p` given small scale par
 		y = quantile( p[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -135,7 +135,7 @@ tape( 'the function evaluates the quantile function at `p` given medium scale pa
 		y = quantile( p[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -162,7 +162,7 @@ tape( 'the function evaluates the quantile function at `p` given large scale par
 		y = quantile( p[i], sigma[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.js
index c4a50acd2cbc..aee0fe2834eb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = skewness( NaN );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a scale parameter `sigma` that is not a nonnegative number, t
 	var sigma;
 
 	sigma = skewness( -1.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = skewness( NINF );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the skewness of a Rayleigh distribution', function t
 	sigma = data.sigma;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( sigma[i] );
-		t.equal( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.native.js
index a00335d70b62..eba22e8732b6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var sigma = skewness( NaN );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a scale parameter `sigma` that is not a nonnegative number, t
 	var sigma;
 
 	sigma = skewness( -1.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = skewness( NINF );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns the skewness of a Rayleigh distribution', opts, func
 	sigma = data.sigma;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( sigma[i] );
-		t.equal( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.js
index 88bf3653bb8c..a7be77044878 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = stdev( NaN );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = stdev( -1.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = stdev( NINF );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'the function returns the standard deviation of a Rayleigh distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], ', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], ', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.native.js
index e03e602d2355..f74f9417c970 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var sigma = stdev( NaN );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = stdev( -1.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = stdev( NINF );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the standard deviation of a Rayleigh distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], ', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], ', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/test/test.js
index c3a858a50ea8..7b11c9a78a4d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Rayleigh distribution functions', function test( t ) {
 	var keys = objectKeys( rayleigh );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.js
index 586a7003c735..8683214e7e39 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = variance( NaN );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = variance( -1.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = variance( NINF );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'the function returns the variance of a Rayleigh distribution', function t
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], ', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], ', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.native.js
index cbf445343069..3030b3a08549 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var sigma = variance( NaN );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = variance( -1.0 );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	sigma = variance( NINF );
-	t.equal( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the variance of a Rayleigh distribution', opts, func
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( sigma[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], ', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], ', sigma: '+sigma[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.cdf.js
index 6f95573a2095..959a87e4acf8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.cdf.js
@@ -44,21 +44,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `n`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `n`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -66,16 +66,16 @@ tape( 'if not provided a positive integer for `n`, the function returns `NaN`',
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 6.9 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function evaluates the CDF for `x` given `n` observations', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.factory.js
index 92af0b8c0cf5..a413976c9655 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.5 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a valid `n`, the function returns a function which returns `1
 
 	cdf = factory( 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'if provided a valid `n`, the function returns a function which returns `0
 
 	cdf = factory( 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -92,17 +92,17 @@ tape( 'if not provided a positive integer for `n`, the created function always r
 	cdf = factory( -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 3.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the created function evaluates the CDF for `x` given `n` observations', f
 		cdf = factory( n[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.js
index 41fd6860aa19..3d16bb07f1d5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.factory.js
index 1515b1d0c946..181e6adbfb69 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 3.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.5 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a valid `n`, the function returns a function which returns `0
 
 	pdf = factory( 8 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'if provided a valid `n`, the function returns a function which returns `0
 
 	pdf = factory( 8 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -92,17 +92,17 @@ tape( 'if not provided a positive integer for `n`, the created function always r
 	pdf = factory( -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 3.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -110,13 +110,13 @@ tape( 'if not provided a positive integer for `n`, the created function always r
 tape( 'the created function returns `0` if provided a non-integer for `x`', function test( t ) {
 	var pdf = factory( 8 );
 	var y = pdf( 1.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 2.5 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.1 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the created function evaluates the PDF for `x` given `n` observations', f
 		pdf = factory( n[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.js
index 83ae212206e2..ea3c461f6267 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.native.js
index 498308478953..512d6936838d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.native.js
@@ -49,21 +49,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `n`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 8 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `n`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 8 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -71,27 +71,27 @@ tape( 'if not provided a positive integer for `n`, the function returns `NaN`',
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'the function returns `0` if provided a non-integer for `x`', opts, function test( t ) {
 	var y = pdf( 1.5, 8 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 
 	y = pdf( 2.5, 8 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.1, 4 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 });
 
 tape( 'the function evaluates the PDF for `x` given `n` observations', opts, function test( t ) {
@@ -109,7 +109,7 @@ tape( 'the function evaluates the PDF for `x` given `n` observations', opts, fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 80.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.pdf.js
index a851772a5ed2..566f29f578dc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.pdf.js
@@ -44,21 +44,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `n`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 8 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `n`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 8 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -66,30 +66,30 @@ tape( 'if not provided a positive integer for `n`, the function returns `NaN`',
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 6.9 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'the function returns `0` if provided a non-integer for `x`', function test( t ) {
 	var y = pdf( 1.5, 8 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 
 	y = pdf( 2.5, 8 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.1, 4 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 });
 
 tape( 'the function evaluates the PDF for `x` given `n` observations', function test( t ) {
@@ -107,7 +107,7 @@ tape( 'the function evaluates the PDF for `x` given `n` observations', function
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], n[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.factory.js
index f852f5d2a8ce..52ad8dada989 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 4 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -69,10 +69,10 @@ tape( 'if provided a valid `n`, the function returns a function which returns `N
 
 	quantile = factory( 4 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,22 +84,22 @@ tape( 'if provided a negative or non-integer `n`, the created function always re
 	quantile = factory( -1.0 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 2.3 );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF );
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the created function evaluates the quantile function at `p` given `n` obs
 		y = quantile( p[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.js
index 40b228fb3337..7903906960ac 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.quantile.js
index 2b4f870d9f96..4cfff202e6b6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.quantile.js
@@ -44,17 +44,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `n`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -62,19 +62,19 @@ tape( 'if provided a negative or non-integer `n`, the function returns `NaN`', f
 	var y;
 
 	y = quantile( 0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.8, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, 4.8 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function evaluates the quantile function at `p` given `n` observation
 		y = quantile( p[i], n[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'p: '+p[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'p: '+p[i]+', n: '+n[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/test/test.js
index 93ff3214febc..5bdd196992a9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Wilcoxon signed rank test statistic distribution functions', function test( t ) {
 	var keys = objectKeys( signrank );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.cdf.js
index 5100f5fd0e0e..df47fcbe2242 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.cdf.js
@@ -42,19 +42,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 3.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 1.0, NaN, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 1.0, 3.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `r < 2` or `v < 2`, the function returns `NaN`', function test( t ) {
 	var y = cdf( 2.5, 1.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 2.5, 3.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -72,7 +72,7 @@ tape( 'the function evaluates the cdf for `x` (matching R\'s implementation to t
 	v = R_DATA.v;
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], r[i], v[i] );
-		t.equal( roundn( y, -2 ), roundn( expected[i], -2 ), 'x: '+x[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( roundn( y, -2 ), roundn( expected[i], -2 ), 'x: '+x[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -91,7 +91,7 @@ tape( 'the function evaluates the cdf for `x` (matching Python\'s implementation
 	v = PYTHON_DATA.v;
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], r[i], v[i] );
-		t.equal( roundn( y, -2 ), roundn( expected[i], -2 ), 'x: '+x[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( roundn( y, -2 ), roundn( expected[i], -2 ), 'x: '+x[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.factory.js
index 4af5109c029f..0fc2e148c619 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 2.0, 2.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,23 +54,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 2.5, 3.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 3.0 );
 	y = cdf( 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 3.0, NaN );
 	y = cdf( 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,15 +81,15 @@ tape( 'if provided `r < 2` or `v < 2`, the created function returns `NaN`', func
 
 	cdf = factory( 1.5, 2.0 );
 	y = cdf( 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 2.0, 1.5 );
 	y = cdf( 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.5, 1.5 );
 	y = cdf( 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	cdf = factory( 3.0, 2.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -111,16 +111,16 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	cdf = factory( 3.0, 2.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -2.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = cdf( -0.1 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the created function evaluates the cdf (matching Python\'s implementation
 	for ( i = 0; i < x.length; i++ ) {
 		cdf = factory( r[ i ], v[ i ] );
 		y = cdf( x[i] );
-		t.equal( roundn( y, -2 ), roundn( expected[i], -2 ), 'x: '+x[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( roundn( y, -2 ), roundn( expected[i], -2 ), 'x: '+x[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -162,7 +162,7 @@ tape( 'the created function evaluates the cdf (matching R\'s implementation to t
 	for ( i = 0; i < x.length; i++ ) {
 		cdf = factory( r[ i ], v[ i ] );
 		y = cdf( x[i] );
-		t.equal( roundn( y, -2 ), roundn( expected[i], -2 ), 'x: '+x[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( roundn( y, -2 ), roundn( expected[i], -2 ), 'x: '+x[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.js
index 2e04ef0c9c22..45f10a1addcd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.factory.js
index 179562cafe2f..ffcd3f50150b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.factory.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 2.0, 2.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -53,23 +53,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 2.5, 3.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 3.0 );
 	y = cdf( 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 3.0, NaN );
 	y = cdf( 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -80,15 +80,15 @@ tape( 'if provided `r < 2` or `v < 2`, the created function returns `NaN`', func
 
 	cdf = factory( 1.5, 2.0 );
 	y = cdf( 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 2.0, 1.5 );
 	y = cdf( 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.5, 1.5 );
 	y = cdf( 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	cdf = factory( 3.0, 2.0 );
 	y = cdf( 1.0 );
-	t.equal( y, PINF, 'returns +infinitt' );
+	t.strictEqual( y, PINF, 'returns +infinitt' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	quantile = factory( 3.0, 2.0 );
 	y = quantile( 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -121,10 +121,10 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	quantile = factory( 3.0, 3.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -145,7 +145,7 @@ tape( 'the created function evaluates the quantile function (matching Python\'s
 	for ( i = 0; i < p.length; i++ ) {
 		quantile = factory( r[ i ], v[ i ] );
 		y = quantile( p[i] );
-		t.equal( roundn( y, -2 ), roundn( expected[i], -2 ), 'p: '+p[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( roundn( y, -2 ), roundn( expected[i], -2 ), 'p: '+p[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -166,7 +166,7 @@ tape( 'the created function evaluates the quantile function (matching R\'s imple
 	for ( i = 0; i < p.length; i++ ) {
 		quantile = factory( r[ i ], v[ i ] );
 		y = quantile( p[i] );
-		t.equal( roundn( y, -2 ), roundn( expected[i], -2 ), 'p: '+p[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( roundn( y, -2 ), roundn( expected[i], -2 ), 'p: '+p[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.js
index 183c4b4b0135..24058374fa90 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.quantile.js
index 072bce07044c..a6c3b1488bf7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.quantile.js
@@ -42,11 +42,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 3.0, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.7, NaN, 3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.7, 3.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -64,7 +64,7 @@ tape( 'the function evaluates the quantile for `p` (matching R\'s implementation
 	v = R_DATA.v;
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], r[i], v[i] );
-		t.equal( roundn( y, -2 ), roundn( expected[i], -2 ), 'p: '+p[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( roundn( y, -2 ), roundn( expected[i], -2 ), 'p: '+p[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function evaluates the quantile for `p` (matching Python\'s implement
 	v = PYTHON_DATA.v;
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], r[i], v[i] );
-		t.equal( roundn( y, -2 ), roundn( expected[i], -2 ), 'p: '+p[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( roundn( y, -2 ), roundn( expected[i], -2 ), 'p: '+p[i]+', r: '+r[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/test/test.js
index c4fbcc52965f..a6f53ed93029 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains distribution functions for the studentized range statistic', function test( t ) {
 	var keys = objectKeys( tukey );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.cdf.js
index 27ad451169d9..4bf606953287 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.cdf.js
@@ -47,21 +47,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `v`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `v`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -69,16 +69,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', functi
 	var y;
 
 	y = cdf( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function evaluates the cdf for `x` given parameter `v` (when `x` and
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -123,7 +123,7 @@ tape( 'the function evaluates the cdf for `x` given parameter `v` (when `x` is l
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -148,7 +148,7 @@ tape( 'the function evaluates the cdf for `x` given parameter `v` (when `x` is s
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the function evaluates the cdf for `x` given parameter `v` (when `x` and
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.factory.js
index 48e3c2c3deb7..a26c3edc45c2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,11 +57,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'if provided a valid `v`, the function returns a function which returns `1
 
 	cdf = factory( 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `v`, the function returns a function which returns `0
 
 	cdf = factory( 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,15 +94,15 @@ tape( 'if provided a valid `v`, the function returns a function which returns `0
 
 	cdf = factory( 1.0 );
 	y = cdf( 0.0 );
-	t.equal( y, 0.5, 'returns 0.5' );
+	t.strictEqual( y, 0.5, 'returns 0.5' );
 
 	cdf = factory( 2.5 );
 	y = cdf( 0.0 );
-	t.equal( y, 0.5, 'returns 0.5' );
+	t.strictEqual( y, 0.5, 'returns 0.5' );
 
 	cdf = factory( 5.0 );
 	y = cdf( 0.0 );
-	t.equal( y, 0.5, 'returns 0.5' );
+	t.strictEqual( y, 0.5, 'returns 0.5' );
 
 	t.end();
 });
@@ -114,15 +114,15 @@ tape( 'if provided a nonpositive `v`, the created function always returns `NaN`'
 	cdf = factory( 0.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'the created function evaluates the cdf for `x` given parameter `v` (when
 		cdf = factory( v[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -171,7 +171,7 @@ tape( 'the function evaluates the cdf for `x` given parameter `v` (when `x` is l
 		cdf = factory( v[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -198,7 +198,7 @@ tape( 'the function evaluates the cdf for `x` given parameter `v` (when `x` is s
 		cdf = factory( v[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -225,7 +225,7 @@ tape( 'the function evaluates the cdf for `x` given parameter `v` (when `x` and
 		cdf = factory( v[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 20.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.js
index e50f843fd110..77c2def96ce6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -51,13 +51,13 @@ tape( 'if provided a degrees of freedom `v` that is not a positive number, the f
 	var v;
 
 	v = entropy( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns the differential entropy of a Student\'s t distribut
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'v:'+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'v:'+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.native.js
index c45b5b91e375..b4be31a82041 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,13 +60,13 @@ tape( 'if provided a degrees of freedom `v` that is not a positive number, the f
 	var v;
 
 	v = entropy( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'the function returns the differential entropy of a Student\'s t distribut
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'v:'+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'v:'+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.js
index c88076134fd4..bd5b9bcb1dcb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -50,32 +50,32 @@ tape( 'if provided `v <= 2`, the function returns `NaN`', function test( t ) {
 	var v;
 
 	v = kurtosis( 2.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `2 < v <= 4`, the function returns `infinity`', function test( t ) {
 	var v = kurtosis( 2.5 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	v = kurtosis( 3.0 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	v = kurtosis( 4.0 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns the excess kurtosis of a Student\'s t distribution',
 	v = data.v;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( v[i] );
-		t.equal( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.native.js
index 07987ef74528..589234b43ecc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -59,32 +59,32 @@ tape( 'if provided `v <= 2`, the function returns `NaN`', opts, function test( t
 	var v;
 
 	v = kurtosis( 2.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `2 < v <= 4`, the function returns `infinity`', opts, function test( t ) {
 	var v = kurtosis( 2.5 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	v = kurtosis( 3.0 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	v = kurtosis( 4.0 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'the function returns the excess kurtosis of a Student\'s t distribution',
 	v = data.v;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( v[i] );
-		t.equal( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.factory.js
index d7a2035952da..069f255808ae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.factory.js
@@ -48,7 +48,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -58,11 +58,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'if provided a valid `v`, the function returns a function which returns `0
 
 	logcdf = factory( 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'if provided a valid `v`, the function returns a function which returns `-
 
 	logcdf = factory( 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -95,15 +95,15 @@ tape( 'if provided a valid `v`, the function returns a function which returns `l
 
 	logcdf = factory( 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( y, LN_HALF, 'returns ln(0.5)' );
+	t.strictEqual( y, LN_HALF, 'returns ln(0.5)' );
 
 	logcdf = factory( 2.5 );
 	y = logcdf( 0.0 );
-	t.equal( y, LN_HALF, 'returns ln(0.5)' );
+	t.strictEqual( y, LN_HALF, 'returns ln(0.5)' );
 
 	logcdf = factory( 5.0 );
 	y = logcdf( 0.0 );
-	t.equal( y, LN_HALF, 'returns ln(0.5)' );
+	t.strictEqual( y, LN_HALF, 'returns ln(0.5)' );
 
 	t.end();
 });
@@ -115,15 +115,15 @@ tape( 'if provided a nonpositive `v`, the created function always returns `NaN`'
 	logcdf = factory( 0.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -145,7 +145,7 @@ tape( 'the created function evaluates the logcdf for `x` given parameter `v` (wh
 		logcdf = factory( v[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -172,7 +172,7 @@ tape( 'the function evaluates the logcdf for `x` given parameter `v` (when `x` i
 		logcdf = factory( v[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -199,7 +199,7 @@ tape( 'the function evaluates the logcdf for `x` given parameter `v` (when `x` i
 		logcdf = factory( v[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -226,7 +226,7 @@ tape( 'the function evaluates the logcdf for `x` given parameter `v` (when `x` a
 		logcdf = factory( v[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.logcdf.js
index 51a84d640dfa..26b594d2b6e3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.logcdf.js
@@ -48,21 +48,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `v`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `v`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -70,13 +70,13 @@ tape( 'if provided `0.0` for `x` and a valid `v`, the function returns `ln(0.5)`
 	var y;
 
 	y = logcdf( 0.0, 1.0 );
-	t.equal( y, LN_HALF, 'returns ln(0.5)' );
+	t.strictEqual( y, LN_HALF, 'returns ln(0.5)' );
 
 	y = logcdf( 0.0, 1.0 );
-	t.equal( y, LN_HALF, 'returns ln(0.5)' );
+	t.strictEqual( y, LN_HALF, 'returns ln(0.5)' );
 
 	y = logcdf( 0.0, 1.0 );
-	t.equal( y, LN_HALF, 'returns ln(0.5)' );
+	t.strictEqual( y, LN_HALF, 'returns ln(0.5)' );
 
 	t.end();
 });
@@ -85,16 +85,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', functi
 	var y;
 
 	y = logcdf( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function evaluates the logcdf for `x` given parameter `v` (when `x` a
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -139,7 +139,7 @@ tape( 'the function evaluates the logcdf for `x` given parameter `v` (when `x` i
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the logcdf for `x` given parameter `v` (when `x` i
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -189,7 +189,7 @@ tape( 'the function evaluates the logcdf for `x` given parameter `v` (when `x` a
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 30.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.factory.js
index 7cfdbbfb43d1..67c05769aa2e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,11 +57,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'if provided a finite `v`, the function returns a function which returns `
 
 	logpdf = factory( 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `v`, the function returns a function which returns `
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'if provided `+infinity` for `v`, the function returns a function which re
 	logpdf = factory( PINF );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,15 +116,15 @@ tape( 'if provided a nonpositive `v`, the created function always returns `NaN`'
 	logpdf = factory( 0.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -146,7 +146,7 @@ tape( 'the created function evaluates the logpdf for `x` given parameter `v` (wh
 		logpdf = factory( v[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `v` (when `x` i
 		logpdf = factory( v[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -200,7 +200,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `v` (when `x` i
 		logpdf = factory( v[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
@@ -227,7 +227,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `v` (when `x` a
 		logpdf = factory( v[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.logpdf.js
index db3d8a6e95da..de4d0bb43fd0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.logpdf.js
@@ -47,21 +47,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `v`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `v`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -69,16 +69,16 @@ tape( 'if provided `Infinity` for `v`, the function returns `NaN`', function tes
 	var y;
 
 	y = logpdf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,16 +87,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', functi
 	var y;
 
 	y = logpdf( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `v` (when `x` a
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -141,7 +141,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `v` (when `x` i
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -166,7 +166,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `v` (when `x` i
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
@@ -191,7 +191,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `v` (when `x` a
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.native.js
index a4c441703071..9ce84a8a2d7a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.native.js
@@ -56,21 +56,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `v`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `v`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -78,16 +78,16 @@ tape( 'if provided `Infinity` for `v`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = logpdf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -96,16 +96,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', opts,
 	var y;
 
 	y = logpdf( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `v` (when `x` a
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -150,7 +150,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `v` (when `x` i
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -175,7 +175,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `v` (when `x` i
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
@@ -200,7 +200,7 @@ tape( 'the function evaluates the logpdf for `x` given parameter `v` (when `x` a
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.js
index 93ebc42bf60e..9df01383e313 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a degrees of freedom `v` that is not a nonnegative number, th
 	var v;
 
 	v = mean( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the expected value of a Student\'s t distribution',
 	v = data.v;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( v[i] );
-		t.equal( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.native.js
index b77b54981051..78c605af442d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.native.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -57,16 +57,16 @@ tape( 'if provided `v <= 1`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mean( 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the expected value of a Student\'s t distribution',
 	v = data.v;
 	for ( i = 0; i < v.length; i++ ) {
 		y = mean( v[ i ] );
-		t.equal( y, expected[ i ], 'v: ' + v[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'v: ' + v[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.js
index 98f584b1f292..b5660e917ff8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a degrees of freedom `v` that is not a nonnegative number, th
 	var v;
 
 	v = median( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the median of a Student\'s t distribution', function
 	v = data.v;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( v[i] );
-		t.equal( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.native.js
index 7b6ab39366ce..3e45e55a8fda 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.native.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for the parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -57,10 +57,10 @@ tape( 'if provided a negative value for `v`, the function returns `NaN`', opts,
 	var y;
 
 	y = median( -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( -0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns the median for a Student\'s t-distribution', opts, f
 		v = data.v[ i ];
 		expected = data.expected[ i ];
 		y = median( v );
-		t.equal( y, expected, 'v: ' + v + ', y: ' + y + ', expected: ' + expected );
+		t.strictEqual( y, expected, 'v: ' + v + ', y: ' + y + ', expected: ' + expected );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.js
index e8da34339896..056412163d74 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a degrees of freedom `v` that is not a nonnegative number, th
 	var v;
 
 	v = mode( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function returns the mode of a Student\'s t distribution', function t
 	v = data.v;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( v[i] );
-		t.equal( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.native.js
index 747825094e44..2d8c517ae144 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.native.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for the parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -57,10 +57,10 @@ tape( 'if provided a negative value for `v`, the function returns `NaN`', opts,
 	var y;
 
 	y = mode( -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( -0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns the mode for a Student\'s t distribution', opts, fun
 		v = data.v[ i ];
 		expected = data.expected[ i ];
 		y = mode( v );
-		t.equal( y, expected, 'v: ' + v + ', y: ' + y + ', expected: ' + expected );
+		t.strictEqual( y, expected, 'v: ' + v + ', y: ' + y + ', expected: ' + expected );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.factory.js
index 0822495d977a..781e1d3c2645 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,11 +57,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'if provided a finite `v`, the function returns a function which returns `
 
 	pdf = factory( 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `v`, the function returns a function which returns `
 
 	pdf = factory( 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'if provided `+infinity` for `v`, the function returns a function which re
 	pdf = factory( PINF );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,15 +116,15 @@ tape( 'if provided a nonpositive `v`, the created function always returns `NaN`'
 	pdf = factory( 0.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -146,7 +146,7 @@ tape( 'the created function evaluates the pdf for `x` given parameter `v` (when
 		pdf = factory( v[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `v` (when `x` is l
 		pdf = factory( v[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -200,7 +200,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `v` (when `x` is s
 		pdf = factory( v[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -227,7 +227,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `v` (when `x` and
 		pdf = factory( v[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.native.js
index 03f91356451d..b9a018c5fe37 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.native.js
@@ -56,21 +56,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `v`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `v`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -78,16 +78,16 @@ tape( 'if provided `+infinity` for `v`, the function returns `NaN`', opts, funct
 	var y;
 
 	y = pdf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -96,16 +96,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', opts,
 	var y;
 
 	y = pdf( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `v` (when `x` and
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[ i ], v[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: ' + x[ i ] + ', v: ' + v[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: ' + x[ i ] + ', v: ' + v[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -150,7 +150,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `v` (when `x` is l
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[ i ], v[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: ' + x[ i ] + ', v: ' + v[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: ' + x[ i ] + ', v: ' + v[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -175,7 +175,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `v` (when `x` is s
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[ i ], v[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: ' + x[ i ] + ', v: ' + v[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: ' + x[ i ] + ', v: ' + v[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -200,7 +200,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `v` (when `x` and
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[ i ], v[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'x: ' + x[ i ] + ', v: ' + v[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'x: ' + x[ i ] + ', v: ' + v[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.pdf.js
index a5586b1caa8c..51c81f6bdc7e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.pdf.js
@@ -47,21 +47,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `v`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `v`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -69,16 +69,16 @@ tape( 'if provided `+infinity` for `v`, the function returns `NaN`', function te
 	var y;
 
 	y = pdf( 0.0, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( PINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -87,16 +87,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', functi
 	var y;
 
 	y = pdf( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `v` (when `x` and
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -141,7 +141,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `v` (when `x` is l
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -166,7 +166,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `v` (when `x` is s
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -191,7 +191,7 @@ tape( 'the function evaluates the pdf for `x` given parameter `v` (when `x` and
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+'. v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.factory.js
index 8f08a7322f95..d424bd3ff391 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.factory.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -53,11 +53,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -68,10 +68,10 @@ tape( 'if provided a finite `v`, the function returns a function which returns `
 
 	quantile = factory( 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,15 +83,15 @@ tape( 'if provided a nonpositive `v`, the created function always returns `NaN`'
 	quantile = factory( 0.0 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( -1.0 );
 
 	y = quantile( 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the created function evaluates the quantile for `p` given small parameter
 		quantile = factory( v[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2000.0 * EPS * abs( expected[ i ] );
@@ -140,7 +140,7 @@ tape( 'the created function evaluates the quantile for `p` given large parameter
 		quantile = factory( v[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 500.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.quantile.js
index a9c6b407a7f6..9bfc2e567969 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.quantile.js
@@ -44,17 +44,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `v`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 2.2, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.2, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -62,16 +62,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', functi
 	var y;
 
 	y = quantile( 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -91,7 +91,7 @@ tape( 'the function evaluates the quantile for `p` given small parameter `v`', f
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2000.0 * EPS * abs( expected[ i ] );
@@ -116,7 +116,7 @@ tape( 'the function evaluates the quantile for `p` given large parameter `v`', f
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], v[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 500.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.js
index 2a82293c3c39..5aa02b101d54 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -49,22 +49,22 @@ tape( 'if provided a degrees of freedom `v <= 3`, the function returns `NaN`', f
 	var v;
 
 	v = skewness( 3.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 2.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns the skewness of a Student\'s t distribution', functi
 	v = data.v;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( v[i] );
-		t.equal( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.native.js
index b0d61d8f1ca1..05f9497e3968 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,22 +58,22 @@ tape( 'if provided a degrees of freedom `v <= 3`, the function returns `NaN`', o
 	var v;
 
 	v = skewness( 3.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 2.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 0.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the skewness of a Student\'s t distribution', opts,
 	v = data.v;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( v[i] );
-		t.equal( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.js
index 20e0ebd6944d..9844e6a79a1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -50,23 +50,23 @@ tape( 'if provided a degrees of freedom `v` that is not a nonnegative number, th
 	var v;
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `1 < v <= 2`, the function returns `infinity`', function test( t ) {
 	var v = stdev( 1.5 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	v = stdev( 1.1 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	v = stdev( 2.0 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the standard deviation of a Student\'s t distributio
 	v = data.v;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( v[i] );
-		t.equal( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.native.js
index 79cf3b104128..1985695ab12b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -59,23 +59,23 @@ tape( 'if provided a degrees of freedom `v` that is not a nonnegative number, th
 	var v;
 
 	v = stdev( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `1 < v <= 2`, the function returns `infinity`', opts, function test( t ) {
 	var v = stdev( 1.5 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	v = stdev( 1.1 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	v = stdev( 2.0 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns the standard deviation of a Student\'s t distributio
 	v = data.v;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( v[i] );
-		t.equal( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/test/test.js
index a77c659e4b12..084f55fb80fb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Student t distribution functions', function test( t ) {
 	var keys = objectKeys( tdist );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.js
index 4fb468247f2b..98520ffe80e2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -50,23 +50,23 @@ tape( 'if provided a degrees of freedom `v` that is not a nonnegative number, th
 	var v;
 
 	v = variance( -1.0 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( NINF );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `1 < v <= 2`, the function returns `infinity`', function test( t ) {
 	var v = variance( 1.5 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	v = variance( 1.1 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	v = variance( 2.0 );
-	t.equal( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns infinity' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the variance of a Student\'s t distribution', functi
 	v = data.v;
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( v[i] );
-		t.equal( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'v: '+v[i]+', y: '+y+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.native.js
index c33d180e3d10..9b96bcaaf04d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for the parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -60,13 +60,13 @@ tape( 'if provided `v <= 1`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = variance( 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -75,13 +75,13 @@ tape( 'if provided `1 < v <= 2`, the function returns `Infinity`', opts, functio
 	var y;
 
 	y = variance( 2.0 );
-	t.equal( y, PINF, 'returns Infinity' );
+	t.strictEqual( y, PINF, 'returns Infinity' );
 
 	y = variance( 1.5 );
-	t.equal( y, PINF, 'returns Infinity' );
+	t.strictEqual( y, PINF, 'returns Infinity' );
 
 	y = variance( 1.1 );
-	t.equal( y, PINF, 'returns Infinity' );
+	t.strictEqual( y, PINF, 'returns Infinity' );
 
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'the function evaluates the variance for a Student\'s t-distribution', opt
 	for ( i = 0; i < v.length; i++ ) {
 		y = variance( v[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'v: ' + v[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'v: ' + v[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/test/test.js
index 3a018c72cd7b..b35c66b44547 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains distribution namespaces', function test( t ) {
 	var keys = objectKeys( dist );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.cdf.js
index 51527dcac155..5f286ee0bf3e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.cdf.js
@@ -46,25 +46,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a`, `b` and `c`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0, 0.5 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a`, `b` and `c`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -72,16 +72,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = cdf( 2.0, -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -105,7 +105,7 @@ tape( 'the function evaluates the cdf for `x` given a small range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -134,7 +134,7 @@ tape( 'the function evaluates the cdf for `x` given a medium range `b - a`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -163,7 +163,7 @@ tape( 'the function evaluates the cdf for `x` given a large range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.factory.js
index b8e606e5ef47..e22ed4c14099 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0, 0.5 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,39 +56,39 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0, 0.5 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0, 0.5 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NaN, 0.5 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN, 0.5 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN, 0.5 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'if provided a valid `a`, `b` and `c`, the function returns a function whi
 
 	cdf = factory( 0.0, 1.0, 0.5 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0, 0.5 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -122,34 +122,34 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the created function
 	cdf = factory( 2.0, 1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NINF, 0.5 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF, 0.5 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF, 0.5 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -1.0, -2.0, 0.5 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -10.0, 10.0, 12.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -10.0, 10.0, -12.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -175,7 +175,7 @@ tape( 'the created function evaluates the cdf for `x` given a small range `b - a
 		cdf = factory( a[i], b[i], c[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -206,7 +206,7 @@ tape( 'the created function evaluates the cdf for `x` given a medium range `b -
 		cdf = factory( a[i], b[i], c[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -237,7 +237,7 @@ tape( 'the created function evaluates the cdf for `x` given a large range `b - a
 		cdf = factory( a[i], b[i], c[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.native.js
index 4e9409917e40..c7438ba29df2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.native.js
@@ -55,25 +55,25 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a`, `b` and `c`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0, 0.5 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a`, `b` and `c`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -81,16 +81,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = cdf( 2.0, -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function evaluates the cdf for `x` given a small range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the cdf for `x` given a medium range `b - a`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -172,7 +172,7 @@ tape( 'the function evaluates the cdf for `x` given a large range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.js
index d39e3cd8f91e..f251abf9dca7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = entropy( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the differential entropy of a triangular distributio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.native.js
index 1c59e5b56cb8..4b7a185b9d80 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = entropy( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns the differential entropy of a triangular distributio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.js
index 68b9c30b3c3a..1df20eba6f75 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = kurtosis( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the excess kurtosis of a triangular distribution', f
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.native.js
index 163f256d6d71..4453403dd334 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = kurtosis( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns the excess kurtosis of a triangular distribution', o
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.factory.js
index 41ad8d79bf43..cd95c5701670 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,39 +56,39 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0, 0.5 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0, 0.5 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, NaN, 0.5 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN, 0.5 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN, 0.5 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'if provided a valid `a`, `b` and `c`, the function returns a function whi
 
 	logcdf = factory( 0.0, 1.0, 0.5 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0.0, 1.0, 0.5 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -122,34 +122,34 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the created function
 	logcdf = factory( 2.0, 1.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, NINF, 0.5 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF, 0.5 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF, 0.5 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( -1.0, -2.0, 0.5 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( -10.0, 10.0, 12.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( -10.0, 10.0, -12.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -175,7 +175,7 @@ tape( 'the created function evaluates the logcdf for `x` given a small range `b
 		logcdf = factory( a[i], b[i], c[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -206,7 +206,7 @@ tape( 'the created function evaluates the logcdf for `x` given a medium range `b
 		logcdf = factory( a[i], b[i], c[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -237,7 +237,7 @@ tape( 'the created function evaluates the logcdf for `x` given a large range `b
 		logcdf = factory( a[i], b[i], c[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.logcdf.js
index 0e6a306c98ca..3800a4ee2330 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.logcdf.js
@@ -46,29 +46,29 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, NaN, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 1.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a`, `b` and `c`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a`, `b` and `c`, the function returns `-infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
@@ -76,16 +76,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = logcdf( 2.0, -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function evaluates the logcdf for `x` given a small range `b - a`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -138,7 +138,7 @@ tape( 'the function evaluates the logcdf for `x` given a medium range `b - a`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -167,7 +167,7 @@ tape( 'the function evaluates the logcdf for `x` given a large range `b - a`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.native.js
index 656dcee686b0..cc1f473efd83 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.native.js
@@ -55,29 +55,29 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, NaN, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 1.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a`, `b` and `c`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a`, `b` and `c`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
@@ -85,16 +85,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = logcdf( 2.0, -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function evaluates the logcdf for `x` given a small range `b - a`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -147,7 +147,7 @@ tape( 'the function evaluates the logcdf for `x` given a medium range `b - a`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
@@ -176,7 +176,7 @@ tape( 'the function evaluates the logcdf for `x` given a large range `b - a`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.factory.js
index 39f7dea1d3f0..93d6ebcecb6d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,45 +57,45 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0, 0.5 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0, 0.5 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, NaN, 0.5 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN, 0.5 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN, 0.5 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN, NaN );
 
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -106,13 +106,13 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	logpdf = factory( -10.0, 10.0, 0.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 20.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 11.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -123,13 +123,13 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	logpdf = factory( -10.0, 10.0, 0.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -100.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -11.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -141,26 +141,26 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the created function
 	logpdf = factory( 0.0, -1.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, NINF, 0.5 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF, 0.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, 10.0, 20.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, 10.0, -10.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -175,7 +175,7 @@ tape( 'if provided valid parameters, the created function returns `ln(2/(b-a))`
 	b = 2.0;
 	c = 1.5;
 	logpdf = factory( a, b, c );
-	t.equal( logpdf( c ), ln( 2.0/(b-a) ), 'returns ln(2/(b-a))' );
+	t.strictEqual( logpdf( c ), ln( 2.0/(b-a) ), 'returns ln(2/(b-a))' );
 	t.end();
 });
 
@@ -200,7 +200,7 @@ tape( 'the created function evaluates the logpdf for `x` given small range `b -
 		logpdf = factory( a[i], b[i], c[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -231,7 +231,7 @@ tape( 'the created function evaluates the logpdf for `x` given a medium range `b
 		logpdf = factory( a[i], b[i], c[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 60.0 * EPS * abs( expected[ i ] );
@@ -262,7 +262,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large range `b
 		logpdf = factory( a[i], b[i], c[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.logpdf.js
index 8a622b909e7d..e1723fecca80 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.logpdf.js
@@ -47,42 +47,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number greater than `b` for `x` and valid parameters, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 20.0, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 2.0, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 1.1, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
 
 tape( 'if provided a number smaller than `a` for `x` and valid parameters, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -20.0, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -2.0, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -0.5, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -91,16 +91,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = logpdf( 2.0, 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, 3.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, 3.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns `ln(2/(b-a))` if provided `x = c`', function test( t
 	var a = 0.0;
 	var b = 2.0;
 	var c = 1.5;
-	t.equal( logpdf( c, a, b, c ), ln( 2.0/(b-a) ), 'returns ln(2/(b-a))' );
+	t.strictEqual( logpdf( c, a, b, c ), ln( 2.0/(b-a) ), 'returns ln(2/(b-a))' );
 	t.end();
 });
 
@@ -132,7 +132,7 @@ tape( 'the function evaluates the logpdf for `x` given a small range `b - a`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -161,7 +161,7 @@ tape( 'the function evaluates the logpdf for `x` given a medium range `b - a`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 60.0 * EPS * abs( expected[ i ] );
@@ -190,7 +190,7 @@ tape( 'the function evaluates the logpdf for `x` given a large range `b - a`', f
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.native.js
index 68f5ed5a7039..81e15ccf6162 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.native.js
@@ -56,48 +56,48 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, NaN, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 1.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided a number greater than `b` for `x` and valid parameters, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 20.0, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 2.0, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( 1.1, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
 
 tape( 'if provided a number smaller than `a` for `x` and valid parameters, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -20.0, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -2.0, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	y = logpdf( -0.5, 0.0, 1.0, 0.5 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -106,16 +106,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = logpdf( 2.0, 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, 3.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, 3.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns `ln(2/(b-a))` if provided `x = c`', opts, function t
 	var a = 0.0;
 	var b = 2.0;
 	var c = 1.5;
-	t.equal( logpdf( c, a, b, c ), ln( 2.0/(b-a) ), 'returns ln(2/(b-a))' );
+	t.strictEqual( logpdf( c, a, b, c ), ln( 2.0/(b-a) ), 'returns ln(2/(b-a))' );
 	t.end();
 });
 
@@ -147,7 +147,7 @@ tape( 'the function evaluates the logpdf for `x` given a small range `b - a`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 40.0 * EPS * abs( expected[ i ] );
@@ -176,7 +176,7 @@ tape( 'the function evaluates the logpdf for `x` given a medium range `b - a`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 60.0 * EPS * abs( expected[ i ] );
@@ -205,7 +205,7 @@ tape( 'the function evaluates the logpdf for `x` given a large range `b - a`', o
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 50.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.js
index 09e18cb1b2c8..e23eb6114bdf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = mean( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the mean of a triangular distribution', function tes
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.native.js
index f0f1432a3f45..9ca692899603 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = mean( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns the mean of a triangular distribution', opts, functi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/median/test/test.js
index bcd0d1a9466c..9bb4fc9364f1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/median/test/test.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -58,16 +58,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = median( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns the median of a triangular distribution if provided
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -116,7 +116,7 @@ tape( 'the function returns the median of a triangular distribution if provided
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/median/test/test.native.js
index 5b4dad51617c..e31d0838b71c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/median/test/test.native.js
@@ -52,13 +52,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -67,16 +67,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = median( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns the median of a triangular distribution if provided
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -125,7 +125,7 @@ tape( 'the function returns the median of a triangular distribution if provided
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.factory.js
index 06e5699cc2e2..8a395901a43b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.factory.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -60,39 +60,39 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0, 1.0, 0.5 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 1.0, 0.5 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, NaN, 0.5 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, 1.0, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 1.0, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN, 0.5 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN, 0.5 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,34 +104,34 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the created function
 	mgf = factory( 2.0, 1.0, 0.5 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, NINF, 0.5 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF, NINF, 0.5 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF, 0.5 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( -1.0, -2.0, 0.5 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( -10.0, 10.0, 12.0 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( -10.0, 10.0, -12.0 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -142,11 +142,11 @@ tape( 'if provided valid `a`, `b`, and `c`, the function returns a function whic
 
 	mgf = factory( 0.0, 1.0, 0.5 );
 	y = mgf( 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	mgf = factory( -1.0, 1.0, 0.0 );
 	y = mgf( 0.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -172,7 +172,7 @@ tape( 'the created function evaluates the MGF for `x` given a small range `b - a
 		mgf = factory( a[i], b[i], c[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -203,7 +203,7 @@ tape( 'the created function evaluates the MGF for `x` given a medium range `b -
 		mgf = factory( a[i], b[i], c[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -234,7 +234,7 @@ tape( 'the created function evaluates the MGF for `x` given a large range `b - a
 		mgf = factory( a[i], b[i], c[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -265,7 +265,7 @@ tape( 'the created function evaluates the MGF for `x` given the case: a < c < b'
 		mgf = factory( a[i], b[i], c[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -296,7 +296,7 @@ tape( 'the created function evaluates the MGF for `x` given the case: a < c = b'
 		mgf = factory( a[i], b[i], c[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -327,7 +327,7 @@ tape( 'the created function evaluates the MGF for `x` given the case: a = c < b'
 		mgf = factory( a[i], b[i], c[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -358,7 +358,7 @@ tape( 'the created function evaluates the MGF for `x` given the case: a = c = b'
 		mgf = factory( a[i], b[i], c[i] );
 		y = mgf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.mgf.js
index 1f326c75a7dc..76643bdd4409 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.mgf.js
@@ -48,13 +48,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -62,16 +62,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = mgf( 2.0, -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns expected value' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,16 +80,16 @@ tape( 'if provided `0` for `t` and valid `a`, `b` and `c`, the function returns
 	var y;
 
 	y = mgf( 0.0, -1.0, -1.0, -1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, 0.0, 1.0, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, 0.0, 1.0, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, 1.0, 1.0, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function evaluates the MGF for `x` given a small range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -142,7 +142,7 @@ tape( 'the function evaluates the MGF for `x` given a medium range `b - a`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -171,7 +171,7 @@ tape( 'the function evaluates the MGF for `x` given a large range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -200,7 +200,7 @@ tape( 'the function evaluates the MGF for `x` given the case: a < c < b', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -229,7 +229,7 @@ tape( 'the function evaluates the MGF for `x` given the case: a < c = b', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -258,7 +258,7 @@ tape( 'the function evaluates the MGF for `x` given the case: a = c < b', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -287,7 +287,7 @@ tape( 'the function evaluates the MGF for `x` given the case: a = c = b', functi
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.native.js
index 57b2aa70ed21..5dffa7fd7f16 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.native.js
@@ -57,13 +57,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -71,16 +71,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = mgf( 2.0, -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,16 +89,16 @@ tape( 'if provided `0` for `t` and valid `a`, `b` and `c`, the function returns
 	var y;
 
 	y = mgf( 0.0, -1.0, -1.0, -1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, 0.0, 1.0, 0.5 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, 0.0, 1.0, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, 1.0, 1.0, 1.0 );
-	t.equal( y, 1.0, 'returns expected value' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function evaluates the MGF for `x` given a small range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
@@ -153,7 +153,7 @@ tape( 'the function evaluates the MGF for `x` given a medium range `b - a`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -182,7 +182,7 @@ tape( 'the function evaluates the MGF for `x` given a large range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -211,7 +211,7 @@ tape( 'the function evaluates the MGF for `x` given the case: a < c < b', opts,
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -240,7 +240,7 @@ tape( 'the function evaluates the MGF for `x` given the case: a < c = b', opts,
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -269,7 +269,7 @@ tape( 'the function evaluates the MGF for `x` given the case: a = c < b', opts,
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -298,7 +298,7 @@ tape( 'the function evaluates the MGF for `x` given the case: a = c = b', opts,
 	for ( i = 0; i < x.length; i++ ) {
 		y = mgf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.js
index 4575035bbb01..235960741d12 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = mode( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the mode of a triangular distribution', function tes
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.native.js
index cfe00ab6a985..ee10045df6c6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = mode( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns the mode of a triangular distribution', opts, functi
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.factory.js
index e01ffcbb9cff..bd90577eb4e0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,45 +56,45 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0, 0.5 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0, 0.5 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, NaN, 0.5 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN, 0.5 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN, 0.5 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN, NaN );
 
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -105,13 +105,13 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	pdf = factory( -10.0, 10.0, 0.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 20.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 11.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -122,13 +122,13 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	pdf = factory( -10.0, 10.0, 0.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -100.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -11.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -140,26 +140,26 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the created function
 	pdf = factory( 0.0, -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, NINF, 0.5 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF, 0.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, 10.0, 20.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, 10.0, -10.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -174,7 +174,7 @@ tape( 'if provided valid parameters, the created function returns `2/(b-a)` in c
 	b = 2.0;
 	c = 1.5;
 	pdf = factory( a, b, c );
-	t.equal( pdf( c ), 2/(b-a), 'returns 2/(b-a)' );
+	t.strictEqual( pdf( c ), 2/(b-a), 'returns 2/(b-a)' );
 	t.end();
 });
 
@@ -199,7 +199,7 @@ tape( 'the created function evaluates the pdf for `x` given small range `b - a`'
 		pdf = factory( a[i], b[i], c[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -230,7 +230,7 @@ tape( 'the created function evaluates the pdf for `x` given a medium range `b -
 		pdf = factory( a[i], b[i], c[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -261,7 +261,7 @@ tape( 'the created function evaluates the pdf for `x` given a large range `b - a
 		pdf = factory( a[i], b[i], c[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.native.js
index 4dffae744320..051fbe3fb080 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.native.js
@@ -55,48 +55,48 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, NaN, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 1.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided a number greater than `b` for `x` and valid parameters, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 20.0, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 2.0, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 1.1, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided a number smaller than `a` for `x` and valid parameters, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -20.0, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -2.0, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -0.5, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -105,16 +105,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = pdf( 2.0, 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, 3.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, 3.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'the function returns `2/(b-a)` if provided `x = c`', opts, function test(
 	var a = 0.0;
 	var b = 2.0;
 	var c = 1.5;
-	t.equal( pdf( c, a, b, c ), 2/(b-a), 'returns 2/(b-a)' );
+	t.strictEqual( pdf( c, a, b, c ), 2/(b-a), 'returns 2/(b-a)' );
 	t.end();
 });
 
@@ -146,7 +146,7 @@ tape( 'the function evaluates the pdf for `x` given a small range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -175,7 +175,7 @@ tape( 'the function evaluates the pdf for `x` given a medium range `b - a`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -204,7 +204,7 @@ tape( 'the function evaluates the pdf for `x` given a large range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.pdf.js
index 9831df998685..468b9ca020bc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.pdf.js
@@ -46,48 +46,48 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, NaN, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 1.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
 
 tape( 'if provided a number greater than `b` for `x` and valid parameters, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 20.0, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 2.0, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( 1.1, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
 
 tape( 'if provided a number smaller than `a` for `x` and valid parameters, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -20.0, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -2.0, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = pdf( -0.5, 0.0, 1.0, 0.5 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -96,16 +96,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = pdf( 2.0, 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, 3.0, 4.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, 3.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function returns `2/(b-a)` if provided `x = c`', function test( t ) {
 	var a = 0.0;
 	var b = 2.0;
 	var c = 1.5;
-	t.equal( pdf( c, a, b, c ), 2/(b-a), 'returns 2/(b-a)' );
+	t.strictEqual( pdf( c, a, b, c ), 2/(b-a), 'returns 2/(b-a)' );
 	t.end();
 });
 
@@ -137,7 +137,7 @@ tape( 'the function evaluates the pdf for `x` given a small range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -166,7 +166,7 @@ tape( 'the function evaluates the pdf for `x` given a medium range `b - a`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -195,7 +195,7 @@ tape( 'the function evaluates the pdf for `x` given a large range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.factory.js
index 702bb80119d1..a4dff7459e1e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,31 +56,31 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0, 0.5 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0, 0.5 );
 	y = quantile( 0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN, 0.5 );
 	y = quantile( 0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, 1.0, NaN );
 	y = quantile( 0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN, 0.5 );
 	y = quantile( 0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 0.0, NaN, NaN );
 	y = quantile( 0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0, NaN );
 	y = quantile( 0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -91,10 +91,10 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	quantile = factory( 0.0, 1.0, 0.5 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -106,18 +106,18 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the created function
 	quantile = factory( 1.0, 0.0, 0.5 );
 
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, 2.0, 3.0 );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF, 0.0 );
 	y = quantile( 0.2 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'if `p` is equal to the inflection point `( c - a ) / ( b - a )`, the crea
 	pInflect = ( c - a ) / ( b - a );
 	quantile = factory( a, b, c );
 	y = quantile( pInflect );
-	t.equal( y, c, 'returns c' );
+	t.strictEqual( y, c, 'returns c' );
 
 	a = -10.0;
 	b = 10.0;
@@ -145,7 +145,7 @@ tape( 'if `p` is equal to the inflection point `( c - a ) / ( b - a )`, the crea
 	pInflect = ( c - a ) / ( b - a );
 	quantile = factory( a, b, c );
 	y = quantile( pInflect );
-	t.equal( y, c, 'returns c' );
+	t.strictEqual( y, c, 'returns c' );
 
 	t.end();
 });
@@ -171,7 +171,7 @@ tape( 'the created function evaluates the quantile for `p` given a small range `
 		quantile = factory( a[i], b[i], c[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -202,7 +202,7 @@ tape( 'the created function evaluates the quantile for `p` given a medium range
 		quantile = factory( a[i], b[i], c[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -233,7 +233,7 @@ tape( 'the created function evaluates the quantile for `p` given a large range `
 		quantile = factory( a[i], b[i], c[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.native.js
index b6c55cc5683e..c34e622014f8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.native.js
@@ -55,21 +55,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.1, NaN, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.1, 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.1, 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and valid parameters, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -77,16 +77,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = quantile( 0.5, PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -10.0, 10.0, 11.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -10.0, 10.0, -11.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -103,14 +103,14 @@ tape( 'if `p` is equal to the inflection point `( c - a ) / ( b - a )`, the func
 	c = 3.0;
 	pInflect = ( c - a ) / ( b - a );
 	y = quantile( pInflect, a, b, c );
-	t.equal( y, c, 'returns c' );
+	t.strictEqual( y, c, 'returns c' );
 
 	a = -10.0;
 	b = 10.0;
 	c = 0.0;
 	pInflect = ( c - a ) / ( b - a );
 	y = quantile( pInflect, a, b, c );
-	t.equal( y, c, 'returns c' );
+	t.strictEqual( y, c, 'returns c' );
 
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'the function evaluates the quantile for `x` given a small range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -163,7 +163,7 @@ tape( 'the function evaluates the quantile for `x` given a medium range `b - a`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -192,7 +192,7 @@ tape( 'the function evaluates the quantile for `x` given a large range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.quantile.js
index 6e02dfa21db6..4d92527aa3f3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.quantile.js
@@ -46,21 +46,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.1, NaN, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.1, 0.0, NaN, 0.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.1, 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and valid parameters, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0, 0.5 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -68,16 +68,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = quantile( 0.5, PINF, NINF, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -10.0, 10.0, 11.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -10.0, 10.0, -11.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,14 +94,14 @@ tape( 'if `p` is equal to the inflection point `( c - a ) / ( b - a )`, the func
 	c = 3.0;
 	pInflect = ( c - a ) / ( b - a );
 	y = quantile( pInflect, a, b, c );
-	t.equal( y, c, 'returns c' );
+	t.strictEqual( y, c, 'returns c' );
 
 	a = -10.0;
 	b = 10.0;
 	c = 0.0;
 	pInflect = ( c - a ) / ( b - a );
 	y = quantile( pInflect, a, b, c );
-	t.equal( y, c, 'returns c' );
+	t.strictEqual( y, c, 'returns c' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function evaluates the quantile for `x` given a small range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -154,7 +154,7 @@ tape( 'the function evaluates the quantile for `x` given a medium range `b - a`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -183,7 +183,7 @@ tape( 'the function evaluates the quantile for `x` given a large range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.js
index 57a68a7ef3e2..bb7dd4f1a18a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = skewness( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the skewness of a triangular distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.native.js
index 1d6c222c5b42..fe67e3aacb1a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = skewness( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns the skewness of a triangular distribution', opts, fu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.js
index 41330418a2cf..10f6b83b1f5a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = stdev( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the standard deviation of a triangular distribution'
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.native.js
index 10bc22ce25c3..4569cc881d81 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = stdev( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns the standard deviation of a triangular distribution'
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/test/test.js
index 7aec0dbbff25..b11d148e651b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains triangular distribution functions', function test( t ) {
 	var keys = objectKeys( triangular );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.js
index 3aa1cf3cf30e..9ac81b9d7b32 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = variance( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns the variance of a triangular distribution', function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( a[i], b[i], c[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.native.js
index 01660514d00b..b6a55406d12f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 1.0, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 0.0, NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 0.0, 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = variance( -1.0, -1.1, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 3.0, 2.0, 2.5 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 0.0, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 0.0, 1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns the variance of a triangular distribution', opts, fu
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( a[i], b[i], c[i] );
 		if ( y.toFixed( 4 ) === expected[i].toFixed( 4 ) ) {
-			t.equal( y.toFixed( 4 ), expected[i].toFixed( 4 ), 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y.toFixed( 4 ), expected[i].toFixed( 4 ), 'a: '+a[i]+', b: '+b[i]+', c: '+c[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/truncated-normal/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/truncated-normal/pdf/test/test.js
index 33976f3e0e94..923e3669cb7c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/truncated-normal/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/truncated-normal/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/truncated-normal/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/truncated-normal/test/test.js
index f9cd82c5c105..6b39a4e0acb9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/truncated-normal/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/truncated-normal/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains truncated normal distribution functions', function test( t ) {
 	var keys = objectKeys( truncatedNormal );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.cdf.js
index 575f135fac9c..942ee9a3da87 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = cdf( 2.0, -1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -101,7 +101,7 @@ tape( 'the function evaluates the cdf for `x` given a small range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -128,7 +128,7 @@ tape( 'the function evaluates the cdf for `x` given a medium range `b - a`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -155,7 +155,7 @@ tape( 'the function evaluates the cdf for `x` given a large range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.factory.js
index 9289720bf8e3..8017b7d7c4f6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a `a >= b`, the created function always returns `NaN`', funct
 	cdf = factory( 2.0, 1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -1.0, -2.0 );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the created function evaluates the cdf for `x` given a small range `b - a
 		cdf = factory( a[i], b[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -178,7 +178,7 @@ tape( 'the created function evaluates the cdf for `x` given a medium range `b -
 		cdf = factory( a[i], b[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -207,7 +207,7 @@ tape( 'the created function evaluates the cdf for `x` given a large range `b - a
 		cdf = factory( a[i], b[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.native.js
index 78c02f192f15..f7d825b5ff1d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = cdf( 2.0, -1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function evaluates the cdf for `x` given a small range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -137,7 +137,7 @@ tape( 'the function evaluates the cdf for `x` given a medium range `b - a`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the cdf for `x` given a large range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.js
index 66a193ffc22d..19ff5d3b8325 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = entropy( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function returns the differential entropy of a uniform distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.native.js
index 4dedd1678e2f..eb2c4eeedd59 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = entropy( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns the differential entropy of a uniform distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.js
index b7c848b12f8a..a24080fb1908 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.js
@@ -38,10 +38,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -50,16 +50,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = kurtosis( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns `-6/5` as the excess kurtosis of a uniform distribut
 		a = ( randu()*10.0 );
 		b = ( randu()*10.0 ) + a;
 		v = kurtosis( a, b );
-		t.equal( v, -6/5, 'returns -6/5' );
+		t.strictEqual( v, -6/5, 'returns -6/5' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.native.js
index c620e7e3edfc..d442483889ed 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.native.js
@@ -47,10 +47,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -59,16 +59,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = kurtosis( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns `-6/5` as the excess kurtosis of a uniform distribut
 		a = ( randu()*10.0 );
 		b = ( randu()*10.0 ) + a;
 		v = kurtosis( a, b );
-		t.equal( v, -6/5, 'returns -6/5' );
+		t.strictEqual( v, -6/5, 'returns -6/5' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.factory.js
index 83fcbfc77604..af689f42e6c1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a `a >= b`, the created function always returns `NaN`', funct
 	logcdf = factory( 2.0, 1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( -1.0, -2.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -150,7 +150,7 @@ tape( 'the created function evaluates the logcdf for `x` given a small range `b
 		y = logcdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the created function evaluates the logcdf for `x` given a medium range `b
 		y = logcdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -212,7 +212,7 @@ tape( 'the created function evaluates the logcdf for `x` given a large range `b
 		y = logcdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.logcdf.js
index 3c46b2166ad1..fb2358d3bed5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logcdf( 2.0, -1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function evaluates the logcdf for `x` given a small range `b - a`', f
 		y = logcdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -131,7 +131,7 @@ tape( 'the function evaluates the logcdf for `x` given a medium range `b - a`',
 		y = logcdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -160,7 +160,7 @@ tape( 'the function evaluates the logcdf for `x` given a large range `b - a`', f
 		y = logcdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.native.js
index b20bb74ea4f1..4d80bf52635f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = logcdf( 2.0, -1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -111,7 +111,7 @@ tape( 'the function evaluates the logcdf for `x` given a small range `b - a`', o
 		y = logcdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -140,7 +140,7 @@ tape( 'the function evaluates the logcdf for `x` given a medium range `b - a`',
 		y = logcdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -169,7 +169,7 @@ tape( 'the function evaluates the logcdf for `x` given a large range `b - a`', o
 		y = logcdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.factory.js
index 1db9d3159de7..c9e469f5833d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `a` and `b`, the function returns a function which re
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `a` and `b`, the function returns a function which re
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -150,7 +150,7 @@ tape( 'the created function evaluates the logpdf for `x` given small range `b -
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -181,7 +181,7 @@ tape( 'the created function evaluates the logpdf for `x` given a medium range `b
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -212,7 +212,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large range `b
 		y = logpdf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.logpdf.js
index 95dd2159f260..311c8740fedb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logpdf( 2.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function evaluates the logpdf for `x` given a small range `b - a`', f
 		y = logpdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -131,7 +131,7 @@ tape( 'the function evaluates the logpdf for `x` given a medium range `b - a`',
 		y = logpdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -160,7 +160,7 @@ tape( 'the function evaluates the logpdf for `x` given a large range `b - a`', f
 		y = logpdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.native.js
index b5a5ecc28fdb..940080b23744 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = logpdf( 2.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -111,7 +111,7 @@ tape( 'the function evaluates the logpdf for `x` given a small range `b - a`', o
 		y = logpdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -140,7 +140,7 @@ tape( 'the function evaluates the logpdf for `x` given a medium range `b - a`',
 		y = logpdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
@@ -169,7 +169,7 @@ tape( 'the function evaluates the logpdf for `x` given a large range `b - a`', o
 		y = logpdf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.js
index b481b787be06..35007e595803 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function returns the mean of a uniform distribution', function test(
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.native.js
index fe7767e86ab9..065f9f6f1135 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.native.js
@@ -55,10 +55,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var v;
 
 	v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,16 +67,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mean( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -96,7 +96,7 @@ tape( 'the function returns the mean of a uniform distribution', opts, function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.js
index 51e2382acc5f..c4f760d9b04b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = median( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function returns the median of a uniform distribution', function test
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.native.js
index 5b3bf7a71a96..6e0e9170dd3d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.native.js
@@ -55,10 +55,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var v;
 
 	v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -67,16 +67,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = median( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -96,7 +96,7 @@ tape( 'the function returns the median of a uniform distribution', opts, functio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.factory.js
index 91c1ea056214..5346f14fee5c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0, 1.0 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,26 +84,26 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	mgf = factory( 0.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -114,11 +114,11 @@ tape( 'if provided valid parameters `a` and `b`, the created function returns `1
 
 	mgf = factory( 0.2, 0.4 );
 	y = mgf( 0.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	mgf = factory( 0.0, 10.0 );
 	y = mgf( 0.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the created function evaluates the MGF for `x` given small range `b - a`'
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 550.0 * EPS * abs( expected[ i ] );
@@ -174,7 +174,7 @@ tape( 'the created function evaluates the MGF for `x` given a medium range `b -
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 300.0 * EPS * abs( expected[ i ] );
@@ -205,7 +205,7 @@ tape( 'the created function evaluates the MGF for `x` given a large range `b - a
 		y = mgf( x[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 400.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.mgf.js
index 3cc66b53e38c..8aa448a6773b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.mgf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -58,16 +58,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mgf( 2.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,13 +76,13 @@ tape( 'if provided valid parameters, the function returns `1` for `t = 0`', func
 	var y;
 
 	y = mgf( 0.0, 2.0, 4.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = mgf( 0.0, 1.0, 2.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = mgf( 0.0, 0.2, 0.8 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -105,7 +105,7 @@ tape( 'the function evaluates the mgf for `x` given a small range `b - a`', func
 		y = mgf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 550.0 * EPS * abs( expected[ i ] );
@@ -134,7 +134,7 @@ tape( 'the function evaluates the mgf for `x` given a medium range `b - a`', fun
 		y = mgf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 300.0 * EPS * abs( expected[ i ] );
@@ -163,7 +163,7 @@ tape( 'the function evaluates the mgf for `x` given a large range `b - a`', func
 		y = mgf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 400.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.native.js
index 868d3aae948d..27ecfb2863d5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.native.js
@@ -55,11 +55,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -67,16 +67,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mgf( 2.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,13 +85,13 @@ tape( 'if provided valid parameters, the function returns `1` for `t = 0`', opts
 	var y;
 
 	y = mgf( 0.0, 2.0, 4.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = mgf( 0.0, 1.0, 2.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	y = mgf( 0.0, 0.2, 0.8 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function evaluates the mgf for `x` given a small range `b - a`', opts
 		y = mgf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 550.0 * EPS * abs( expected[ i ] );
@@ -143,7 +143,7 @@ tape( 'the function evaluates the mgf for `x` given a medium range `b - a`', opt
 		y = mgf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 300.0 * EPS * abs( expected[ i ] );
@@ -172,7 +172,7 @@ tape( 'the function evaluates the mgf for `x` given a large range `b - a`', opts
 		y = mgf( x[i], a[i], b[i] );
 		if ( expected[i] !== null ) {
 			if ( y === expected[i] ) {
-				t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+				t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 			} else {
 				delta = abs( y - expected[ i ] );
 				tol = 400.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.factory.js
index 82e4f5f50a7f..dcc3e007a7c4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the created function evaluates the pdf for `x` given small range `b - a`'
 		pdf = factory( a[i], b[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -178,7 +178,7 @@ tape( 'the created function evaluates the pdf for `x` given a medium range `b -
 		pdf = factory( a[i], b[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -207,7 +207,7 @@ tape( 'the created function evaluates the pdf for `x` given a large range `b - a
 		pdf = factory( a[i], b[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.native.js
index b8b790faa65b..a2af03e92c98 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = pdf( 2.0, -1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 0.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -0.5, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function evaluates the pdf for `x` given a small range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -137,7 +137,7 @@ tape( 'the function evaluates the pdf for `x` given a medium range `b - a`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the pdf for `x` given a large range `b - a`', opts
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.pdf.js
index 23edf347b056..dfa8e3e1900b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pdf( 2.0, 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -101,7 +101,7 @@ tape( 'the function evaluates the pdf for `x` given a small range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -128,7 +128,7 @@ tape( 'the function evaluates the pdf for `x` given a medium range `b - a`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -155,7 +155,7 @@ tape( 'the function evaluates the pdf for `x` given a large range `b - a`', func
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.factory.js
index 1a72657548ca..317bdf42ab72 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,18 +98,18 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	quantile = factory( 1.0, 0.5 );
 
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 0.3 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the created function evaluates the quantile for `p` given a small range `
 		quantile = factory( a[i], b[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -162,7 +162,7 @@ tape( 'the created function evaluates the quantile for `p` given a medium range
 		quantile = factory( a[i], b[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -191,7 +191,7 @@ tape( 'the created function evaluates the quantile for `p` given a large range `
 		quantile = factory( a[i], b[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.native.js
index 36b2407bb5fc..f71f5424eb68 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -75,16 +75,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -2.0, -3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function evaluates the quantile for `p` given a small range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -133,7 +133,7 @@ tape( 'the function evaluates the quantile for `p` given a medium range `b - a`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -160,7 +160,7 @@ tape( 'the function evaluates the quantile for `p` given a large range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.quantile.js
index d78579ad7d29..f55f148e491a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.2, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,16 +66,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -2.0, -3.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function evaluates the quantile for `p` given a small range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -124,7 +124,7 @@ tape( 'the function evaluates the quantile for `p` given a medium range `b - a`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -151,7 +151,7 @@ tape( 'the function evaluates the quantile for `p` given a large range `b - a`',
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.js
index 1aa5383a771f..8faa2cf52670 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.js
@@ -38,10 +38,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -50,16 +50,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns `0.0` as the skewness of a uniform distribution ', f
 		a = ( randu()*10.0 );
 		b = ( randu()*10.0 ) + a;
 		v = skewness( a, b );
-		t.equal( v, 0.0, 'returns 0.0' );
+		t.strictEqual( v, 0.0, 'returns 0.0' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.native.js
index 006dbe22c854..3bf2e0154de2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.native.js
@@ -48,10 +48,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var v;
 
 	v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -60,16 +60,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -78,13 +78,13 @@ tape( 'the function returns the skewness of a uniform distribution', opts, funct
 	var y;
 
 	y = skewness( 0.0, 1.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = skewness( 4.0, 12.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = skewness( -4.0, 4.0 );
-	t.equal( y, 0.0, 'returns expected value' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.js
index 48d75a6aac27..839d96f9eb43 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = stdev( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.native.js
index cee4887a0497..d86c3d2f215e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = stdev( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/test/test.js
index 66cd9243b227..edda0fa53fcb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains uniform distribution functions', function test( t ) {
 	var keys = objectKeys( uniform );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.js
index db0ed8a98d04..be21788dcc23 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = variance( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function returns the variance of a uniform distribution', function te
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.native.js
index bd77d8453bad..3403c69695e8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = variance( 3.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 2.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns the variance of a uniform distribution', opts, funct
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( a[i], b[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'a: '+a[i]+', b: '+b[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.cdf.js
index 2ca4e0f27288..c18993485c13 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `lambda`, the function returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,25 +97,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', function test
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1/0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'the function evaluates the cdf for `x` given large `lambda` and `k`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the cdf for `x` given large shape parameter `lambd
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -191,7 +191,7 @@ tape( 'the function evaluates the cdf for `x` given large scale parameter `k`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.factory.js
index 063632008834..7794cb571dbe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.equal( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0 );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `k`, the created function always returns `NaN`'
 	cdf = factory( 0.0, 1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( -1.0, 1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -145,34 +145,34 @@ tape( 'if provided a nonpositive `lambda`, the created function always returns `
 	cdf = factory( 0.5, 0.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 0.5, -1.0 );
 
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( 1.0, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -196,7 +196,7 @@ tape( 'the created function evaluates the cdf for `x` given large `k` and `lambd
 		cdf = factory( k[i], lambda[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -225,7 +225,7 @@ tape( 'the created function evaluates the cdf for `x` given large shape paramete
 		cdf = factory( k[i], lambda[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -254,7 +254,7 @@ tape( 'the created function evaluates the cdf for `x` given large scale paramete
 		cdf = factory( k[i], lambda[i] );
 		y = cdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', lambda: '+lambda[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.js
index 9875450acab2..f4a9cb6f3510 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `cdf` functions', function test( t ) {
-	t.equal( typeof cdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof cdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.native.js
index 80fd4941bcaf..c69959167c18 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.equal( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns 1' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `lambda`, the function returns `NaN`', opts, fu
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -106,25 +106,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 0.0, -1/0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -146,7 +146,7 @@ tape( 'the function evaluates the cdf for `x` given large `lambda` and `k`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the function evaluates the cdf for `x` given large shape parameter `lambd
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -200,7 +200,7 @@ tape( 'the function evaluates the cdf for `x` given large scale parameter `k`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = cdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.js
index 115cf1c567ac..14f5f947fbbf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the differential entropy of a Weibull distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.native.js
index 8eece0b0e727..aaa4560425c1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = entropy( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = entropy( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the differential entropy of a Weibull distribution',
 	for ( i = 0; i < expected.length; i++ ) {
 		y = entropy( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.js
index c6d2e9172d12..7179049026a1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the excess kurtosis of a Weibull distribution', func
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5e6 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.native.js
index 6057f3613c6b..774d4fd03e70 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = kurtosis( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = kurtosis( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the excess kurtosis of a Weibull distribution', opts
 	for ( i = 0; i < expected.length; i++ ) {
 		y = kurtosis( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.5e6 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.factory.js
index d7b748dea010..4228896496d7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.equal( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0, 1.0 );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( NINF );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `k`, the created function always returns `NaN`'
 	logcdf = factory( 0.0, 1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( -1.0, 1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, 0.0 );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, PINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NaN );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -145,34 +145,34 @@ tape( 'if provided a nonpositive `lambda`, the created function always returns `
 	logcdf = factory( 0.5, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 0.5, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( 1.0, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -196,7 +196,7 @@ tape( 'the created function evaluates the logcdf for `x` given large `lambda` an
 		logcdf = factory( k[i], lambda[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -225,7 +225,7 @@ tape( 'the created function evaluates the logcdf for `x` given large shape param
 		logcdf = factory( k[i], lambda[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -254,7 +254,7 @@ tape( 'the created function evaluates the logcdf for `x` given large scale param
 		logcdf = factory( k[i], lambda[i] );
 		y = logcdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.js
index 0749c942579c..fd240d244992 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logcdf` functions', function test( t ) {
-	t.equal( typeof logcdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logcdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.logcdf.js
index 013bf772d877..ac06c0e3e4c0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns 0' );
+	t.strictEqual( y, NINF, 'returns 0' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `lambda`, the function returns `NaN`', function
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,25 +97,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', function test
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -1/0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'the function evaluates the logcdf for `x` given large `lambda` and `k`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -164,7 +164,7 @@ tape( 'the function evaluates the logcdf for `x` given large shape parameter `la
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -191,7 +191,7 @@ tape( 'the function evaluates the logcdf for `x` given large scale parameter `k`
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.native.js
index 8d8493a9abba..f85264300786 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.equal( y, NINF, 'returns 0' );
+	t.strictEqual( y, NINF, 'returns 0' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `lambda`, the function returns `NaN`', opts, fu
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -106,25 +106,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 0.0, -1/0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -146,7 +146,7 @@ tape( 'the function evaluates the logcdf for `x` given large `lambda` and `k`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -173,7 +173,7 @@ tape( 'the function evaluates the logcdf for `x` given large shape parameter `la
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -200,7 +200,7 @@ tape( 'the function evaluates the logcdf for `x` given large scale parameter `k`
 	for ( i = 0; i < x.length; i++ ) {
 		y = logcdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.factory.js
index 0620aedb7d15..726176b2675a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.equal( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0, 1.0 );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( PINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -107,33 +107,33 @@ tape( 'if provided `k <= 0`, the created function always returns `NaN`', functio
 	logpdf = factory( 0.0, 1.0 );
 
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( -1.0, 1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -144,33 +144,33 @@ tape( 'if provided `lambda <= 0`, the created function always returns `NaN`', fu
 
 	logpdf = factory( 1.0, 0.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, -1.0 );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( 1.0, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -185,7 +185,7 @@ tape( 'if provided a positive `lambda` and `k` equal to one, the created functio
 	lambda = 3.0;
 	logpdf = factory( k, lambda );
 	y = logpdf( 0.0 );
-	t.equal( y, ln(k/lambda), 'returns ln( k / lambda )' );
+	t.strictEqual( y, ln(k/lambda), 'returns ln( k / lambda )' );
 	t.end();
 });
 
@@ -195,7 +195,7 @@ tape( 'if provided a positive `lambda` and `k` not equal to one, the  created fu
 
 	logpdf = factory( 2.0, 1.0 );
 	y = logpdf( 0.0 );
-	t.equal( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns -infinity' );
 	t.end();
 });
 
@@ -218,7 +218,7 @@ tape( 'the created function evaluates the logpdf for `x` given large `lambda` an
 		logpdf = factory( k[i], lambda[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -249,7 +249,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large shape par
 		logpdf = factory( k[i], lambda[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -278,7 +278,7 @@ tape( 'the created function evaluates the logpdf for `x` given a large scale par
 		logpdf = factory( k[i], lambda[i] );
 		y = logpdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.js
index 64ccf13585e0..43c89129db1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `logpdf` functions', function test( t ) {
-	t.equal( typeof logpdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof logpdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.logpdf.js
index c54c4d180391..06e8745389ff 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.logpdf.js
@@ -47,23 +47,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -71,25 +71,25 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,25 +98,25 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logpdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -129,13 +129,13 @@ tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` equal to one, the
 	k = 1.0;
 	lambda = 3.0;
 	y = logpdf( 0.0, k, lambda );
-	t.equal( y, ln(k/lambda), 'returns ln(k / lambda)' );
+	t.strictEqual( y, ln(k/lambda), 'returns ln(k / lambda)' );
 	t.end();
 });
 
 tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` not equal to one, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( 0.0, 2.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -156,7 +156,7 @@ tape( 'the function evaluates the logpdf for `x` given large `lambda` and `k`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -183,7 +183,7 @@ tape( 'the function evaluates the logpdf for `x` given large scale parameter `la
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -210,7 +210,7 @@ tape( 'the function evaluates the logpdf for `x` given large shape parameter `k`
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.native.js
index f37bc397d42a..4113f3317484 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.native.js
@@ -56,23 +56,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -80,25 +80,25 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, 2.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -107,25 +107,25 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = logpdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -138,13 +138,13 @@ tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` equal to one, the
 	k = 1.0;
 	lambda = 3.0;
 	y = logpdf( 0.0, k, lambda );
-	t.equal( y, ln(k/lambda), 'returns ln(k / lambda)' );
+	t.strictEqual( y, ln(k/lambda), 'returns ln(k / lambda)' );
 	t.end();
 });
 
 tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` not equal to one, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( 0.0, 2.0, 1.0 );
-	t.equal( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns -Infinity' );
 	t.end();
 });
 
@@ -165,7 +165,7 @@ tape( 'the function evaluates the logpdf for `x` given large `lambda` and `k`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -192,7 +192,7 @@ tape( 'the function evaluates the logpdf for `x` given large scale parameter `la
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -219,7 +219,7 @@ tape( 'the function evaluates the logpdf for `x` given large shape parameter `k`
 	for ( i = 0; i < x.length; i++ ) {
 		y = logpdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 10.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.js
index aa64184f2120..3c3159bf33c4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the mean of a Weibull distribution', function test(
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.native.js
index cbddde44de39..21d8f82e2558 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mean( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mean( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the mean of a Weibull distribution', opts, function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mean( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 3.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.js
index a99ac70e69df..41e2c7575c2e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = median( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the median of a Weibull distribution', function test
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.native.js
index 8f3ee6aae1ab..0fb0c5922348 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = median( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = median( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = median( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = median( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the median of a Weibull distribution', opts, functio
 	for ( i = 0; i < expected.length; i++ ) {
 		y = median( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.factory.js
index b9e06cfbb7a7..0e59ce10d62d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.factory.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.equal( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -49,23 +49,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 1.0, 1.0 );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,31 +77,31 @@ tape( 'if provided a nonpositive `k`, the created function always returns `NaN`'
 	mgf = factory( 1.0, 0.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 1.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( 1.0, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -113,31 +113,31 @@ tape( 'if provided a nonpositive `lambda`, the created function always returns `
 	mgf = factory( 0.0, 0.5 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( -1.0, 0.5 );
 
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, 1.0 );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, PINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	mgf = factory( NINF, NaN );
 	y = mgf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.js
index e6d05e4f7408..7914468c7a29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
-	t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof mgf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.mgf.js
index 026567fa6f2a..03deeaefe683 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.mgf.js
@@ -40,11 +40,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', function test
 	var y;
 
 	y = mgf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', function test
 	var y;
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.native.js
index 354c4e381f25..2d301f8eb2cd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.native.js
@@ -49,11 +49,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mgf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -88,25 +88,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 0.0, 2.0, -1/0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.js
index 600b5c3162b2..0bae2c9a8a3a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,10 +56,10 @@ tape( 'if provided `0 < k <= 1` and `lambda > 0`, the function returns `0`', fun
 	var y;
 
 	y = mode( 0.3, 2.0 );
-	t.equal( y, 0.0, 'returns NaN' );
+	t.strictEqual( y, 0.0, 'returns NaN' );
 
 	y = mode( 0.9, 2.0 );
-	t.equal( y, 0.0, 'returns NaN' );
+	t.strictEqual( y, 0.0, 'returns NaN' );
 
 	t.end();
 });
@@ -68,19 +68,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -121,7 +121,7 @@ tape( 'the function returns the mode of a Weibull distribution', function test(
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.native.js
index 814dd8bd2186..a72b63f4d159 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = mode( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'if provided `0 < k <= 1` and `lambda > 0`, the function returns `0`', opt
 	var y;
 
 	y = mode( 0.3, 2.0 );
-	t.equal( y, 0.0, 'returns NaN' );
+	t.strictEqual( y, 0.0, 'returns NaN' );
 
 	y = mode( 0.9, 2.0 );
-	t.equal( y, 0.0, 'returns NaN' );
+	t.strictEqual( y, 0.0, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -98,19 +98,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = mode( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function returns the mode of a Weibull distribution', opts, function
 	for ( i = 0; i < expected.length; i++ ) {
 		y = mode( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.factory.js
index 374a7888e771..ac79a0fc38e3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.equal( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 
 	t.end();
 });
@@ -105,33 +105,33 @@ tape( 'if provided `k <= 0`, the created function always returns `NaN`', functio
 
 	pdf = factory( 0.0, 0.5 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( -1.0, 0.5 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -142,33 +142,33 @@ tape( 'if provided `lambda <= 0`, the created function always returns `NaN`', fu
 
 	pdf = factory( 1.0, 0.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, -1.0 );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( 1.0, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'if provided a positive `lambda` and `k` equal to one, the created functio
 	lambda = 3.0;
 	pdf = factory( k, lambda );
 	y = pdf( 0.0 );
-	t.equal( y, k/lambda, 'returns k / lambda' );
+	t.strictEqual( y, k/lambda, 'returns k / lambda' );
 	t.end();
 });
 
@@ -193,7 +193,7 @@ tape( 'if provided a positive `lambda` and `k` not equal to one, the  created fu
 
 	pdf = factory( 2.0, 1.0 );
 	y = pdf( 0.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -216,7 +216,7 @@ tape( 'the created function evaluates the pdf for `x` given large `lambda` and `
 		pdf = factory( k[i], lambda[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -245,7 +245,7 @@ tape( 'the created function evaluates the pdf for `x` given a large shape parame
 		pdf = factory( k[i], lambda[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -274,7 +274,7 @@ tape( 'the created function evaluates the pdf for `x` given a large scale parame
 		pdf = factory( k[i], lambda[i] );
 		y = pdf( x[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.js
index 4c4ed20d90fa..c325e2497829 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `pdf` functions', function test( t ) {
-	t.equal( typeof pdf.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof pdf.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.native.js
index 4a2c819eed45..3d86f15f82fe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = pdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -106,25 +106,25 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -137,13 +137,13 @@ tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` equal to one, the
 	k = 1.0;
 	lambda = 3.0;
 	y = pdf( 0.0, k, lambda );
-	t.equal( y, k/lambda, 'returns k / lambda' );
+	t.strictEqual( y, k/lambda, 'returns k / lambda' );
 	t.end();
 });
 
 tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` not equal to one, the function returns `0`', opts, function test( t ) {
 	var y = pdf( 0.0, 2.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -164,7 +164,7 @@ tape( 'the function evaluates the pdf for `x` given large `lambda` and `k`', opt
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -191,7 +191,7 @@ tape( 'the function evaluates the pdf for `x` given large scale parameter `lambd
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -218,7 +218,7 @@ tape( 'the function evaluates the pdf for `x` given large shape parameter `k`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.pdf.js
index 0a7e8c0c8548..db39b1371351 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pdf( 2.0, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,25 +97,25 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -128,13 +128,13 @@ tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` equal to one, the
 	k = 1.0;
 	lambda = 3.0;
 	y = pdf( 0.0, k, lambda );
-	t.equal( y, k/lambda, 'returns k / lambda' );
+	t.strictEqual( y, k/lambda, 'returns k / lambda' );
 	t.end();
 });
 
 tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` not equal to one, the function returns `0`', function test( t ) {
 	var y = pdf( 0.0, 2.0, 1.0 );
-	t.equal( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -155,7 +155,7 @@ tape( 'the function evaluates the pdf for `x` given large `lambda` and `k`', fun
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -182,7 +182,7 @@ tape( 'the function evaluates the pdf for `x` given large scale parameter `lambd
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -209,7 +209,7 @@ tape( 'the function evaluates the pdf for `x` given large shape parameter `k`',
 	for ( i = 0; i < x.length; i++ ) {
 		y = pdf( x[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'x: '+x[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.factory.js
index df2d89189a6c..bb14a4dfc9d9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.equal( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( -0.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 1.1 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -97,33 +97,33 @@ tape( 'if provided a nonpositive `k`, the created function always returns `NaN`'
 
 	quantile = factory( 1.0, 0.0 );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, -1.0 );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( 1.0, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -134,33 +134,33 @@ tape( 'if provided a nonpositive `lambda`, the created function always returns `
 
 	quantile = factory( 0.0, 0.5 );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( -1.0, 0.5 );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -184,7 +184,7 @@ tape( 'the created function evaluates the quantile for `p` given large `lambda`
 		quantile = factory( k[i], lambda[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -213,7 +213,7 @@ tape( 'the created function evaluates the quantile for `p` given large shape par
 		quantile = factory( k[i], lambda[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -242,7 +242,7 @@ tape( 'the created function evaluates the quantile for `p` given large scale par
 		quantile = factory( k[i], lambda[i] );
 		y = quantile( p[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', lambda: '+lambda[i]+', k: '+k[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.js
index 8d7af21e5823..42ecaac1b121 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a factory method for generating `quantile` functions', function test( t ) {
-	t.equal( typeof quantile.factory, 'function', 'exports a factory method' );
+	t.strictEqual( typeof quantile.factory, 'function', 'exports a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.native.js
index 431fb7f502de..df1751bf76df 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.5, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.5, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( PINF, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NINF, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `k <= 0` or `lambda <= 0`, the function returns `NaN`', opts,
 	var y;
 
 	y = quantile( 0.5, -1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 1.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 1.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function evaluates the quantile for `p` given large `k` and `lambda`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[ i ], k[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'p: ' + p[ i ] + ', k: ' + k[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'p: ' + p[ i ] + ', k: ' + k[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
@@ -137,7 +137,7 @@ tape( 'the function evaluates the quantile for `p` given large `lambda`', opts,
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[ i ], k[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'p: ' + p[ i ] + ', k: ' + k[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'p: ' + p[ i ] + ', k: ' + k[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			if ( k[ i ] > 4.0 ||
@@ -171,7 +171,7 @@ tape( 'the function evaluates the quantile for `p` given large `k`', opts, funct
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[ i ], k[ i ], lambda[ i ] );
 		if ( y === expected[ i ] ) {
-			t.equal( y, expected[ i ], 'p: ' + p[ i ] + ', k: ' + k[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
+			t.strictEqual( y, expected[ i ], 'p: ' + p[ i ] + ', k: ' + k[ i ] + ', lambda: ' + lambda[ i ] + ', y: ' + y + ', expected: ' + expected[ i ] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 2.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.quantile.js
index b3eeffc2aac6..1dbe738323b6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `lambda` and `k`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.equal( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,25 +66,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', function test
 	var y;
 
 	y = quantile( 0.5, 0.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -93,25 +93,25 @@ tape( 'if provided a nonpositive `lambda`, the function returns `NaN`', function
 	var y;
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = quantile( 0.5, NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the function evaluates the p-th quantile given large parameters `lambda`
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -160,7 +160,7 @@ tape( 'the function evaluates the p-th quantile given large shape parameter `lam
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1.0 * EPS * abs( expected[ i ] );
@@ -187,7 +187,7 @@ tape( 'the function evaluates the p-th quantile given large scale parameter `k`'
 	for ( i = 0; i < p.length; i++ ) {
 		y = quantile( p[i], k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'p: '+p[i]+', k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 5.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.js
index 6fe2d0ea4e3c..bde508eda493 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.js
@@ -43,10 +43,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -55,19 +55,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -76,19 +76,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -108,7 +108,7 @@ tape( 'the function returns the skewness of a Weibull distribution', function te
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1e-11 * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.native.js
index 14a8abe4d207..26eab9beabdf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.native.js
@@ -52,10 +52,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = skewness( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -64,19 +64,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -85,19 +85,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = skewness( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -117,7 +117,7 @@ tape( 'the function returns the skewness of a Weibull distribution', opts, funct
 	for ( i = 0; i < expected.length; i++ ) {
 		y = skewness( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 1e-11 * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.js
index 120551c4e5ae..147477e04626 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the standard deviation of a Weibull distribution', f
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 170.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.native.js
index 1a73fc22b423..4e4e8e80cce7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = stdev( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = stdev( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the standard deviation of a Weibull distribution', o
 	for ( i = 0; i < expected.length; i++ ) {
 		y = stdev( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 180.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/test/test.js
index 35a087aaf040..a04710fbbc52 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains Weibull distribution functions', function test( t ) {
 	var keys = objectKeys( weibull );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.js
index 407d2f7fe9af..03eba79a271f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns the variance of a Weibull distribution', function te
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 300.0 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.native.js
index d5976826e799..c115609ef707 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	v = variance( 10.0, NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, 1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, PINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NaN );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( 1.0, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( PINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NINF, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	y = variance( NaN, NINF );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the function returns the variance of a Weibull distribution', opts, funct
 	for ( i = 0; i < expected.length; i++ ) {
 		y = variance( k[i], lambda[i] );
 		if ( y === expected[i] ) {
-			t.equal( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
+			t.strictEqual( y, expected[i], 'k: '+k[i]+', lambda: '+lambda[i]+', y: '+y+', expected: '+expected[i] );
 		} else {
 			delta = abs( y - expected[ i ] );
 			tol = 300.0 * EPS * abs( expected[ i ] );

From 842892db70da69098d8fb271ea19ae45c09a8a0e Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Wed, 13 Aug 2025 22:08:47 -0500
Subject: [PATCH 06/32] test: use .strictEqual() instead of .equal() and fix
 lint errors

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/stats/anova1/test/test.js         | 39 ++++----
 .../stats/anova1/test/test.validate.js        |  8 +-
 .../@stdlib/stats/array/test/test.js          |  2 +-
 .../@stdlib/stats/bartlett-test/test/test.js  | 12 +--
 .../stats/bartlett-test/test/test.validate.js | 10 +--
 .../@stdlib/stats/base/ndarray/test/test.js   |  2 +-
 .../@stdlib/stats/base/test/test.js           |  2 +-
 .../@stdlib/stats/binomial-test/test/test.js  | 14 +--
 .../stats/binomial-test/test/test.validate.js | 12 +--
 .../stats/chi2gof/test/test.get_pmf.js        | 18 ++--
 .../@stdlib/stats/chi2gof/test/test.js        | 25 +++---
 .../stats/chi2gof/test/test.validate.js       | 14 +--
 .../@stdlib/stats/chi2test/test/test.js       | 16 ++--
 .../stats/chi2test/test/test.validate.js      | 10 +--
 .../@stdlib/stats/fligner-test/test/test.js   | 12 +--
 .../stats/fligner-test/test/test.validate.js  | 10 +--
 .../@stdlib/stats/incr/apcorr/test/test.js    | 44 +++++-----
 .../@stdlib/stats/incr/count/test/test.js     | 11 +--
 .../stats/incr/covariance/test/test.js        | 44 +++++-----
 .../@stdlib/stats/incr/covmat/test/test.js    | 16 ++--
 .../@stdlib/stats/incr/cv/test/test.js        | 33 +++----
 .../@stdlib/stats/incr/ewmean/test/test.js    |  9 +-
 .../@stdlib/stats/incr/ewstdev/test/test.js   |  9 +-
 .../stats/incr/ewvariance/test/test.js        |  9 +-
 .../@stdlib/stats/incr/hmean/test/test.js     |  6 +-
 .../@stdlib/stats/incr/kurtosis/test/test.js  | 20 ++---
 .../@stdlib/stats/incr/maape/test/test.js     | 10 +--
 .../@stdlib/stats/incr/mae/test/test.js       | 10 +--
 .../@stdlib/stats/incr/mapcorr/test/test.js   | 69 ++++++++-------
 .../@stdlib/stats/incr/mape/test/test.js      | 10 +--
 .../@stdlib/stats/incr/max/test/test.js       | 19 ++--
 .../@stdlib/stats/incr/maxabs/test/test.js    | 19 ++--
 .../stats/incr/mcovariance/test/test.js       | 65 +++++++-------
 .../@stdlib/stats/incr/mcv/test/test.js       | 57 ++++++------
 .../@stdlib/stats/incr/mda/test/test.js       | 10 +--
 .../@stdlib/stats/incr/me/test/test.js        | 10 +--
 .../@stdlib/stats/incr/mean/test/test.js      | 11 +--
 .../@stdlib/stats/incr/meanabs/test/test.js   | 11 +--
 .../@stdlib/stats/incr/meanabs2/test/test.js  | 10 +--
 .../@stdlib/stats/incr/meanstdev/test/test.js | 26 +++---
 .../@stdlib/stats/incr/meanvar/test/test.js   | 26 +++---
 .../@stdlib/stats/incr/mgmean/test/test.js    | 16 ++--
 .../stats/incr/mgrubbs/test/test.meanstdev.js | 26 +++---
 .../stats/incr/mgrubbs/test/test.minmax.js    | 19 ++--
 .../@stdlib/stats/incr/mhmean/test/test.js    | 14 +--
 .../@stdlib/stats/incr/midrange/test/test.js  | 13 +--
 .../@stdlib/stats/incr/min/test/test.js       | 19 ++--
 .../@stdlib/stats/incr/minabs/test/test.js    | 19 ++--
 .../@stdlib/stats/incr/minmax/test/test.js    | 36 ++++----
 .../@stdlib/stats/incr/minmaxabs/test/test.js | 36 ++++----
 .../@stdlib/stats/incr/mmaape/test/test.js    | 26 +++---
 .../@stdlib/stats/incr/mmae/test/test.js      | 22 ++---
 .../@stdlib/stats/incr/mmape/test/test.js     | 26 +++---
 .../@stdlib/stats/incr/mmax/test/test.js      | 14 +--
 .../@stdlib/stats/incr/mmaxabs/test/test.js   | 14 +--
 .../@stdlib/stats/incr/mmda/test/test.js      | 26 +++---
 .../@stdlib/stats/incr/mme/test/test.js       | 26 +++---
 .../@stdlib/stats/incr/mmean/test/test.js     | 10 +--
 .../@stdlib/stats/incr/mmeanabs/test/test.js  | 10 +--
 .../@stdlib/stats/incr/mmeanabs2/test/test.js | 14 +--
 .../stats/incr/mmeanstdev/test/test.js        | 50 +++++------
 .../@stdlib/stats/incr/mmeanvar/test/test.js  | 50 +++++------
 .../@stdlib/stats/incr/mmidrange/test/test.js | 14 +--
 .../@stdlib/stats/incr/mmin/test/test.js      | 14 +--
 .../@stdlib/stats/incr/mminabs/test/test.js   | 14 +--
 .../@stdlib/stats/incr/mminmax/test/test.js   | 20 ++---
 .../stats/incr/mminmaxabs/test/test.js        | 20 ++---
 .../@stdlib/stats/incr/mmpe/test/test.js      | 26 +++---
 .../@stdlib/stats/incr/mmse/test/test.js      | 26 +++---
 .../@stdlib/stats/incr/mpcorr/test/test.js    | 69 ++++++++-------
 .../@stdlib/stats/incr/mpcorr2/test/test.js   | 69 ++++++++-------
 .../stats/incr/mpcorrdist/test/test.js        | 69 ++++++++-------
 .../@stdlib/stats/incr/mpe/test/test.js       | 10 +--
 .../@stdlib/stats/incr/mprod/test/test.js     | 88 +++++++++----------
 .../@stdlib/stats/incr/mrange/test/test.js    | 14 +--
 .../@stdlib/stats/incr/mrmse/test/test.js     | 26 +++---
 .../@stdlib/stats/incr/mrss/test/test.js      | 26 +++---
 .../@stdlib/stats/incr/mse/test/test.js       | 10 +--
 .../@stdlib/stats/incr/mstdev/test/test.js    | 52 +++++------
 .../@stdlib/stats/incr/msum/test/test.js      | 10 +--
 .../@stdlib/stats/incr/msumabs/test/test.js   | 10 +--
 .../@stdlib/stats/incr/msumabs2/test/test.js  | 10 +--
 .../@stdlib/stats/incr/msummary/test/test.js  |  5 +-
 .../@stdlib/stats/incr/msumprod/test/test.js  | 25 +++---
 .../@stdlib/stats/incr/mvariance/test/test.js | 57 ++++++------
 .../@stdlib/stats/incr/mvmr/test/test.js      | 57 ++++++------
 .../@stdlib/stats/incr/nancount/test/test.js  | 11 +--
 .../@stdlib/stats/incr/nanmaxabs/test/test.js | 12 +--
 .../@stdlib/stats/incr/nanmean/test/test.js   |  6 +-
 .../stats/incr/nanmeanabs/test/test.js        |  6 +-
 .../@stdlib/stats/incr/nanmstdev/test/test.js | 46 +++++-----
 .../@stdlib/stats/incr/nanmsum/test/test.js   |  6 +-
 .../stats/incr/nanskewness/test/test.js       | 12 +--
 .../@stdlib/stats/incr/nanstdev/test/test.js  | 16 ++--
 .../@stdlib/stats/incr/nansum/test/test.js    | 13 +--
 .../@stdlib/stats/incr/nansumabs/test/test.js | 11 +--
 .../stats/incr/nansumabs2/test/test.js        | 11 +--
 .../@stdlib/stats/incr/pcorr/test/test.js     | 44 +++++-----
 .../@stdlib/stats/incr/pcorr2/test/test.js    | 44 +++++-----
 .../@stdlib/stats/incr/pcorrdist/test/test.js | 42 ++++-----
 .../stats/incr/pcorrdistmat/test/test.js      | 16 ++--
 .../@stdlib/stats/incr/pcorrmat/test/test.js  | 16 ++--
 .../@stdlib/stats/incr/range/test/test.js     | 13 +--
 .../@stdlib/stats/incr/rmse/test/test.js      | 10 +--
 .../@stdlib/stats/incr/rss/test/test.js       | 10 +--
 .../@stdlib/stats/incr/skewness/test/test.js  | 16 ++--
 .../@stdlib/stats/incr/stdev/test/test.js     | 28 +++---
 .../@stdlib/stats/incr/sum/test/test.js       | 13 +--
 .../@stdlib/stats/incr/sumabs/test/test.js    | 11 +--
 .../@stdlib/stats/incr/sumabs2/test/test.js   | 11 +--
 .../@stdlib/stats/incr/summary/test/test.js   |  5 +-
 .../@stdlib/stats/incr/sumprod/test/test.js   | 11 +--
 .../@stdlib/stats/incr/test/test.js           |  2 +-
 .../@stdlib/stats/incr/variance/test/test.js  | 33 +++----
 .../@stdlib/stats/incr/vmr/test/test.js       | 33 +++----
 .../@stdlib/stats/incr/wmean/test/test.js     | 22 ++---
 .../@stdlib/stats/iter/cugmean/test/test.js   | 66 +++++++-------
 .../@stdlib/stats/iter/cuhmean/test/test.js   | 66 +++++++-------
 .../@stdlib/stats/iter/cumax/test/test.js     | 66 +++++++-------
 .../@stdlib/stats/iter/cumaxabs/test/test.js  | 66 +++++++-------
 .../@stdlib/stats/iter/cumean/test/test.js    | 66 +++++++-------
 .../@stdlib/stats/iter/cumeanabs/test/test.js | 66 +++++++-------
 .../stats/iter/cumeanabs2/test/test.js        | 70 +++++++--------
 .../stats/iter/cumidrange/test/test.js        | 66 +++++++-------
 .../@stdlib/stats/iter/cumin/test/test.js     | 66 +++++++-------
 .../@stdlib/stats/iter/cuminabs/test/test.js  | 66 +++++++-------
 .../@stdlib/stats/iter/cuprod/test/test.js    | 66 +++++++-------
 .../@stdlib/stats/iter/curange/test/test.js   | 66 +++++++-------
 .../@stdlib/stats/iter/cusum/test/test.js     | 66 +++++++-------
 .../@stdlib/stats/iter/cusumabs/test/test.js  | 66 +++++++-------
 .../@stdlib/stats/iter/cusumabs2/test/test.js | 66 +++++++-------
 .../@stdlib/stats/iter/mmax/test/test.js      | 62 ++++++-------
 .../@stdlib/stats/iter/mmaxabs/test/test.js   | 62 ++++++-------
 .../@stdlib/stats/iter/mmean/test/test.js     | 62 ++++++-------
 .../@stdlib/stats/iter/mmeanabs/test/test.js  | 62 ++++++-------
 .../@stdlib/stats/iter/mmeanabs2/test/test.js | 66 +++++++-------
 .../@stdlib/stats/iter/mmidrange/test/test.js | 62 ++++++-------
 .../@stdlib/stats/iter/mmin/test/test.js      | 62 ++++++-------
 .../@stdlib/stats/iter/mminabs/test/test.js   | 62 ++++++-------
 .../@stdlib/stats/iter/mprod/test/test.js     | 62 ++++++-------
 .../@stdlib/stats/iter/mrange/test/test.js    | 62 ++++++-------
 .../@stdlib/stats/iter/msum/test/test.js      | 62 ++++++-------
 .../@stdlib/stats/iter/msumabs/test/test.js   | 62 ++++++-------
 .../@stdlib/stats/iter/msumabs2/test/test.js  | 62 ++++++-------
 .../@stdlib/stats/iter/test/test.js           |  2 +-
 .../@stdlib/stats/kde2d/test/test.js          | 24 ++---
 .../@stdlib/stats/kde2d/test/test.validate.js | 24 ++---
 .../@stdlib/stats/kruskal-test/test/test.js   | 12 +--
 .../stats/kruskal-test/test/test.validate.js  | 10 +--
 .../@stdlib/stats/kstest/test/test.get_cdf.js | 50 +++++------
 .../@stdlib/stats/kstest/test/test.js         | 15 ++--
 .../stats/kstest/test/test.validate.js        | 12 +--
 .../@stdlib/stats/levene-test/test/test.js    | 12 +--
 .../stats/levene-test/test/test.validate.js   | 10 +--
 .../stats/lowess/test/test.validate.js        | 14 +--
 .../@stdlib/stats/padjust/test/test.js        | 16 ++--
 .../@stdlib/stats/pcorrtest/test/test.js      | 22 ++---
 .../stats/pcorrtest/test/test.validate.js     | 12 +--
 .../@stdlib/stats/ranks/test/test.validate.js | 10 +--
 .../@stdlib/stats/strided/test/test.js        |  2 +-
 lib/node_modules/@stdlib/stats/test/test.js   |  2 +-
 .../@stdlib/stats/ttest/test/test.js          | 16 ++--
 .../@stdlib/stats/ttest/test/test.validate.js | 16 ++--
 .../@stdlib/stats/ttest2/test/test.js         | 22 ++---
 .../stats/ttest2/test/test.validate.js        | 14 +--
 .../@stdlib/stats/vartest/test/test.js        | 20 ++---
 .../stats/vartest/test/test.validate.js       | 12 +--
 .../@stdlib/stats/wilcoxon/test/test.js       | 16 ++--
 .../stats/wilcoxon/test/test.validate.js      | 18 ++--
 .../@stdlib/stats/ztest/test/test.js          | 23 ++---
 .../@stdlib/stats/ztest/test/test.validate.js | 12 +--
 .../@stdlib/stats/ztest2/test/test.js         | 31 +++----
 .../stats/ztest2/test/test.validate.js        | 14 +--
 173 files changed, 2417 insertions(+), 2377 deletions(-)

diff --git a/lib/node_modules/@stdlib/stats/anova1/test/test.js b/lib/node_modules/@stdlib/stats/anova1/test/test.js
index 7636a056c705..aaa22cb10f3c 100644
--- a/lib/node_modules/@stdlib/stats/anova1/test/test.js
+++ b/lib/node_modules/@stdlib/stats/anova1/test/test.js
@@ -25,6 +25,7 @@ var randu = require( '@stdlib/random/base/randu' );
 var roundn = require( '@stdlib/math/base/special/roundn' );
 var contains = require( '@stdlib/assert/contains' );
 var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var anova1 = require( './../lib' );
 
 
@@ -191,14 +192,14 @@ tape( 'the function produces expected values on simple inputs', function test( t
 	out = anova1( x, f );
 
 	// Tested against R:
-	t.equal( out.treatment.df, 2 );
-	t.equal( out.treatment.ss, 3.75 );
-	t.equal( out.treatment.ms, 1.875 );
-	t.equal( out.error.df, 7 );
-	t.equal( out.error.ss, 96.75 );
-	t.equal( roundn(out.error.ms, -4), 13.8214 );
-	t.equal( roundn(out.statistic, -4), 0.1357 );
-	t.equal( roundn(out.pValue, -4), 0.8754 );
+	t.strictEqual( out.treatment.df, 2 );
+	t.strictEqual( out.treatment.ss, 3.75 );
+	t.strictEqual( out.treatment.ms, 1.875 );
+	t.strictEqual( out.error.df, 7 );
+	t.strictEqual( out.error.ss, 96.75 );
+	t.strictEqual( roundn(out.error.ms, -4), 13.8214 );
+	t.strictEqual( roundn(out.statistic, -4), 0.1357 );
+	t.strictEqual( roundn(out.pValue, -4), 0.8754 );
 	t.end();
 });
 
@@ -211,8 +212,8 @@ tape( 'the `.print()` method allows printing a formatted output table', function
 	var i;
 
 	len = 30;
-	vals = new Array( len );
-	group = new Array( len );
+	vals = zeros( len );
+	group = zeros( len );
 	for ( i = 0; i < len; i++ ) {
 		group[ i ] = discreteUniform( 0, 3 );
 		vals[ i ] = ( randu()*50.0 ) + ( 10.0*group[ i ] );
@@ -220,7 +221,7 @@ tape( 'the `.print()` method allows printing a formatted output table', function
 	actual = anova1( group, vals );
 	table = actual.print();
 
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 	t.end();
 });
 
@@ -233,8 +234,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	var i;
 
 	len = 30;
-	vals = new Array( len );
-	group = new Array( len );
+	vals = zeros( len );
+	group = zeros( len );
 	for ( i = 0; i < len; i++ ) {
 		group[ i ] = discreteUniform( 0, 3 );
 		vals[ i ] = ( randu()*50.0 ) + ( 10.0*group[ i ] );
@@ -243,7 +244,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = actual.print({
 		'digits': 6
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -256,8 +257,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	var i;
 
 	len = 30;
-	vals = new Array( len );
-	group = new Array( len );
+	vals = zeros( len );
+	group = zeros( len );
 	for ( i = 0; i < len; i++ ) {
 		group[ i ] = discreteUniform( 0, 3 );
 		vals[ i ] = ( randu()*50.0 ) + ( 10.0*group[ i ] );
@@ -266,8 +267,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = actual.print({
 		'decision': false
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -282,7 +283,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	out = anova1( x, f );
 	table = out.print( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/anova1/test/test.validate.js b/lib/node_modules/@stdlib/stats/anova1/test/test.validate.js
index 14f06b6bacfa..149b8e79109d 100644
--- a/lib/node_modules/@stdlib/stats/anova1/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/anova1/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -118,7 +118,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/array/test/test.js b/lib/node_modules/@stdlib/stats/array/test/test.js
index d1e6eeb4039e..30bee535777f 100644
--- a/lib/node_modules/@stdlib/stats/array/test/test.js
+++ b/lib/node_modules/@stdlib/stats/array/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'returns expected value' );
+	t.strictEqual( keys.length > 0, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/bartlett-test/test/test.js b/lib/node_modules/@stdlib/stats/bartlett-test/test/test.js
index d9c907e7395b..0c99b477c994 100644
--- a/lib/node_modules/@stdlib/stats/bartlett-test/test/test.js
+++ b/lib/node_modules/@stdlib/stats/bartlett-test/test/test.js
@@ -194,13 +194,13 @@ tape( 'the function returns an object with a `.print()` method for printing a fo
 
 	out = bartlettTest( x, y, z );
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 
 	out = bartlettTest( x, y, z, {
 		'alpha': 0.01
 	});
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -217,7 +217,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'digits': 6
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -233,8 +233,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'decision': false
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -249,7 +249,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	out = bartlettTest( x, y, z );
 	table = out.print( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/bartlett-test/test/test.validate.js b/lib/node_modules/@stdlib/stats/bartlett-test/test/test.validate.js
index f202e380474d..fe14730a1a64 100644
--- a/lib/node_modules/@stdlib/stats/bartlett-test/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/bartlett-test/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns a type error if provided a `groups` option which is
 		err = validate( {}, {
 			'groups': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -145,7 +145,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/test/test.js b/lib/node_modules/@stdlib/stats/base/ndarray/test/test.js
index d1e6eeb4039e..30bee535777f 100644
--- a/lib/node_modules/@stdlib/stats/base/ndarray/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'returns expected value' );
+	t.strictEqual( keys.length > 0, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/test/test.js b/lib/node_modules/@stdlib/stats/base/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/stats/base/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/binomial-test/test/test.js b/lib/node_modules/@stdlib/stats/binomial-test/test/test.js
index d07a8a29573b..40728d1d03e7 100644
--- a/lib/node_modules/@stdlib/stats/binomial-test/test/test.js
+++ b/lib/node_modules/@stdlib/stats/binomial-test/test/test.js
@@ -273,19 +273,19 @@ tape( 'the function returns an object with a `.print()` method for generating a
 
 	out = binomialTest( 682, 925 );
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = binomialTest( 682, 925, {
 		'alternative': 'less'
 	});
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = binomialTest( 682, 925, {
 		'alternative': 'greater'
 	});
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -297,7 +297,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'digits': 6
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -309,8 +309,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'decision': false
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -321,7 +321,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	out = binomialTest( 682, 925 );
 	table = out.print( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/binomial-test/test/test.validate.js b/lib/node_modules/@stdlib/stats/binomial-test/test/test.validate.js
index 7b9a0047dd5a..f41824c6e498 100644
--- a/lib/node_modules/@stdlib/stats/binomial-test/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/binomial-test/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns a type error if provided an `alternative` option whi
 		err = validate( {}, {
 			'alternative': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns a type error if provided a `p` option which is not a
 		err = validate( {}, {
 			'p': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -151,7 +151,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -172,7 +172,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/chi2gof/test/test.get_pmf.js b/lib/node_modules/@stdlib/stats/chi2gof/test/test.get_pmf.js
index 3481af6a9d5e..725026826c1b 100644
--- a/lib/node_modules/@stdlib/stats/chi2gof/test/test.get_pmf.js
+++ b/lib/node_modules/@stdlib/stats/chi2gof/test/test.get_pmf.js
@@ -40,13 +40,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns the correct PMF if provided a valid input string', function test( t ) {
-	t.equal( getPMF( 'bernoulli' ), bernoulliPMF );
-	t.equal( getPMF( 'binomial' ), binomialPMF );
-	t.equal( getPMF( 'discrete-uniform' ), discreteUniformPMF );
-	t.equal( getPMF( 'geometric' ), geometricPMF );
-	t.equal( getPMF( 'hypergeometric' ), hypergeometricPMF );
-	t.equal( getPMF( 'negative-binomial' ), negativeBinomialPMF );
-	t.equal( getPMF( 'poisson' ), poissonPMF );
+	t.strictEqual( getPMF( 'bernoulli' ), bernoulliPMF );
+	t.strictEqual( getPMF( 'binomial' ), binomialPMF );
+	t.strictEqual( getPMF( 'discrete-uniform' ), discreteUniformPMF );
+	t.strictEqual( getPMF( 'geometric' ), geometricPMF );
+	t.strictEqual( getPMF( 'hypergeometric' ), hypergeometricPMF );
+	t.strictEqual( getPMF( 'negative-binomial' ), negativeBinomialPMF );
+	t.strictEqual( getPMF( 'poisson' ), poissonPMF );
 	t.end();
 });
 
@@ -79,7 +79,7 @@ tape( 'the function returns an error if provided the name of a continuous distri
 
 	for ( i = 0; i < values.length; i++ ) {
 		out = getPMF( values[ i ] );
-		t.equal( out instanceof Error, true, 'returns an error when provided '+values[i] );
+		t.strictEqual( out instanceof Error, true, 'returns an error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -105,7 +105,7 @@ tape( 'the function returns an error if provided a name which does not match any
 
 	for ( i = 0; i < values.length; i++ ) {
 		out = getPMF( values[ i ] );
-		t.equal( out instanceof Error, true, 'returns an error when provided '+values[i] );
+		t.strictEqual( out instanceof Error, true, 'returns an error when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/chi2gof/test/test.js b/lib/node_modules/@stdlib/stats/chi2gof/test/test.js
index 8dd634041085..cf3d07830f3a 100644
--- a/lib/node_modules/@stdlib/stats/chi2gof/test/test.js
+++ b/lib/node_modules/@stdlib/stats/chi2gof/test/test.js
@@ -25,6 +25,7 @@ var contains = require( '@stdlib/assert/contains' );
 var poisson = require( '@stdlib/random/base/poisson' ).factory;
 var abs = require( '@stdlib/math/base/special/abs' );
 var EPS = require( '@stdlib/constants/float64/eps' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var chi2gof = require( './../lib' );
 
 
@@ -304,7 +305,7 @@ tape( 'the function computes the chi-square goodness-of-fit test (when `y` is a
 		'seed': 23
 	});
 
-	freq = new Array( 300 );
+	freq = zeros( 300 );
 	for ( j = 0; j < freq.length; j++ ) {
 		freq[ j ] = 0;
 	}
@@ -317,7 +318,7 @@ tape( 'the function computes the chi-square goodness-of-fit test (when `y` is a
 		'simulate': true,
 		'iterations': 500
 	}).pValue;
-	t.equal( typeof pValue, 'number', 'returns a p-value: '+pValue );
+	t.strictEqual( typeof pValue, 'number', 'returns a p-value: '+pValue );
 	t.end();
 });
 
@@ -333,7 +334,7 @@ tape( 'the function allows to correct the used degrees of freedom via the `ddof`
 		'ddof': 2
 	});
 
-	t.equal( out.df, 2, 'df is equal to two' );
+	t.strictEqual( out.df, 2, 'df is equal to two' );
 
 	t.end();
 });
@@ -351,7 +352,7 @@ tape( 'the function computes the p-value via Monte Carlo simulation when `simula
 		'iterations': 500
 	});
 
-	t.equal( typeof out.pValue, 'number', 'returns a number' );
+	t.strictEqual( typeof out.pValue, 'number', 'returns a number' );
 	t.end();
 });
 
@@ -367,13 +368,13 @@ tape( 'the function returns the correct decision giving different values of `alp
 		'alpha': 0.05
 	});
 
-	t.equal( out.rejected, true, 'rejects null hypothesis at alpha = 0.05' );
+	t.strictEqual( out.rejected, true, 'rejects null hypothesis at alpha = 0.05' );
 
 	out = chi2gof( x, p, {
 		'alpha': 0.01
 	});
 
-	t.equal( out.rejected, false, 'does not reject null hypothesis at alpha = 0.01' );
+	t.strictEqual( out.rejected, false, 'does not reject null hypothesis at alpha = 0.01' );
 
 	t.end();
 });
@@ -401,7 +402,7 @@ tape( 'the function returns an object with a `.toString()` method for printing a
 
 		Test Decision: Reject null in favor of alternative at 5% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 
 	out = chi2gof( x, p, {
 		'alpha': 0.01
@@ -419,7 +420,7 @@ tape( 'the function returns an object with a `.toString()` method for printing a
 
 		Test Decision: Fail to reject null in favor of alternative at 1% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 
 	// FIXME: actually test for expected output; e.g., split into lines and do line-by-line comparison
 
@@ -451,7 +452,7 @@ tape( 'the function returns an object with a `.toString()` method that accepts a
 
 		Test Decision: Reject null in favor of alternative at 5% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	// FIXME: this test does not actually assert the desired behavior!!!!
 
@@ -482,8 +483,8 @@ tape( 'the function returns an object with a `.toString()` method that accepts a
 			degrees of freedom: 4
 
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -499,7 +500,7 @@ tape( 'the function returns an object with a `.toString()` method that accepts a
 	out = chi2gof( x, p );
 	table = out.toString( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/chi2gof/test/test.validate.js b/lib/node_modules/@stdlib/stats/chi2gof/test/test.validate.js
index 93ab621af036..75adb7315963 100644
--- a/lib/node_modules/@stdlib/stats/chi2gof/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/chi2gof/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns a type error if provided a `ddof` option which is no
 		err = validate( {}, {
 			'ddof': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function returns a type error if provided a `iterations` option which
 		err = validate( {}, {
 			'iterations': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns a type error if provided a `simulate` option which i
 		err = validate( {}, {
 			'simulate': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -204,7 +204,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/chi2test/test/test.js b/lib/node_modules/@stdlib/stats/chi2test/test/test.js
index 5f207deaabb5..c8e1b0f84376 100644
--- a/lib/node_modules/@stdlib/stats/chi2test/test/test.js
+++ b/lib/node_modules/@stdlib/stats/chi2test/test/test.js
@@ -296,13 +296,13 @@ tape( 'the function returns the correct decision giving different values of `alp
 		'alpha': 0.05
 	});
 
-	t.equal( out.rejected, false, 'does not reject null hypothesis at alpha = 0.05' );
+	t.strictEqual( out.rejected, false, 'does not reject null hypothesis at alpha = 0.05' );
 
 	out = chi2test( x, {
 		'alpha': 0.1
 	});
 
-	t.equal( out.rejected, true, 'rejects null hypothesis at alpha = 0.1' );
+	t.strictEqual( out.rejected, true, 'rejects null hypothesis at alpha = 0.1' );
 
 	t.end();
 });
@@ -316,13 +316,13 @@ tape( 'the function returns an object with a `.toString()` method for printing a
 
 	out = chi2test( x );
 	table = out.toString();
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 
 	out = chi2test( x, {
 		'alpha': 0.01
 	});
 	table = out.toString();
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -337,7 +337,7 @@ tape( 'the function returns an object with a `.toString()` method that accepts a
 	table = out.toString({
 		'digits': 6
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -352,8 +352,8 @@ tape( 'the function returns an object with a `.toString()` method that accepts a
 	table = out.toString({
 		'decision': false
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -366,7 +366,7 @@ tape( 'the function returns an object with a `.toString()` method that accepts a
 	out = chi2test( x );
 	table = out.toString( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/chi2test/test/test.validate.js b/lib/node_modules/@stdlib/stats/chi2test/test/test.validate.js
index 16a694d9a53c..675d5339c930 100644
--- a/lib/node_modules/@stdlib/stats/chi2test/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/chi2test/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns a type error if provided a `correct` option which is
 		err = validate( {}, {
 			'correct': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -145,7 +145,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/fligner-test/test/test.js b/lib/node_modules/@stdlib/stats/fligner-test/test/test.js
index 3c0e21b91e5c..f2c37ea587ff 100644
--- a/lib/node_modules/@stdlib/stats/fligner-test/test/test.js
+++ b/lib/node_modules/@stdlib/stats/fligner-test/test/test.js
@@ -194,13 +194,13 @@ tape( 'the function returns an object with a `.print()` method for printing a fo
 
 	out = flignerTest( x, y, z );
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 
 	out = flignerTest( x, y, z, {
 		'alpha': 0.01
 	});
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -217,7 +217,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'digits': 6
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -233,8 +233,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'decision': false
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -249,7 +249,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	out = flignerTest( x, y, z );
 	table = out.print( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/fligner-test/test/test.validate.js b/lib/node_modules/@stdlib/stats/fligner-test/test/test.validate.js
index f202e380474d..fe14730a1a64 100644
--- a/lib/node_modules/@stdlib/stats/fligner-test/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/fligner-test/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns a type error if provided a `groups` option which is
 		err = validate( {}, {
 			'groups': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -145,7 +145,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/apcorr/test/test.js b/lib/node_modules/@stdlib/stats/incr/apcorr/test/test.js
index c4f9c79264fd..f884f65b3109 100644
--- a/lib/node_modules/@stdlib/stats/incr/apcorr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/apcorr/test/test.js
@@ -88,12 +88,12 @@ tape( 'the function throws an error if provided a non-numeric value for the seco
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrapcorr(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrapcorr(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.equal( typeof incrapcorr( 3.0, -5.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrapcorr( 3.0, -5.0 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -129,7 +129,7 @@ tape( 'the accumulator function incrementally computes a sample absolute correla
 		} else {
 			delta = abs( expected[ i ] - actual );
 			tol = 3.7 * EPS * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -167,7 +167,7 @@ tape( 'the accumulator function incrementally computes a sample absolute correla
 		} else {
 			delta = abs( expected[ i ] - actual );
 			tol = EPS * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -186,7 +186,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < x.length; i++ ) {
 		acc( x[ i ], y[ i ] );
 	}
-	t.equal( acc(), 0.7699852380946451, 'returns expected result' );
+	t.strictEqual( acc(), 0.7699852380946451, 'returns expected result' );
 	t.end();
 });
 
@@ -203,7 +203,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < x.length; i++ ) {
 		acc( x[ i ], y[ i ] );
 	}
-	t.equal( acc(), 0.7699852380946453, 'returns expected result' );
+	t.strictEqual( acc(), 0.7699852380946453, 'returns expected result' );
 	t.end();
 });
 
@@ -214,7 +214,7 @@ tape( 'the sample absolute correlation coefficient is `null` until at least 1 da
 	acc = incrapcorr();
 
 	v = acc();
-	t.equal( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns null' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
@@ -232,7 +232,7 @@ tape( 'the sample absolute correlation coefficient is `null` until at least 1 da
 	acc = incrapcorr( 3.0, -5.0 );
 
 	v = acc();
-	t.equal( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns null' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
@@ -250,10 +250,10 @@ tape( 'the sample absolute correlation coefficient is `0` until at least 2 datum
 	acc = incrapcorr();
 
 	v = acc( 2.0, 10.0 );
-	t.equal( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns 0' );
 
 	v = acc();
-	t.equal( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns 0' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, 0.0, 'does not return 0' );
@@ -281,10 +281,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrapcorr();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	data = [
 		[ 1.0, NaN ],
@@ -297,10 +297,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrapcorr();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -322,10 +322,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrapcorr( 3.14, 1.0 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	data = [
 		[ 1.0, NaN ],
@@ -338,10 +338,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrapcorr( 3.14, 1.0 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/count/test/test.js b/lib/node_modules/@stdlib/stats/incr/count/test/test.js
index de7ac2342d5c..8dc8377de0b3 100644
--- a/lib/node_modules/@stdlib/stats/incr/count/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/count/test/test.js
@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrcount = require( './../lib' );
 
 
@@ -33,13 +34,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrcount(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcount(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is zero', function test( t ) {
 	var acc = incrcount();
-	t.equal( acc(), 0, 'returns expected value' );
+	t.strictEqual( acc(), 0, 'returns expected value' );
 	t.end();
 });
 
@@ -56,8 +57,8 @@ tape( 'the accumulator function incrementally computes a count', function test(
 	data = [ 2.0, 3.0, 2.0, 4.0, 3.0, 4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrcount();
 
@@ -82,6 +83,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 3, 'returns the current accumulated count' );
+	t.strictEqual( acc(), 3, 'returns the current accumulated count' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/covariance/test/test.js b/lib/node_modules/@stdlib/stats/incr/covariance/test/test.js
index 1bbe37cb9271..608654c94258 100644
--- a/lib/node_modules/@stdlib/stats/incr/covariance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/covariance/test/test.js
@@ -88,12 +88,12 @@ tape( 'the function throws an error if provided a non-numeric value for the seco
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrcovariance(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcovariance(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.equal( typeof incrcovariance( 3.0, -5.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcovariance( 3.0, -5.0 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -129,7 +129,7 @@ tape( 'the accumulator function incrementally computes an unbiased sample covari
 		} else {
 			delta = abs( expected[ i ] - actual );
 			tol = 3.7 * EPS * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -167,7 +167,7 @@ tape( 'the accumulator function incrementally computes an unbiased sample covari
 		} else {
 			delta = abs( expected[ i ] - actual );
 			tol = EPS * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -186,7 +186,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < x.length; i++ ) {
 		acc( x[ i ], y[ i ] );
 	}
-	t.equal( acc(), -1.7, 'returns the current accumulated unbiased sample covariance' );
+	t.strictEqual( acc(), -1.7, 'returns the current accumulated unbiased sample covariance' );
 	t.end();
 });
 
@@ -203,7 +203,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < x.length; i++ ) {
 		acc( x[ i ], y[ i ] );
 	}
-	t.equal( acc(), -1.1333333333333335, 'returns the current accumulated unbiased sample covariance' );
+	t.strictEqual( acc(), -1.1333333333333335, 'returns the current accumulated unbiased sample covariance' );
 	t.end();
 });
 
@@ -214,7 +214,7 @@ tape( 'the sample covariance is `null` until at least 1 datum has been provided
 	acc = incrcovariance();
 
 	v = acc();
-	t.equal( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns null' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
@@ -232,7 +232,7 @@ tape( 'the sample covariance is `null` until at least 1 datum has been provided
 	acc = incrcovariance( 3.0, -5.0 );
 
 	v = acc();
-	t.equal( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns null' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
@@ -250,10 +250,10 @@ tape( 'the sample covariance is `0` until at least 2 datums have been provided (
 	acc = incrcovariance();
 
 	v = acc( 2.0, 10.0 );
-	t.equal( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns 0' );
 
 	v = acc();
-	t.equal( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns 0' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, 0.0, 'does not return 0' );
@@ -278,10 +278,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrcovariance();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	data = [
 		[ 1.0, NaN ],
@@ -294,10 +294,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrcovariance();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -319,10 +319,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrcovariance( 3.14, 1.0 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	data = [
 		[ 1.0, NaN ],
@@ -335,10 +335,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrcovariance( 3.14, 1.0 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/covmat/test/test.js b/lib/node_modules/@stdlib/stats/incr/covmat/test/test.js
index f42ba11c7277..b2ffc07c166f 100644
--- a/lib/node_modules/@stdlib/stats/incr/covmat/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/covmat/test/test.js
@@ -234,7 +234,7 @@ tape( 'the function throws an error if the number of known means does not match
 });
 
 tape( 'the function returns an accumulator function (order)', function test( t ) {
-	t.equal( typeof incrcovmat( 2 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcovmat( 2 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -249,7 +249,7 @@ tape( 'the function returns an accumulator function (covariance matrix)', functi
 	strides = [ 2, 1 ];
 	cov = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.equal( typeof incrcovmat( cov ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcovmat( cov ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -264,7 +264,7 @@ tape( 'the function returns an accumulator function (order; known means)', funct
 	strides = [ 1 ];
 	means = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.equal( typeof incrcovmat( 2, means ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcovmat( 2, means ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -285,7 +285,7 @@ tape( 'the function returns an accumulator function (covariance matrix; known me
 	strides = [ 1 ];
 	means = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.equal( typeof incrcovmat( cov, means ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcovmat( cov, means ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -640,7 +640,7 @@ tape( 'the accumulator function incrementally computes an unbiased sample covari
 				} else {
 					delta = abs( e - v );
 					tol = 3.0 * EPS * abs( e );
-					t.equal( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+					t.strictEqual( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
 				}
 			}
 		}
@@ -711,7 +711,7 @@ tape( 'the accumulator function incrementally computes an unbiased sample covari
 				} else {
 					delta = abs( e - v );
 					tol = 3.0 * EPS * abs( e );
-					t.equal( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+					t.strictEqual( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
 				}
 			}
 		}
@@ -779,7 +779,7 @@ tape( 'the accumulator function incrementally computes an unbiased sample covari
 				} else {
 					delta = abs( e - v );
 					tol = 3.0 * EPS * abs( e );
-					t.equal( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+					t.strictEqual( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
 				}
 			}
 		}
@@ -853,7 +853,7 @@ tape( 'the accumulator function incrementally computes an unbiased sample covari
 				} else {
 					delta = abs( e - v );
 					tol = 3.0 * EPS * abs( e );
-					t.equal( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+					t.strictEqual( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
 				}
 			}
 		}
diff --git a/lib/node_modules/@stdlib/stats/incr/cv/test/test.js b/lib/node_modules/@stdlib/stats/incr/cv/test/test.js
index 759c3e18862e..03ba0988a1bc 100644
--- a/lib/node_modules/@stdlib/stats/incr/cv/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/cv/test/test.js
@@ -23,6 +23,7 @@
 var tape = require( 'tape' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrcv = require( './../lib' );
 
 
@@ -35,12 +36,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrcv(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcv(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.equal( typeof incrcv( 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcv( 3.0 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -91,7 +92,7 @@ tape( 'the accumulator function incrementally computes the coefficient of variat
 
 	acc = incrcv();
 
-	actual = new Array( data.length );
+	actual = zeros( data.length );
 	for ( i = 0; i < data.length; i++ ) {
 		actual[ i ] = acc( data[ i ] );
 	}
@@ -120,7 +121,7 @@ tape( 'the accumulator function incrementally computes the coefficient of variat
 
 	acc = incrcv( 3.0 );
 
-	actual = new Array( data.length );
+	actual = zeros( data.length );
 	for ( i = 0; i < data.length; i++ ) {
 		actual[ i ] = acc( data[ i ] );
 	}
@@ -138,7 +139,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), sqrt( 1.0 )/2.0, 'returns expected value' );
+	t.strictEqual( acc(), sqrt( 1.0 )/2.0, 'returns expected value' );
 	t.end();
 });
 
@@ -152,7 +153,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), sqrt( 0.6666666666666666 )/2.0, 'returns expected value' );
+	t.strictEqual( acc(), sqrt( 0.6666666666666666 )/2.0, 'returns expected value' );
 	t.end();
 });
 
@@ -163,7 +164,7 @@ tape( 'the accumulated value is `null` until at least 1 datum has been provided
 	acc = incrcv();
 
 	cv = acc();
-	t.equal( cv, null, 'returns null' );
+	t.strictEqual( cv, null, 'returns null' );
 
 	cv = acc( 3.0 );
 	t.notEqual( cv, null, 'does not return null' );
@@ -181,7 +182,7 @@ tape( 'the accumulated value is `null` until at least 1 datum has been provided
 	acc = incrcv( 3.0 );
 
 	cv = acc();
-	t.equal( cv, null, 'returns null' );
+	t.strictEqual( cv, null, 'returns null' );
 
 	cv = acc( 3.0 );
 	t.notEqual( cv, null, 'does not return null' );
@@ -199,10 +200,10 @@ tape( 'the accumulated value is `0` until at least 2 datums have been provided (
 	acc = incrcv();
 
 	cv = acc( 2.0 );
-	t.equal( cv, 0.0, 'returns 0' );
+	t.strictEqual( cv, 0.0, 'returns 0' );
 
 	cv = acc();
-	t.equal( cv, 0.0, 'returns 0' );
+	t.strictEqual( cv, 0.0, 'returns 0' );
 
 	cv = acc( 3.0 );
 	t.notEqual( cv, 0.0, 'does not return 0' );
@@ -223,10 +224,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrcv();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -240,9 +241,9 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrcv( 3.14 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/ewmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/ewmean/test/test.js
index 823c4a1ca5f7..b578e2a0e84c 100644
--- a/lib/node_modules/@stdlib/stats/incr/ewmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/ewmean/test/test.js
@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var increwmean = require( './../lib' );
 
 
@@ -85,13 +86,13 @@ tape( 'the function throws an error if provided a nonnegative number which does
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof increwmean( 0.5 ), 'function', 'returns a function' );
+	t.strictEqual( typeof increwmean( 0.5 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = increwmean( 0.5 );
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -107,7 +108,7 @@ tape( 'the accumulator function incrementally computes an exponentially weighted
 	N = data.length;
 
 	expected = [ 2.0, 2.5, 2.25, 3.125, 3.0625, 3.53125 ];
-	actual = new Array( N );
+	actual = zeros( N );
 
 	acc = increwmean( 0.5 );
 
@@ -128,6 +129,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 1.75, 'returns the current accumulated mean' );
+	t.strictEqual( acc(), 1.75, 'returns the current accumulated mean' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/ewstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/ewstdev/test/test.js
index 5bc0a99804fb..570f98c0e1f7 100644
--- a/lib/node_modules/@stdlib/stats/incr/ewstdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/ewstdev/test/test.js
@@ -23,6 +23,7 @@
 var tape = require( 'tape' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var increwstdev = require( './../lib' );
 
 
@@ -87,13 +88,13 @@ tape( 'the function throws an error if provided a nonnegative number which does
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof increwstdev( 0.5 ), 'function', 'returns a function' );
+	t.strictEqual( typeof increwstdev( 0.5 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = increwstdev( 0.5 );
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -124,7 +125,7 @@ tape( 'the accumulator function incrementally computes an exponentially weighted
 		sqrt( (0.5*0.859375) + (0.25*pow( 3.0-3.125, 2 )) ), // m = 3.0625, s2 = 0.43359375
 		sqrt( (0.5*0.43359375) + (0.25*pow( 4.0-3.0625, 2 )) ) // m = 3.53125, s2 = 0.4365234375
 	];
-	actual = new Array( N );
+	actual = zeros( N );
 
 	acc = increwstdev( 0.5 );
 
@@ -149,6 +150,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), sqrt( 0.6875 ), 'returns expected value' );
+	t.strictEqual( acc(), sqrt( 0.6875 ), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/ewvariance/test/test.js b/lib/node_modules/@stdlib/stats/incr/ewvariance/test/test.js
index 0a28fb3d82b2..af7c264638eb 100644
--- a/lib/node_modules/@stdlib/stats/incr/ewvariance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/ewvariance/test/test.js
@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var pow = require( '@stdlib/math/base/special/pow' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var increwvariance = require( './../lib' );
 
 
@@ -86,13 +87,13 @@ tape( 'the function throws an error if provided a nonnegative number which does
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof increwvariance( 0.5 ), 'function', 'returns a function' );
+	t.strictEqual( typeof increwvariance( 0.5 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = increwvariance( 0.5 );
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -123,7 +124,7 @@ tape( 'the accumulator function incrementally computes an exponentially weighted
 		(0.5*0.859375) + (0.25*pow( 3.0-3.125, 2 )), // m = 3.0625, s2 = 0.43359375
 		(0.5*0.43359375) + (0.25*pow( 4.0-3.0625, 2 )) // m = 3.53125, s2 = 0.4365234375
 	];
-	actual = new Array( N );
+	actual = zeros( N );
 
 	acc = increwvariance( 0.5 );
 
@@ -148,6 +149,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 0.6875, 'returns expected value' );
+	t.strictEqual( acc(), 0.6875, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/hmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/hmean/test/test.js
index 149365fd922c..5b124c1f5655 100644
--- a/lib/node_modules/@stdlib/stats/incr/hmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/hmean/test/test.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrhmean(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrhmean(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is null', function test( t ) {
 	var acc = incrhmean();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -89,6 +89,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 1.6363636363636365, 'returns the current accumulated harmonic mean' );
+	t.strictEqual( acc(), 1.6363636363636365, 'returns the current accumulated harmonic mean' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/incr/kurtosis/test/test.js
index 4cf17208c35e..96b7435326c8 100644
--- a/lib/node_modules/@stdlib/stats/incr/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/kurtosis/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrkurtosis(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrkurtosis(), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -66,7 +66,7 @@ tape( 'the accumulator function incrementally computes a corrected sample excess
 	for ( i = 0; i < data.length; i++ ) {
 		actual = acc( data[ i ] );
 		if ( expected[i] === null ) {
-			t.equal( actual, null, 'returns null' );
+			t.strictEqual( actual, null, 'returns null' );
 		} else {
 			delta = abs( actual - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
@@ -88,7 +88,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 		acc( data[ i ] );
 	}
 
-	t.equal( acc(), -6.0, 'returns the current accumulated corrected sample excess kurtosis' );
+	t.strictEqual( acc(), -6.0, 'returns the current accumulated corrected sample excess kurtosis' );
 	t.end();
 });
 
@@ -99,16 +99,16 @@ tape( 'the corrected sample excess kurtosis is `null` until at least 4 datums ha
 	acc = incrkurtosis();
 
 	out = acc();
-	t.equal( out, null, 'returns null' );
+	t.strictEqual( out, null, 'returns null' );
 
 	out = acc( 2.0 );
-	t.equal( out, null, 'returns null' );
+	t.strictEqual( out, null, 'returns null' );
 
 	out = acc( 8.0 );
-	t.equal( out, null, 'returns null' );
+	t.strictEqual( out, null, 'returns null' );
 
 	out = acc( -4.0 );
-	t.equal( out, null, 'returns null' );
+	t.strictEqual( out, null, 'returns null' );
 
 	out = acc( 3.0 );
 	t.notEqual( out, null, 'does not return null' );
@@ -126,9 +126,9 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrkurtosis();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/maape/test/test.js b/lib/node_modules/@stdlib/stats/incr/maape/test/test.js
index 39c0ecf146c8..6bdcf47286ef 100644
--- a/lib/node_modules/@stdlib/stats/incr/maape/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/maape/test/test.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmaape(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmaape(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrmaape();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -79,11 +79,11 @@ tape( 'the accumulator function incrementally computes the mean arctangent absol
 		expected = sum / (i+1);
 		actual = acc( x, y );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value' );
+			t.strictEqual( actual, expected, 'returns expected value' );
 		} else {
 			delta = abs( expected - actual );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -111,6 +111,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	expected = 1.0 / 3.0 * ( atan(1.0/3.0) + atan(2.0/5.0) + atan(9.0/1.0) );
 	delta = abs( expected - actual );
 	tol = 1.5 * EPS * abs( expected );
-	t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+	t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mae/test/test.js b/lib/node_modules/@stdlib/stats/incr/mae/test/test.js
index ee6767167270..16657f9dd859 100644
--- a/lib/node_modules/@stdlib/stats/incr/mae/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mae/test/test.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmae(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmae(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrmae();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -78,11 +78,11 @@ tape( 'the accumulator function incrementally computes the mean absolute error',
 		expected = sum / (i+1);
 		actual = acc( x, y );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value' );
+			t.strictEqual( actual, expected, 'returns expected value' );
 		} else {
 			delta = abs( expected - actual );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -102,6 +102,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ][ 0 ], data[ i ][ 1 ] );
 	}
-	t.equal( acc(), 6.0, 'returns expected value' );
+	t.strictEqual( acc(), 6.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mapcorr/test/test.js b/lib/node_modules/@stdlib/stats/incr/mapcorr/test/test.js
index 6894a3f67d38..f92f213d983c 100644
--- a/lib/node_modules/@stdlib/stats/incr/mapcorr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mapcorr/test/test.js
@@ -27,6 +27,7 @@ var pow = require( '@stdlib/math/base/special/pow' );
 var sqrt = require( '@stdlib/math/base/special/sqrt' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var EPS = require( '@stdlib/constants/float64/eps' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmapcorr = require( './../lib' );
 
 
@@ -178,9 +179,9 @@ function datasets( N, M, seed ) {
 	});
 
 	// Generate datasets consisting of (x,y) pairs of varying value ranges...
-	data = new Array( N );
+	data = zeros( N );
 	for ( i = 0; i < N; i++ ) {
-		tmp = new Array( M );
+		tmp = zeros( M );
 		for ( j = 0; j < M; j++ ) {
 			tmp[ j ] = [
 				rand() * pow( 10.0, i ),
@@ -316,12 +317,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmapcorr( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmapcorr( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.equal( typeof incrmapcorr( 3, 3.0, 3.14 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmapcorr( 3, 3.0, 3.14 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -363,11 +364,11 @@ tape( 'the accumulator function computes a moving sample absolute Pearson produc
 			means = mean( [ 0.0, 0.0 ], arr );
 			expected = apcorr( arr, means[ 0 ], means[ 1 ], false );
 			if ( actual === expected ) {
-				t.equal( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
+				t.strictEqual( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
 			} else {
 				delta = abs( actual - expected );
 				tol = 5.0e5 * EPS * abs( expected );
-				t.equal( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+				t.strictEqual( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
 		}
 	}
@@ -411,11 +412,11 @@ tape( 'the accumulator function computes a moving sample absolute Pearson produc
 			}
 			expected = apcorr( arr, means[ 0 ], means[ 1 ], true );
 			if ( actual === expected ) {
-				t.equal( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
+				t.strictEqual( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
 			} else {
 				delta = abs( actual - expected );
 				tol = 5.0e5 * EPS * abs( expected );
-				t.equal( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+				t.strictEqual( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
 		}
 	}
@@ -458,11 +459,11 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 		means = mean( [ 0.0, 0.0 ], d );
 		expected = apcorr( d, means[ 0 ], means[ 1 ], false );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value. window: '+i+'.' );
+			t.strictEqual( actual, expected, 'returns expected value. window: '+i+'.' );
 		} else {
 			delta = abs( actual - expected );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -504,11 +505,11 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 		}
 		expected = apcorr( d, means[ 0 ], means[ 1 ], true );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value. window: '+i+'.' );
+			t.strictEqual( actual, expected, 'returns expected value. window: '+i+'.' );
 		} else {
 			delta = abs( actual - expected );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -516,20 +517,20 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmapcorr( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known means)', function test( t ) {
 	var acc = incrmapcorr( 3, 3.0, 3.14 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if only one datum has been provided and the means are unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmapcorr( 3 );
 	acc( 2.0, 3.14 );
-	t.equal( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -548,7 +549,7 @@ tape( 'if the window size is `1` and the means are unknown, the accumulator func
 	acc = incrmapcorr( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		r = acc( randu()*100.0, randu()*100.0 );
-		t.equal( r, 0.0, 'returns 0' );
+		t.strictEqual( r, 0.0, 'returns 0' );
 	}
 	t.end();
 });
@@ -628,15 +629,15 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else if ( v === expected[ i ] ) {
-			t.equal( v, expected[ i ], 'returns expected value for window: '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window: '+i );
 		} else {
 			delta = abs( v - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
-			t.equal( acc(), v, 'returns expected value for window '+i );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( acc(), v, 'returns expected value for window '+i );
 		}
 	}
 
@@ -669,15 +670,15 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else if ( v === expected[ i ] ) {
-			t.equal( v, expected[ i ], 'returns expected value for window: '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window: '+i );
 		} else {
 			delta = abs( v - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
-			t.equal( acc(), v, 'returns expected value for window '+i );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( acc(), v, 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -743,11 +744,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -780,11 +781,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mape/test/test.js b/lib/node_modules/@stdlib/stats/incr/mape/test/test.js
index 0f46c4e5b082..a6a5b3002329 100644
--- a/lib/node_modules/@stdlib/stats/incr/mape/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mape/test/test.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmape(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmape(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrmape();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -78,11 +78,11 @@ tape( 'the accumulator function incrementally computes the mean absolute percent
 		expected = 100.0 * ( sum/(i+1) );
 		actual = acc( x, y );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value' );
+			t.strictEqual( actual, expected, 'returns expected value' );
 		} else {
 			delta = abs( expected - actual );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -110,6 +110,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	expected = 100.0 / 3.0 * ((1.0/3.0) + (2.0/5.0) + (9.0/1.0));
 	delta = abs( expected - actual );
 	tol = 1.0 * EPS * abs( expected );
-	t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+	t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/max/test/test.js b/lib/node_modules/@stdlib/stats/incr/max/test/test.js
index 5b406da80612..35fbc38acff3 100644
--- a/lib/node_modules/@stdlib/stats/incr/max/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/max/test/test.js
@@ -24,6 +24,7 @@ var tape = require( 'tape' );
 var isNegativeZero = require( '@stdlib/math/base/assert/is-negative-zero' );
 var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmax = require( './../lib' );
 
 
@@ -36,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmax(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmax(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'if not provided any values, the initial returned maximum value is `null`', function test( t ) {
 	var acc = incrmax();
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -59,8 +60,8 @@ tape( 'the accumulator function incrementally computes a maximum value', functio
 	data = [ 2.0, 3.0, 2.0, 4.0, 3.0, 4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrmax();
 
@@ -87,7 +88,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 3.0, 'returns the current accumulated maximum value' );
+	t.strictEqual( acc(), 3.0, 'returns the current accumulated maximum value' );
 	t.end();
 });
 
@@ -98,13 +99,13 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 	acc = incrmax();
 
 	v = acc( -0.0 );
-	t.equal( isNegativeZero( v ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	v = acc( 0.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = acc( -0.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -119,6 +120,6 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/maxabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/maxabs/test/test.js
index 25f8a7118990..66a1ebff31e3 100644
--- a/lib/node_modules/@stdlib/stats/incr/maxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/maxabs/test/test.js
@@ -24,6 +24,7 @@ var tape = require( 'tape' );
 var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var abs = require( '@stdlib/math/base/special/abs' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmaxabs = require( './../lib' );
 
 
@@ -36,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmaxabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmaxabs(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'if not provided any values, the initial returned maximum absolute value is `null`', function test( t ) {
 	var acc = incrmaxabs();
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -60,8 +61,8 @@ tape( 'the accumulator function incrementally computes a maximum absolute value'
 	data = [ 2.0, -3.0, 2.0, -4.0, 3.0, 4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrmaxabs();
 
@@ -89,7 +90,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 3.0, 'returns expected value' );
+	t.strictEqual( acc(), 3.0, 'returns expected value' );
 	t.end();
 });
 
@@ -100,13 +101,13 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 	acc = incrmaxabs();
 
 	v = acc( -0.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = acc( 0.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = acc( -0.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -121,6 +122,6 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mcovariance/test/test.js b/lib/node_modules/@stdlib/stats/incr/mcovariance/test/test.js
index e41084344472..8f4688a5d9a9 100644
--- a/lib/node_modules/@stdlib/stats/incr/mcovariance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mcovariance/test/test.js
@@ -26,6 +26,7 @@ var abs = require( '@stdlib/math/base/special/abs' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var EPS = require( '@stdlib/constants/float64/eps' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmcovariance = require( './../lib' );
 
 
@@ -112,9 +113,9 @@ function datasets( N, M, seed ) {
 	});
 
 	// Generate datasets consisting of (x,y) pairs of varying value ranges...
-	data = new Array( N );
+	data = zeros( N );
 	for ( i = 0; i < N; i++ ) {
-		tmp = new Array( M );
+		tmp = zeros( M );
 		for ( j = 0; j < M; j++ ) {
 			tmp[ j ] = [
 				rand() * pow( 10.0, i ),
@@ -250,12 +251,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmcovariance( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmcovariance( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.equal( typeof incrmcovariance( 3, 3.0, 3.14 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmcovariance( 3, 3.0, 3.14 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -297,11 +298,11 @@ tape( 'the accumulator function computes a moving unbiased sample covariance inc
 			means = mean( [ 0.0, 0.0 ], arr );
 			expected = covariance( arr, means[ 0 ], means[ 1 ], false );
 			if ( actual === expected ) {
-				t.equal( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
+				t.strictEqual( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
 			} else {
 				delta = abs( actual - expected );
 				tol = 5.0e5 * EPS * abs( expected );
-				t.equal( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+				t.strictEqual( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
 		}
 	}
@@ -345,11 +346,11 @@ tape( 'the accumulator function computes a moving unbiased sample covariance inc
 			}
 			expected = covariance( arr, means[ 0 ], means[ 1 ], true );
 			if ( actual === expected ) {
-				t.equal( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
+				t.strictEqual( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
 			} else {
 				delta = abs( actual - expected );
 				tol = 5.0e5 * EPS * abs( expected );
-				t.equal( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+				t.strictEqual( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
 		}
 	}
@@ -392,11 +393,11 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 		means = mean( [ 0.0, 0.0 ], d );
 		expected = covariance( d, means[ 0 ], means[ 1 ], false );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value. window: '+i+'.' );
+			t.strictEqual( actual, expected, 'returns expected value. window: '+i+'.' );
 		} else {
 			delta = abs( actual - expected );
 			tol = 1.5 * EPS * abs( expected );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -438,11 +439,11 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 		}
 		expected = covariance( d, means[ 0 ], means[ 1 ], true );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value. window: '+i+'.' );
+			t.strictEqual( actual, expected, 'returns expected value. window: '+i+'.' );
 		} else {
 			delta = abs( actual - expected );
 			tol = EPS * abs( expected );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -450,20 +451,20 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmcovariance( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known means)', function test( t ) {
 	var acc = incrmcovariance( 3, 3.0, 3.14 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if only one datum has been provided and the means are unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmcovariance( 3 );
 	acc( 2.0, 3.14 );
-	t.equal( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -482,7 +483,7 @@ tape( 'if the window size is `1` and the means are unknown, the accumulator func
 	acc = incrmcovariance( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		cov = acc( randu()*100.0, randu()*100.0 );
-		t.equal( cov, 0.0, 'returns 0' );
+		t.strictEqual( cov, 0.0, 'returns 0' );
 	}
 	t.end();
 });
@@ -556,11 +557,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -591,11 +592,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -657,11 +658,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -692,11 +693,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mcv/test/test.js b/lib/node_modules/@stdlib/stats/incr/mcv/test/test.js
index 6c962474edff..85088cd744ab 100644
--- a/lib/node_modules/@stdlib/stats/incr/mcv/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mcv/test/test.js
@@ -26,6 +26,7 @@ var abs = require( '@stdlib/math/base/special/abs' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var EPS = require( '@stdlib/constants/float64/eps' );
 var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmcv = require( './../lib' );
 
 
@@ -125,12 +126,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmcv( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmcv( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.equal( typeof incrmcv( 3, 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmcv( 3, 3.0 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -156,7 +157,7 @@ tape( 'the accumulator function computes a moving coefficient of variation incre
 
 	acc = incrmcv( 3 );
 
-	actual = new Array( N );
+	actual = zeros( N );
 	for ( i = 0; i < N; i++ ) {
 		actual[ i ] = acc( data[ i ] );
 	}
@@ -177,7 +178,7 @@ tape( 'the accumulator function computes a moving coefficient of variation incre
 
 	acc = incrmcv( 3, 2.0 );
 
-	actual = new Array( N );
+	actual = zeros( N );
 	for ( i = 0; i < N; i++ ) {
 		actual[ i ] = acc( data[ i ] );
 	}
@@ -207,7 +208,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length-1; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), sqrt( 0.5 )/2.5, 'returns expected value' );
+	t.strictEqual( acc(), sqrt( 0.5 )/2.5, 'returns expected value' );
 
 	acc( data[ data.length-1 ] );
 
@@ -216,7 +217,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	delta = abs( actual - expected );
 	tol = EPS * expected;
 
-	t.equal( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+	t.strictEqual( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 	t.end();
 });
 
@@ -234,7 +235,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length-1; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), sqrt( 6.5 )/5.0, 'returns expected value' );
+	t.strictEqual( acc(), sqrt( 6.5 )/5.0, 'returns expected value' );
 
 	acc( data[ data.length-1 ] );
 
@@ -243,26 +244,26 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	delta = abs( actual - expected );
 	tol = EPS * expected;
 
-	t.equal( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+	t.strictEqual( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmcv( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known mean)', function test( t ) {
 	var acc = incrmcv( 3, 3.0 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if only one datum has been provided and the mean is unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmcv( 3 );
 	acc( 2.0 );
-	t.equal( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -281,7 +282,7 @@ tape( 'if the window size is `1` and the mean is unknown, the accumulator functi
 	acc = incrmcv( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		cv = acc( randu() * 100.0 );
-		t.equal( cv, 0.0, 'returns 0' );
+		t.strictEqual( cv, 0.0, 'returns 0' );
 	}
 	t.end();
 });
@@ -353,11 +354,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -417,11 +418,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -481,11 +482,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -545,11 +546,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mda/test/test.js b/lib/node_modules/@stdlib/stats/incr/mda/test/test.js
index b0312cedb7b5..264347586191 100644
--- a/lib/node_modules/@stdlib/stats/incr/mda/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mda/test/test.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmda(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmda(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrmda();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -78,11 +78,11 @@ tape( 'the accumulator function incrementally computes the mean directional accu
 	for ( i = 0; i < N; i++ ) {
 		actual = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
 		if ( actual === expected[ i ] ) {
-			t.equal( actual, expected[ i ], 'returns expected value' );
+			t.strictEqual( actual, expected[ i ], 'returns expected value' );
 		} else {
 			delta = abs( expected[ i ] - actual );
 			tol = 1.0 * EPS * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[ i ]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[ i ]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -102,6 +102,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ][ 0 ], data[ i ][ 1 ] );
 	}
-	t.equal( acc(), 2.0/3.0, 'returns expected value' );
+	t.strictEqual( acc(), 2.0/3.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/me/test/test.js b/lib/node_modules/@stdlib/stats/incr/me/test/test.js
index 05397ffd388a..3e03a3da2e56 100644
--- a/lib/node_modules/@stdlib/stats/incr/me/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/me/test/test.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrme(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrme(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrme();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -78,11 +78,11 @@ tape( 'the accumulator function incrementally computes the mean error', function
 		expected = sum / (i+1);
 		actual = acc( x, y );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value' );
+			t.strictEqual( actual, expected, 'returns expected value' );
 		} else {
 			delta = abs( expected - actual );
 			tol = 6.0 * EPS * abs( expected );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -110,6 +110,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	expected = 2.0 / 3.0;
 	delta = abs( expected - actual );
 	tol = 3.0 * EPS * abs( expected );
-	t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+	t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mean/test/test.js b/lib/node_modules/@stdlib/stats/incr/mean/test/test.js
index 27a61a7d22ce..774d5d5a68e5 100644
--- a/lib/node_modules/@stdlib/stats/incr/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mean/test/test.js
@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmean = require( './../lib' );
 
 
@@ -33,13 +34,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmean(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmean(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrmean();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -56,8 +57,8 @@ tape( 'the accumulator function incrementally computes an arithmetic mean', func
 	data = [ 2.0, 3.0, 2.0, 4.0, 3.0, 4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrmean();
 
@@ -82,6 +83,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 2.0, 'returns the current accumulated mean' );
+	t.strictEqual( acc(), 2.0, 'returns the current accumulated mean' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/meanabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/meanabs/test/test.js
index 4228d794459d..4b9aa0f7bc61 100644
--- a/lib/node_modules/@stdlib/stats/incr/meanabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/meanabs/test/test.js
@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmeanabs = require( './../lib' );
 
 
@@ -33,13 +34,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmeanabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmeanabs(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrmeanabs();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -56,8 +57,8 @@ tape( 'the accumulator function incrementally computes an arithmetic mean of abs
 	data = [ 2.0, -3.0, 2.0, -4.0, 3.0, -4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrmeanabs();
 
@@ -82,6 +83,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 2.0, 'returns expected value' );
+	t.strictEqual( acc(), 2.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/meanabs2/test/test.js b/lib/node_modules/@stdlib/stats/incr/meanabs2/test/test.js
index 1c1c22b89cb0..70470c79e2a1 100644
--- a/lib/node_modules/@stdlib/stats/incr/meanabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/meanabs2/test/test.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmeanabs2(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmeanabs2(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrmeanabs2();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -69,11 +69,11 @@ tape( 'the accumulator function incrementally computes an arithmetic mean of squ
 		expected = sum / (i+1);
 		actual = acc( d );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value' );
+			t.strictEqual( actual, expected, 'returns expected value' );
 		} else {
 			delta = abs( expected - actual );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -89,6 +89,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 14.0/3.0, 'returns expected value' );
+	t.strictEqual( acc(), 14.0/3.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/meanstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/meanstdev/test/test.js
index 882abbb30870..26f2d2cc4874 100644
--- a/lib/node_modules/@stdlib/stats/incr/meanstdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/meanstdev/test/test.js
@@ -63,12 +63,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmeanstdev(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmeanstdev(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.equal( typeof incrmeanstdev( [ 0.0, 0.0 ] ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmeanstdev( [ 0.0, 0.0 ] ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -128,7 +128,7 @@ tape( 'the accumulator function incrementally computes an arithmetic mean and co
 
 	for ( i = 0; i < N; i++ ) {
 		actual = acc( data[ i ] );
-		t.equal( actual, out, 'returns output array' );
+		t.strictEqual( actual, out, 'returns output array' );
 		t.deepEqual( actual, expected[ i ], 'returns expected value' );
 	}
 	t.end();
@@ -150,9 +150,9 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmeanstdev();
-	t.equal( acc(), null, 'returns null' );
-	t.equal( acc(), null, 'returns null' );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -163,13 +163,13 @@ tape( 'the sample standard deviation is `0` until at least 2 datums have been pr
 	acc = incrmeanstdev();
 
 	ms = acc();
-	t.equal( ms, null, 'returns null' );
+	t.strictEqual( ms, null, 'returns null' );
 
 	ms = acc( 3.0 );
-	t.equal( ms[ 1 ], 0.0, 'returns expected value' );
+	t.strictEqual( ms[ 1 ], 0.0, 'returns expected value' );
 
 	ms = acc();
-	t.equal( ms[ 1 ], 0.0, 'returns expected value' );
+	t.strictEqual( ms[ 1 ], 0.0, 'returns expected value' );
 
 	ms = acc( 5.0 );
 	t.notEqual( ms[ 1 ], 0.0, 'does not return 0' );
@@ -190,12 +190,12 @@ tape( 'if provided `NaN`, the accumulated values are `NaN` for all future invoca
 	acc = incrmeanstdev();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
-		t.equal( isnan( v[ 0 ] ), true, 'returns expected value' );
-		t.equal( isnan( v[ 1 ] ), true, 'returns expected value' );
+		t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value' );
+		t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value' );
 
 		v = acc();
-		t.equal( isnan( v[ 0 ] ), true, 'returns expected value' );
-		t.equal( isnan( v[ 1 ] ), true, 'returns expected value' );
+		t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value' );
+		t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/meanvar/test/test.js b/lib/node_modules/@stdlib/stats/incr/meanvar/test/test.js
index d27d0fd59be6..a3c9b59f740c 100644
--- a/lib/node_modules/@stdlib/stats/incr/meanvar/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/meanvar/test/test.js
@@ -62,12 +62,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmeanvar(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmeanvar(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.equal( typeof incrmeanvar( [ 0.0, 0.0 ] ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmeanvar( [ 0.0, 0.0 ] ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -127,7 +127,7 @@ tape( 'the accumulator function incrementally computes an arithmetic mean and un
 
 	for ( i = 0; i < N; i++ ) {
 		actual = acc( data[ i ] );
-		t.equal( actual, out, 'returns output array' );
+		t.strictEqual( actual, out, 'returns output array' );
 		t.deepEqual( actual, expected[ i ], 'returns expected value' );
 	}
 	t.end();
@@ -149,9 +149,9 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmeanvar();
-	t.equal( acc(), null, 'returns null' );
-	t.equal( acc(), null, 'returns null' );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -162,13 +162,13 @@ tape( 'the sample variance is `0` until at least 2 datums have been provided', f
 	acc = incrmeanvar();
 
 	mv = acc();
-	t.equal( mv, null, 'returns null' );
+	t.strictEqual( mv, null, 'returns null' );
 
 	mv = acc( 3.0 );
-	t.equal( mv[ 1 ], 0.0, 'returns expected value' );
+	t.strictEqual( mv[ 1 ], 0.0, 'returns expected value' );
 
 	mv = acc();
-	t.equal( mv[ 1 ], 0.0, 'returns expected value' );
+	t.strictEqual( mv[ 1 ], 0.0, 'returns expected value' );
 
 	mv = acc( 5.0 );
 	t.notEqual( mv[ 1 ], 0.0, 'does not return 0' );
@@ -189,12 +189,12 @@ tape( 'if provided `NaN`, the accumulated values are `NaN` for all future invoca
 	acc = incrmeanvar();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
-		t.equal( isnan( v[ 0 ] ), true, 'returns expected value' );
-		t.equal( isnan( v[ 1 ] ), true, 'returns expected value' );
+		t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value' );
+		t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value' );
 
 		v = acc();
-		t.equal( isnan( v[ 0 ] ), true, 'returns expected value' );
-		t.equal( isnan( v[ 1 ] ), true, 'returns expected value' );
+		t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value' );
+		t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mgmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/mgmean/test/test.js
index 5d0a2637bf4d..b4c9eb22edcc 100644
--- a/lib/node_modules/@stdlib/stats/incr/mgmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mgmean/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmgmean( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmgmean( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -101,11 +101,11 @@ tape( 'the accumulator function computes a moving geometric mean incrementally',
 
 	for ( i = 0; i < N; i++ ) {
 		if ( actual[ i ] === expected[ i ] ) {
-			t.equal( actual[ i ], expected[ i ], 'returns expected value' );
+			t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' );
 		} else {
 			delta = abs( expected[ i ] - actual[ i ] );
 			tol = 1.2 * EPSILON * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'within tolerance. Expected: '+expected[ i ]+'. Actual: '+actual[ i ]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Expected: '+expected[ i ]+'. Actual: '+actual[ i ]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -129,13 +129,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	expected = 3.872983346207417; // Note: computed by hand using textbook formula
 	delta = abs( expected - actual );
 	tol = 1.0 * EPSILON * abs( expected );
-	t.equal( delta <= tol, true, 'within tolerance. Expected: '+expected+'. Actual: '+actual+'. Delta: '+delta+'. Tol: '+tol+'.' );
+	t.strictEqual( delta <= tol, true, 'within tolerance. Expected: '+expected+'. Actual: '+actual+'. Delta: '+delta+'. Tol: '+tol+'.' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmgmean( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -195,13 +195,13 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else if ( v === expected[ i ] ) {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		} else {
 			delta = abs( expected[ i ] - v );
 			tol = 1.0 * EPSILON * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'within tolerance for window '+i+'. Expected: '+expected[ i ]+'. Actual: '+v+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance for window '+i+'. Expected: '+expected[ i ]+'. Actual: '+v+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.meanstdev.js b/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.meanstdev.js
index dc7761bb850b..6156ce4836fd 100644
--- a/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.meanstdev.js
+++ b/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.meanstdev.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmeanstdev( [ 0.0, 0.0 ], 3, [ 0.0, 0.0, 0.0 ] ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanstdev( [ 0.0, 0.0 ], 3, [ 0.0, 0.0, 0.0 ] ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -81,8 +81,8 @@ tape( 'the accumulator function computes a moving arithmetic mean and corrected
 tape( 'if only one datum has been provided, the accumulator function returns `0` for the sample standard deviation', function test( t ) {
 	var acc = incrmmeanstdev( [ 0.0, 0.0 ], 3, [ 0.0, 0.0, 0.0 ] );
 	var v = acc( 2.0, 0 );
-	t.equal( v[ 0 ], 2.0, 'returns expected value' );
-	t.equal( v[ 1 ], 0.0, 'returns expected value' );
+	t.strictEqual( v[ 0 ], 2.0, 'returns expected value' );
+	t.strictEqual( v[ 1 ], 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -99,8 +99,8 @@ tape( 'if the window size is `1`, the accumulator functions always returns `0` f
 		v = randu() * 100.0;
 		out = acc( v, 0 );
 		buf[ 0 ] = v;
-		t.equal( out[ 0 ], v, 'returns expected value' );
-		t.equal( out[ 1 ], 0.0, 'returns expected value' );
+		t.strictEqual( out[ 0 ], v, 'returns expected value' );
+		t.strictEqual( out[ 1 ], 0.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -166,11 +166,11 @@ tape( 'if provided `NaN`, the accumulated values are both `NaN` for at least `W`
 		v = acc( data[ i ], j );
 		buf[ j ] = data[ i ];
 		if ( isnan( expected[ i ][ 0 ] ) ) {
-			t.equal( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
-			t.equal( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
-			t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -233,11 +233,11 @@ tape( 'if provided `NaN`, the accumulated values are both `NaN` for at least `W`
 		v = acc( data[ i ], 0 );
 		buf[ 0 ] = data[ i ];
 		if ( isnan( expected[ i ][ 0 ] ) ) {
-			t.equal( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
-			t.equal( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
-			t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.minmax.js b/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.minmax.js
index e4049e54f605..9f3be5197acf 100644
--- a/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.minmax.js
+++ b/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.minmax.js
@@ -23,6 +23,7 @@
 var tape = require( 'tape' );
 var isNegativeZero = require( '@stdlib/math/base/assert/is-negative-zero' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmminmax = require( './../lib/minmax.js' );
 
 
@@ -35,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmminmax( [ 0.0, 0.0 ], 3, [ 0.0, 0.0, 0.0 ] ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmminmax( [ 0.0, 0.0 ], 3, [ 0.0, 0.0, 0.0 ] ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -59,12 +60,12 @@ tape( 'the accumulator function computes a moving minimum and maximum incrementa
 	buf = [ 0.0, 0.0, 0.0 ];
 	acc = incrmminmax( out, W, buf );
 
-	actual = new Array( N );
+	actual = zeros( N );
 	for ( i = 0; i < N; i++ ) {
 		j = i % W;
 		actual[ i ] = acc( data[ i ], j );
 		buf[ j ] = data[ i ];
-		t.equal( actual[ i ], out, 'returns output array' );
+		t.strictEqual( actual[ i ], out, 'returns output array' );
 		actual[ i ] = actual[ i ].slice();
 	}
 	expected = [
@@ -330,16 +331,16 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 		if ( expected[ i ][ 0 ] === 0.0 ) {
 			sgn1 = isNegativeZero( v[ 0 ] );
 			sgn2 = isNegativeZero( expected[ i ][ 0 ] );
-			t.equal( sgn1, sgn2, 'returns expected signed zero minimum for window '+i+'. v: '+( ( isNegativeZero( data[ i ] ) ) ? '-' : '+' )+data[ i ]+'. actual: '+( ( sgn1 ) ? '-' : '+' )+v[ 0 ]+'. expected: '+( ( sgn2 ) ? '-' : '+' )+expected[ i ][ 0 ]+'.' );
+			t.strictEqual( sgn1, sgn2, 'returns expected signed zero minimum for window '+i+'. v: '+( ( isNegativeZero( data[ i ] ) ) ? '-' : '+' )+data[ i ]+'. actual: '+( ( sgn1 ) ? '-' : '+' )+v[ 0 ]+'. expected: '+( ( sgn2 ) ? '-' : '+' )+expected[ i ][ 0 ]+'.' );
 		} else {
-			t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected minimum for window '+i+'. v: '+data[ i ]+'. actual: '+v[ 0 ]+'. expected: '+expected[ i ][ 0 ]+'.' );
+			t.strictEqual( v[ 0 ], expected[ i ][ 0 ], 'returns expected minimum for window '+i+'. v: '+data[ i ]+'. actual: '+v[ 0 ]+'. expected: '+expected[ i ][ 0 ]+'.' );
 		}
 		if ( expected[ i ][ 1 ] === 0.0 ) {
 			sgn1 = isNegativeZero( v[ 1 ] );
 			sgn2 = isNegativeZero( expected[ i ][ 1 ] );
-			t.equal( sgn1, sgn2, 'returns expected signed zero maximum for window '+i+'. v: '+( ( isNegativeZero( data[ i ] ) ) ? '-' : '+' )+data[ i ]+'. actual: '+( ( sgn1 ) ? '-' : '+' )+v[ 1 ]+'. expected: '+( ( sgn2 ) ? '-' : '+' )+expected[ i ][ 1 ]+'.' );
+			t.strictEqual( sgn1, sgn2, 'returns expected signed zero maximum for window '+i+'. v: '+( ( isNegativeZero( data[ i ] ) ) ? '-' : '+' )+data[ i ]+'. actual: '+( ( sgn1 ) ? '-' : '+' )+v[ 1 ]+'. expected: '+( ( sgn2 ) ? '-' : '+' )+expected[ i ][ 1 ]+'.' );
 		} else {
-			t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected maximum for window '+i+'. v: '+data[ i ]+'. actual: '+v[ 1 ]+'. expected: '+expected[ i ][ 1 ]+'.' );
+			t.strictEqual( v[ 1 ], expected[ i ][ 1 ], 'returns expected maximum for window '+i+'. v: '+data[ i ]+'. actual: '+v[ 1 ]+'. expected: '+expected[ i ][ 1 ]+'.' );
 		}
 	}
 	t.end();
@@ -446,8 +447,8 @@ tape( 'if provided `NaN`, the accumulated minimum and maximum values are `NaN` f
 		v = acc( data[ i ], j );
 		buf[ j ] = data[ i ];
 		if ( isnan( expected[ i ][ 0 ] ) ) {
-			t.equal( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
-			t.equal( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
 		} else {
 			t.deepEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
diff --git a/lib/node_modules/@stdlib/stats/incr/mhmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/mhmean/test/test.js
index a64ba817807e..cf84bf440266 100644
--- a/lib/node_modules/@stdlib/stats/incr/mhmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mhmean/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmhmean( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmhmean( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -101,11 +101,11 @@ tape( 'the accumulator function computes a moving harmonic mean incrementally',
 
 	for ( i = 0; i < N; i++ ) {
 		if ( actual[ i ] === expected[ i ] ) {
-			t.equal( actual[ i ], expected[ i ], 'returns expected value' );
+			t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' );
 		} else {
 			delta = abs( expected[ i ] - actual[ i ] );
 			tol = EPSILON * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'within tolerance. Expected: '+expected[ i ]+'. Actual: '+actual[ i ]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Expected: '+expected[ i ]+'. Actual: '+actual[ i ]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -129,13 +129,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	expected = 3.75; // Note: computed by hand using textbook formula
 	delta = abs( expected - actual );
 	tol = 1.1 * EPSILON * abs( expected );
-	t.equal( delta <= tol, true, 'within tolerance. Expected: '+expected+'. Actual: '+actual+'. Delta: '+delta+'. Tol: '+tol+'.' );
+	t.strictEqual( delta <= tol, true, 'within tolerance. Expected: '+expected+'. Actual: '+actual+'. Delta: '+delta+'. Tol: '+tol+'.' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmhmean( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -193,9 +193,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/midrange/test/test.js b/lib/node_modules/@stdlib/stats/incr/midrange/test/test.js
index 7c62bda0bd33..d6584327f899 100644
--- a/lib/node_modules/@stdlib/stats/incr/midrange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/midrange/test/test.js
@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmidrange = require( './../lib' );
 
 
@@ -34,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmidrange(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmidrange(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'if not provided any values, the initial returned mid-range is `null`', function test( t ) {
 	var acc = incrmidrange();
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -58,8 +59,8 @@ tape( 'the accumulator function incrementally computes a mid-range', function te
 	data = [ 2.0, 3.0, -2.0, 4.0, -3.0, 4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrmidrange();
 
@@ -89,7 +90,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 0.5, 'returns the current accumulated mid-range' );
+	t.strictEqual( acc(), 0.5, 'returns the current accumulated mid-range' );
 	t.end();
 });
 
@@ -103,6 +104,6 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/min/test/test.js b/lib/node_modules/@stdlib/stats/incr/min/test/test.js
index 06c5112da8cf..da5e2502a192 100644
--- a/lib/node_modules/@stdlib/stats/incr/min/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/min/test/test.js
@@ -24,6 +24,7 @@ var tape = require( 'tape' );
 var isNegativeZero = require( '@stdlib/math/base/assert/is-negative-zero' );
 var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmin = require( './../lib' );
 
 
@@ -36,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmin(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmin(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'if not provided any values, the initial returned minimum value is `null`', function test( t ) {
 	var acc = incrmin();
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -59,8 +60,8 @@ tape( 'the accumulator function incrementally computes a minimum value', functio
 	data = [ 2.0, 3.0, 1.0, 4.0, 3.0, 4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrmin();
 
@@ -87,7 +88,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 1.0, 'returns the current accumulated minimum value' );
+	t.strictEqual( acc(), 1.0, 'returns the current accumulated minimum value' );
 	t.end();
 });
 
@@ -98,13 +99,13 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 	acc = incrmin();
 
 	v = acc( 0.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = acc( -0.0 );
-	t.equal( isNegativeZero( v ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	v = acc( 0.0 );
-	t.equal( isNegativeZero( v ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -119,6 +120,6 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/minabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/minabs/test/test.js
index 7f6eca6ddc58..a4e992b23de7 100644
--- a/lib/node_modules/@stdlib/stats/incr/minabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/minabs/test/test.js
@@ -24,6 +24,7 @@ var tape = require( 'tape' );
 var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var abs = require( '@stdlib/math/base/special/abs' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrminabs = require( './../lib' );
 
 
@@ -36,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrminabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrminabs(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'if not provided any values, the initial returned minimum absolute value is `null`', function test( t ) {
 	var acc = incrminabs();
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -60,8 +61,8 @@ tape( 'the accumulator function incrementally computes a minimum absolute value'
 	data = [ 2.0, -3.0, 2.0, -4.0, 3.0, 4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrminabs();
 
@@ -89,7 +90,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 1.0, 'returns expected value' );
+	t.strictEqual( acc(), 1.0, 'returns expected value' );
 	t.end();
 });
 
@@ -100,13 +101,13 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 	acc = incrminabs();
 
 	v = acc( -0.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = acc( 0.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = acc( -0.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -121,6 +122,6 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/minmax/test/test.js b/lib/node_modules/@stdlib/stats/incr/minmax/test/test.js
index 9419340c87da..d0f71992adf0 100644
--- a/lib/node_modules/@stdlib/stats/incr/minmax/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/minmax/test/test.js
@@ -64,12 +64,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrminmax(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrminmax(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.equal( typeof incrminmax( [ 0.0, 0.0 ] ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrminmax( [ 0.0, 0.0 ] ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -128,7 +128,7 @@ tape( 'the accumulator function computes a minimum and maximum incrementally (ou
 	actual = [];
 	for ( i = 0; i < N; i++ ) {
 		actual.push( acc( data[ i ] ) );
-		t.equal( actual[ i ], out, 'returns output array' );
+		t.strictEqual( actual[ i ], out, 'returns output array' );
 		actual[ i ] = actual[ i ].slice();
 	}
 	expected = [
@@ -167,7 +167,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrminmax();
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -178,30 +178,30 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 	acc = incrminmax();
 
 	v = acc( 0.0 );
-	t.equal( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
 
 	v = acc( -0.0 );
-	t.equal( isNegativeZero( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
 
 	v = acc( 0.0 );
-	t.equal( isNegativeZero( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
 
 	acc = incrminmax();
 
 	v = acc( -0.0 );
-	t.equal( isNegativeZero( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isNegativeZero( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( v[ 1 ] ), true, 'returns expected value' );
 
 	v = acc( 0.0 );
-	t.equal( isNegativeZero( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
 
 	v = acc( -0.0 );
-	t.equal( isNegativeZero( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -218,7 +218,7 @@ tape( 'if provided `NaN`, the accumulated minimum and maximum values are `NaN` f
 		acc( data[ i ] );
 	}
 	v = acc();
-	t.equal( isnan( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isnan( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/minmaxabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/minmaxabs/test/test.js
index af1f0126ff99..033bbc3c3bff 100644
--- a/lib/node_modules/@stdlib/stats/incr/minmaxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/minmaxabs/test/test.js
@@ -63,12 +63,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrminmaxabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrminmaxabs(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.equal( typeof incrminmaxabs( [ 0.0, 0.0 ] ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrminmaxabs( [ 0.0, 0.0 ] ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -155,7 +155,7 @@ tape( 'the accumulator function computes a minimum and maximum absolute value in
 	actual = [];
 	for ( i = 0; i < N; i++ ) {
 		actual.push( acc( data[ i ] ) );
-		t.equal( actual[ i ], out, 'returns output array' );
+		t.strictEqual( actual[ i ], out, 'returns output array' );
 		actual[ i ] = actual[ i ].slice();
 	}
 	expected = [
@@ -194,7 +194,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrminmaxabs();
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -205,30 +205,30 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 	acc = incrminmaxabs();
 
 	v = acc( 0.0 );
-	t.equal( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
 
 	v = acc( -0.0 );
-	t.equal( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
 
 	v = acc( 0.0 );
-	t.equal( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
 
 	acc = incrminmaxabs();
 
 	v = acc( -0.0 );
-	t.equal( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
 
 	v = acc( 0.0 );
-	t.equal( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
 
 	v = acc( -0.0 );
-	t.equal( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v[ 1 ] ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -245,7 +245,7 @@ tape( 'if provided `NaN`, the accumulated minimum and maximum values are `NaN` f
 		acc( data[ i ] );
 	}
 	v = acc();
-	t.equal( isnan( v[ 0 ] ), true, 'returns expected value' );
-	t.equal( isnan( v[ 1 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mmaape/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmaape/test/test.js
index 4caae463284c..cf0702f40f9e 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmaape/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmaape/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmaape( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmaape( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -105,11 +105,11 @@ tape( 'the accumulator function computes a moving mean arctangent absolute perce
 	for ( i = 0; i < N; i++ ) {
 		actual = acc( data[i][0], data[i][1] );
 		if ( actual === expected[i] ) {
-			t.equal( actual, expected[i], 'returns expected value' );
+			t.strictEqual( actual, expected[i], 'returns expected value' );
 		} else {
 			delta = abs( expected[i] - actual );
 			tol = 1.0 * EPS * abs( expected[i] );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -129,13 +129,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[i][0], data[i][1] );
 	}
-	t.equal( acc(), 0.5*( atan(2.0/5.0)+atan(9.0/10.0) ), 'returns expected value' );
+	t.strictEqual( acc(), 0.5*( atan(2.0/5.0)+atan(9.0/10.0) ), 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmaape( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -195,11 +195,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -252,11 +252,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mmae/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmae/test/test.js
index 3018c5469908..0903e87f8d2c 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmae/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmae/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmae( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmae( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -112,13 +112,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[i][0], data[i][1] );
 	}
-	t.equal( acc(), 8.5, 'returns expected value' );
+	t.strictEqual( acc(), 8.5, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmae( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -178,11 +178,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -213,11 +213,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mmape/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmape/test/test.js
index 26a618502382..407d176a5d17 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmape/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmape/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmape( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmape( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -104,11 +104,11 @@ tape( 'the accumulator function computes a moving mean absolute percentage error
 	for ( i = 0; i < N; i++ ) {
 		actual = acc( data[i][0], data[i][1] );
 		if ( actual === expected[i] ) {
-			t.equal( actual, expected[i], 'returns expected value' );
+			t.strictEqual( actual, expected[i], 'returns expected value' );
 		} else {
 			delta = abs( expected[i] - actual );
 			tol = 1.5 * EPS * abs( expected[i] );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -128,13 +128,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[i][0], data[i][1] );
 	}
-	t.equal( acc(), 65.0, 'returns expected value' );
+	t.strictEqual( acc(), 65.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmape( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -194,11 +194,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -251,11 +251,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mmax/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmax/test/test.js
index d03db08c4655..78fba8df5e06 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmax/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmax/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmax( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmax( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -104,13 +104,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 5.0, 'returns expected value' );
+	t.strictEqual( acc(), 5.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmax( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -156,9 +156,9 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isPositiveZero( expected[ i ] ) ) {
-			t.equal( isPositiveZero( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isPositiveZero( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( isNegativeZero( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isNegativeZero( v ), true, 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -218,9 +218,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mmaxabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmaxabs/test/test.js
index 7971b1ca685c..c919385c3112 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmaxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmaxabs/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmaxabs( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmaxabs( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -104,13 +104,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 5.0, 'returns expected value' );
+	t.strictEqual( acc(), 5.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmaxabs( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -156,9 +156,9 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isPositiveZero( expected[ i ] ) ) {
-			t.equal( isPositiveZero( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isPositiveZero( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( isNegativeZero( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isNegativeZero( v ), true, 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -218,9 +218,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mmda/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmda/test/test.js
index c3d3d5ed34d2..6d42fa8c8305 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmda/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmda/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmda( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmda( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -108,11 +108,11 @@ tape( 'the accumulator function computes a moving mean directional accuracy incr
 	for ( i = 0; i < N; i++ ) {
 		actual = acc( data[i][0], data[i][1] );
 		if ( actual === expected[i] ) {
-			t.equal( actual, expected[i], 'returns expected value' );
+			t.strictEqual( actual, expected[i], 'returns expected value' );
 		} else {
 			delta = abs( expected[i] - actual );
 			tol = 1.0 * EPS * abs( expected[i] );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -132,13 +132,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[i][0], data[i][1] );
 	}
-	t.equal( acc(), 0.5, 'returns expected value' );
+	t.strictEqual( acc(), 0.5, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmda( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -202,11 +202,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -263,11 +263,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mme/test/test.js b/lib/node_modules/@stdlib/stats/incr/mme/test/test.js
index 1c8365c624c5..76b7cbf3e7f4 100644
--- a/lib/node_modules/@stdlib/stats/incr/mme/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mme/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmme( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmme( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -96,11 +96,11 @@ tape( 'the accumulator function computes a moving mean error incrementally', fun
 	for ( i = 0; i < N; i++ ) {
 		actual = acc( data[i][0], data[i][1] );
 		if ( actual === expected[i] ) {
-			t.equal( actual, expected[i], 'returns expected value' );
+			t.strictEqual( actual, expected[i], 'returns expected value' );
 		} else {
 			delta = abs( expected[i] - actual );
 			tol = 1.0 * EPS * abs( expected[i] );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -120,13 +120,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[i][0], data[i][1] );
 	}
-	t.equal( acc(), 0.5, 'returns expected value' );
+	t.strictEqual( acc(), 0.5, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmme( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -186,11 +186,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -243,11 +243,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmean/test/test.js
index 4ebc75b7616f..7e389bc41c8c 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmean/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmean( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmean( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -101,13 +101,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 4.0, 'returns expected value' );
+	t.strictEqual( acc(), 4.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmean( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -165,9 +165,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mmeanabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmeanabs/test/test.js
index d8e621bb860b..6bf4fd96c621 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmeanabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmeanabs/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmeanabs( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanabs( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -101,13 +101,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 4.0, 'returns expected value' );
+	t.strictEqual( acc(), 4.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmeanabs( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -165,9 +165,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mmeanabs2/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmeanabs2/test/test.js
index 3de297e271c6..6cb5b7e6fc2e 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmeanabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmeanabs2/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmeanabs2( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanabs2( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -89,11 +89,11 @@ tape( 'the accumulator function computes a moving arithmetic mean of squared abs
 	for ( i = 0; i < N; i++ ) {
 		actual = acc( data[ i ] );
 		if ( actual === expected[i] ) {
-			t.equal( actual, expected[i], 'returns expected value' );
+			t.strictEqual( actual, expected[i], 'returns expected value' );
 		} else {
 			delta = abs( expected[i] - actual );
 			tol = 1.0 * EPS * abs( expected[i] );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -109,13 +109,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 17.0, 'returns expected value' );
+	t.strictEqual( acc(), 17.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmeanabs2( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -173,9 +173,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mmeanstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmeanstdev/test/test.js
index c817bf0998c3..f9e6dae2b26b 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmeanstdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmeanstdev/test/test.js
@@ -158,12 +158,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmeanstdev( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanstdev( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.equal( typeof incrmmeanstdev( [ 0.0, 0.0 ], 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanstdev( [ 0.0, 0.0 ], 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -247,26 +247,26 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	expected = [ 5.0, sqrt( 19.0 ) ];
 	actual = acc();
 
-	t.equal( actual[ 0 ], expected[ 0 ], 'returns expected value' );
+	t.strictEqual( actual[ 0 ], expected[ 0 ], 'returns expected value' );
 
 	delta = abs( actual[ 1 ] - expected[ 1 ] );
 	tol = EPS * expected[ 1 ];
-	t.equal( delta < tol, true, 'expected: '+expected[ 1 ]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+	t.strictEqual( delta < tol, true, 'expected: '+expected[ 1 ]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmeanstdev( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if only one datum has been provided, the accumulator function returns `0` for the sample standard deviation', function test( t ) {
 	var acc = incrmmeanstdev( 3 );
 	var v = acc( 2.0 );
-	t.equal( v[ 0 ], 2.0, 'returns expected value' );
-	t.equal( v[ 1 ], 0.0, 'returns expected value' );
+	t.strictEqual( v[ 0 ], 2.0, 'returns expected value' );
+	t.strictEqual( v[ 1 ], 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -280,8 +280,8 @@ tape( 'if the window size is `1`, the accumulator functions always returns `0` f
 	for ( i = 0; i < 100; i++ ) {
 		v = randu() * 100.0;
 		out = acc( v );
-		t.equal( out[ 0 ], v, 'returns expected value' );
-		t.equal( out[ 1 ], 0.0, 'returns expected value' );
+		t.strictEqual( out[ 0 ], v, 'returns expected value' );
+		t.strictEqual( out[ 1 ], 0.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -340,19 +340,19 @@ tape( 'if provided `NaN`, the accumulated values are both `NaN` for at least `W`
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ][ 0 ] ) ) {
-			t.equal( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
-			t.equal( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
 
 			v = acc();
-			t.equal( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
-			t.equal( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
-			t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
 
 			v = acc();
-			t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
-			t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -412,19 +412,19 @@ tape( 'if provided `NaN`, the accumulated values are both `NaN` for at least `W`
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ][ 0 ] ) ) {
-			t.equal( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
-			t.equal( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
 
 			v = acc();
-			t.equal( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
-			t.equal( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
-			t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
 
 			v = acc();
-			t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
-			t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mmeanvar/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmeanvar/test/test.js
index a913ec96f88d..7d33a2c10e7b 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmeanvar/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmeanvar/test/test.js
@@ -157,12 +157,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmeanvar( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanvar( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.equal( typeof incrmmeanvar( [ 0.0, 0.0 ], 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanvar( [ 0.0, 0.0 ], 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -246,26 +246,26 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	expected = [ 5.0, 19.0 ];
 	actual = acc();
 
-	t.equal( actual[ 0 ], expected[ 0 ], 'returns expected value' );
+	t.strictEqual( actual[ 0 ], expected[ 0 ], 'returns expected value' );
 
 	delta = abs( actual[ 1 ] - expected[ 1 ] );
 	tol = EPS * expected[ 1 ];
-	t.equal( delta < tol, true, 'expected: '+expected[ 1 ]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+	t.strictEqual( delta < tol, true, 'expected: '+expected[ 1 ]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmeanvar( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if only one datum has been provided, the accumulator function returns `0` for the sample variance', function test( t ) {
 	var acc = incrmmeanvar( 3 );
 	var v = acc( 2.0 );
-	t.equal( v[ 0 ], 2.0, 'returns expected value' );
-	t.equal( v[ 1 ], 0.0, 'returns expected value' );
+	t.strictEqual( v[ 0 ], 2.0, 'returns expected value' );
+	t.strictEqual( v[ 1 ], 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -279,8 +279,8 @@ tape( 'if the window size is `1`, the accumulator functions always returns `0` f
 	for ( i = 0; i < 100; i++ ) {
 		v = randu() * 100.0;
 		out = acc( v );
-		t.equal( out[ 0 ], v, 'returns expected value' );
-		t.equal( out[ 1 ], 0.0, 'returns expected value' );
+		t.strictEqual( out[ 0 ], v, 'returns expected value' );
+		t.strictEqual( out[ 1 ], 0.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -339,19 +339,19 @@ tape( 'if provided `NaN`, the accumulated values are both `NaN` for at least `W`
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ][ 0 ] ) ) {
-			t.equal( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
-			t.equal( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
 
 			v = acc();
-			t.equal( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
-			t.equal( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
-			t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
 
 			v = acc();
-			t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
-			t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -411,19 +411,19 @@ tape( 'if provided `NaN`, the accumulated values are both `NaN` for at least `W`
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ][ 0 ] ) ) {
-			t.equal( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
-			t.equal( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
 
 			v = acc();
-			t.equal( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
-			t.equal( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
-			t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
 
 			v = acc();
-			t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
-			t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 0 ], expected[ i ][ 0 ], 'returns expected value for window '+i );
+			t.strictEqual( v[ 1 ], expected[ i ][ 1 ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mmidrange/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmidrange/test/test.js
index 061b1410ac91..cd14223f1a6e 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmidrange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmidrange/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmidrange( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmidrange( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -117,13 +117,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 4.5, 'returns expected value' );
+	t.strictEqual( acc(), 4.5, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmidrange( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -359,9 +359,9 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( expected[ i ] === 0.0 ) {
-			t.equal( isNegativeZero( v ), isNegativeZero( expected[ i ] ), 'returns expected value for window '+i );
+			t.strictEqual( isNegativeZero( v ), isNegativeZero( expected[ i ] ), 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -461,9 +461,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mmin/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmin/test/test.js
index c52a4da4ee0e..8a4d28824083 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmin/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmin/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmin( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmin( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -104,13 +104,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 4.0, 'returns expected value' );
+	t.strictEqual( acc(), 4.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmin( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -156,9 +156,9 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isNegativeZero( expected[ i ] ) ) {
-			t.equal( isNegativeZero( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isNegativeZero( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( isPositiveZero( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isPositiveZero( v ), true, 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -218,9 +218,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mminabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/mminabs/test/test.js
index 6f6a1cf22129..2ba6a20d4ee2 100644
--- a/lib/node_modules/@stdlib/stats/incr/mminabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mminabs/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmminabs( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmminabs( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -104,13 +104,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 4.0, 'returns expected value' );
+	t.strictEqual( acc(), 4.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmminabs( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -156,9 +156,9 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isPositiveZero( expected[ i ] ) ) {
-			t.equal( isPositiveZero( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isPositiveZero( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( isNegativeZero( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isNegativeZero( v ), true, 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -218,9 +218,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mminmax/test/test.js b/lib/node_modules/@stdlib/stats/incr/mminmax/test/test.js
index def44dc42a32..549770bd9eb0 100644
--- a/lib/node_modules/@stdlib/stats/incr/mminmax/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mminmax/test/test.js
@@ -125,12 +125,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmminmax( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmminmax( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.equal( typeof incrmminmax( [ 0.0, 0.0 ], 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmminmax( [ 0.0, 0.0 ], 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -189,7 +189,7 @@ tape( 'the accumulator function computes a moving minimum and maximum incrementa
 	actual = [];
 	for ( i = 0; i < N; i++ ) {
 		actual.push( acc( data[ i ] ) );
-		t.equal( actual[ i ], out, 'returns output array' );
+		t.strictEqual( actual[ i ], out, 'returns output array' );
 		actual[ i ] = actual[ i ].slice();
 	}
 	expected = [
@@ -228,7 +228,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmminmax( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -468,16 +468,16 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 		if ( expected[ i ][ 0 ] === 0.0 ) {
 			sgn1 = isNegativeZero( v[ 0 ] );
 			sgn2 = isNegativeZero( expected[ i ][ 0 ] );
-			t.equal( sgn1, sgn2, 'returns expected signed zero minimum for window '+i+'. v: '+( ( isNegativeZero( data[ i ] ) ) ? '-' : '+' )+data[ i ]+'. actual: '+( ( sgn1 ) ? '-' : '+' )+v[ 0 ]+'. expected: '+( ( sgn2 ) ? '-' : '+' )+expected[ i ][ 0 ]+'.' );
+			t.strictEqual( sgn1, sgn2, 'returns expected signed zero minimum for window '+i+'. v: '+( ( isNegativeZero( data[ i ] ) ) ? '-' : '+' )+data[ i ]+'. actual: '+( ( sgn1 ) ? '-' : '+' )+v[ 0 ]+'. expected: '+( ( sgn2 ) ? '-' : '+' )+expected[ i ][ 0 ]+'.' );
 		} else {
-			t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected minimum for window '+i+'. v: '+data[ i ]+'. actual: '+v[ 0 ]+'. expected: '+expected[ i ][ 0 ]+'.' );
+			t.strictEqual( v[ 0 ], expected[ i ][ 0 ], 'returns expected minimum for window '+i+'. v: '+data[ i ]+'. actual: '+v[ 0 ]+'. expected: '+expected[ i ][ 0 ]+'.' );
 		}
 		if ( expected[ i ][ 1 ] === 0.0 ) {
 			sgn1 = isNegativeZero( v[ 1 ] );
 			sgn2 = isNegativeZero( expected[ i ][ 1 ] );
-			t.equal( sgn1, sgn2, 'returns expected signed zero maximum for window '+i+'. v: '+( ( isNegativeZero( data[ i ] ) ) ? '-' : '+' )+data[ i ]+'. actual: '+( ( sgn1 ) ? '-' : '+' )+v[ 1 ]+'. expected: '+( ( sgn2 ) ? '-' : '+' )+expected[ i ][ 1 ]+'.' );
+			t.strictEqual( sgn1, sgn2, 'returns expected signed zero maximum for window '+i+'. v: '+( ( isNegativeZero( data[ i ] ) ) ? '-' : '+' )+data[ i ]+'. actual: '+( ( sgn1 ) ? '-' : '+' )+v[ 1 ]+'. expected: '+( ( sgn2 ) ? '-' : '+' )+expected[ i ][ 1 ]+'.' );
 		} else {
-			t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected maximum for window '+i+'. v: '+data[ i ]+'. actual: '+v[ 1 ]+'. expected: '+expected[ i ][ 1 ]+'.' );
+			t.strictEqual( v[ 1 ], expected[ i ][ 1 ], 'returns expected maximum for window '+i+'. v: '+data[ i ]+'. actual: '+v[ 1 ]+'. expected: '+expected[ i ][ 1 ]+'.' );
 		}
 	}
 	t.end();
@@ -577,8 +577,8 @@ tape( 'if provided `NaN`, the accumulated minimum and maximum values are `NaN` f
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ][ 0 ] ) ) {
-			t.equal( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
-			t.equal( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
 		} else {
 			t.deepEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
diff --git a/lib/node_modules/@stdlib/stats/incr/mminmaxabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/mminmaxabs/test/test.js
index a167408c524b..a80a70f99b95 100644
--- a/lib/node_modules/@stdlib/stats/incr/mminmaxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mminmaxabs/test/test.js
@@ -125,12 +125,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmminmaxabs( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmminmaxabs( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.equal( typeof incrmminmaxabs( [ 0.0, 0.0 ], 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmminmaxabs( [ 0.0, 0.0 ], 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -217,7 +217,7 @@ tape( 'the accumulator function computes moving minimum and maximum absolute val
 	actual = [];
 	for ( i = 0; i < N; i++ ) {
 		actual.push( acc( data[ i ] ) );
-		t.equal( actual[ i ], out, 'returns output array' );
+		t.strictEqual( actual[ i ], out, 'returns output array' );
 		actual[ i ] = actual[ i ].slice();
 	}
 	expected = [
@@ -256,7 +256,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmminmaxabs( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -496,16 +496,16 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 		if ( expected[ i ][ 0 ] === 0.0 ) {
 			sgn1 = isNegativeZero( v[ 0 ] );
 			sgn2 = isNegativeZero( expected[ i ][ 0 ] );
-			t.equal( sgn1, sgn2, 'returns expected signed zero minimum for window '+i+'. v: '+( ( isNegativeZero( data[ i ] ) ) ? '-' : '+' )+data[ i ]+'. actual: '+( ( sgn1 ) ? '-' : '+' )+v[ 0 ]+'. expected: '+( ( sgn2 ) ? '-' : '+' )+expected[ i ][ 0 ]+'.' );
+			t.strictEqual( sgn1, sgn2, 'returns expected signed zero minimum for window '+i+'. v: '+( ( isNegativeZero( data[ i ] ) ) ? '-' : '+' )+data[ i ]+'. actual: '+( ( sgn1 ) ? '-' : '+' )+v[ 0 ]+'. expected: '+( ( sgn2 ) ? '-' : '+' )+expected[ i ][ 0 ]+'.' );
 		} else {
-			t.equal( v[ 0 ], expected[ i ][ 0 ], 'returns expected minimum for window '+i+'. v: '+data[ i ]+'. actual: '+v[ 0 ]+'. expected: '+expected[ i ][ 0 ]+'.' );
+			t.strictEqual( v[ 0 ], expected[ i ][ 0 ], 'returns expected minimum for window '+i+'. v: '+data[ i ]+'. actual: '+v[ 0 ]+'. expected: '+expected[ i ][ 0 ]+'.' );
 		}
 		if ( expected[ i ][ 1 ] === 0.0 ) {
 			sgn1 = isNegativeZero( v[ 1 ] );
 			sgn2 = isNegativeZero( expected[ i ][ 1 ] );
-			t.equal( sgn1, sgn2, 'returns expected signed zero maximum for window '+i+'. v: '+( ( isNegativeZero( data[ i ] ) ) ? '-' : '+' )+data[ i ]+'. actual: '+( ( sgn1 ) ? '-' : '+' )+v[ 1 ]+'. expected: '+( ( sgn2 ) ? '-' : '+' )+expected[ i ][ 1 ]+'.' );
+			t.strictEqual( sgn1, sgn2, 'returns expected signed zero maximum for window '+i+'. v: '+( ( isNegativeZero( data[ i ] ) ) ? '-' : '+' )+data[ i ]+'. actual: '+( ( sgn1 ) ? '-' : '+' )+v[ 1 ]+'. expected: '+( ( sgn2 ) ? '-' : '+' )+expected[ i ][ 1 ]+'.' );
 		} else {
-			t.equal( v[ 1 ], expected[ i ][ 1 ], 'returns expected maximum for window '+i+'. v: '+data[ i ]+'. actual: '+v[ 1 ]+'. expected: '+expected[ i ][ 1 ]+'.' );
+			t.strictEqual( v[ 1 ], expected[ i ][ 1 ], 'returns expected maximum for window '+i+'. v: '+data[ i ]+'. actual: '+v[ 1 ]+'. expected: '+expected[ i ][ 1 ]+'.' );
 		}
 	}
 	t.end();
@@ -605,8 +605,8 @@ tape( 'if provided `NaN`, the accumulated minimum and maximum absolute values ar
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ][ 0 ] ) ) {
-			t.equal( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
-			t.equal( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value for window '+i );
 		} else {
 			t.deepEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
diff --git a/lib/node_modules/@stdlib/stats/incr/mmpe/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmpe/test/test.js
index d4ca4358b632..4051334c39a7 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmpe/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmpe/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmpe( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmpe( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -104,11 +104,11 @@ tape( 'the accumulator function computes a moving mean percentage error incremen
 	for ( i = 0; i < N; i++ ) {
 		actual = acc( data[i][0], data[i][1] );
 		if ( actual === expected[i] ) {
-			t.equal( actual, expected[i], 'returns expected value' );
+			t.strictEqual( actual, expected[i], 'returns expected value' );
 		} else {
 			delta = abs( expected[i] - actual );
 			tol = 1.0 * EPS * abs( expected[i] );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -128,13 +128,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[i][0], data[i][1] );
 	}
-	t.equal( acc(), 65.0, 'returns expected value' );
+	t.strictEqual( acc(), 65.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmpe( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -194,11 +194,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -251,11 +251,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mmse/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmse/test/test.js
index d5a9833e1f97..5136d2b975f3 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmse/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmse/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmmse( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmse( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -96,11 +96,11 @@ tape( 'the accumulator function computes a moving mean squared error incremental
 	for ( i = 0; i < N; i++ ) {
 		actual = acc( data[i][0], data[i][1] );
 		if ( actual === expected[i] ) {
-			t.equal( actual, expected[i], 'returns expected value' );
+			t.strictEqual( actual, expected[i], 'returns expected value' );
 		} else {
 			delta = abs( expected[i] - actual );
 			tol = 1.0 * EPS * abs( expected[i] );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -120,13 +120,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[i][0], data[i][1] );
 	}
-	t.equal( acc(), 145.0/2.0, 'returns expected value' );
+	t.strictEqual( acc(), 145.0/2.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmse( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -186,11 +186,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -243,11 +243,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mpcorr/test/test.js b/lib/node_modules/@stdlib/stats/incr/mpcorr/test/test.js
index 5399c6a92528..0393edc579dd 100644
--- a/lib/node_modules/@stdlib/stats/incr/mpcorr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mpcorr/test/test.js
@@ -27,6 +27,7 @@ var pow = require( '@stdlib/math/base/special/pow' );
 var sqrt = require( '@stdlib/math/base/special/sqrt' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var EPS = require( '@stdlib/constants/float64/eps' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmpcorr = require( './../lib' );
 
 
@@ -178,9 +179,9 @@ function datasets( N, M, seed ) {
 	});
 
 	// Generate datasets consisting of (x,y) pairs of varying value ranges...
-	data = new Array( N );
+	data = zeros( N );
 	for ( i = 0; i < N; i++ ) {
-		tmp = new Array( M );
+		tmp = zeros( M );
 		for ( j = 0; j < M; j++ ) {
 			tmp[ j ] = [
 				rand() * pow( 10.0, i ),
@@ -316,12 +317,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmpcorr( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpcorr( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.equal( typeof incrmpcorr( 3, 3.0, 3.14 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpcorr( 3, 3.0, 3.14 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -363,11 +364,11 @@ tape( 'the accumulator function computes a moving sample Pearson product-moment
 			means = mean( [ 0.0, 0.0 ], arr );
 			expected = pcorr( arr, means[ 0 ], means[ 1 ], false );
 			if ( actual === expected ) {
-				t.equal( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
+				t.strictEqual( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
 			} else {
 				delta = abs( actual - expected );
 				tol = 5.0e5 * EPS * abs( expected );
-				t.equal( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+				t.strictEqual( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
 		}
 	}
@@ -411,11 +412,11 @@ tape( 'the accumulator function computes a moving sample Pearson product-moment
 			}
 			expected = pcorr( arr, means[ 0 ], means[ 1 ], true );
 			if ( actual === expected ) {
-				t.equal( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
+				t.strictEqual( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
 			} else {
 				delta = abs( actual - expected );
 				tol = 5.0e5 * EPS * abs( expected );
-				t.equal( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+				t.strictEqual( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
 		}
 	}
@@ -458,11 +459,11 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 		means = mean( [ 0.0, 0.0 ], d );
 		expected = pcorr( d, means[ 0 ], means[ 1 ], false );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value. window: '+i+'.' );
+			t.strictEqual( actual, expected, 'returns expected value. window: '+i+'.' );
 		} else {
 			delta = abs( actual - expected );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -504,11 +505,11 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 		}
 		expected = pcorr( d, means[ 0 ], means[ 1 ], true );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value. window: '+i+'.' );
+			t.strictEqual( actual, expected, 'returns expected value. window: '+i+'.' );
 		} else {
 			delta = abs( actual - expected );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -516,20 +517,20 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmpcorr( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known means)', function test( t ) {
 	var acc = incrmpcorr( 3, 3.0, 3.14 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if only one datum has been provided and the means are unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmpcorr( 3 );
 	acc( 2.0, 3.14 );
-	t.equal( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -548,7 +549,7 @@ tape( 'if the window size is `1` and the means are unknown, the accumulator func
 	acc = incrmpcorr( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		r = acc( randu()*100.0, randu()*100.0 );
-		t.equal( r, 0.0, 'returns 0' );
+		t.strictEqual( r, 0.0, 'returns 0' );
 	}
 	t.end();
 });
@@ -628,15 +629,15 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else if ( v === expected[ i ] ) {
-			t.equal( v, expected[ i ], 'returns expected value for window: '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window: '+i );
 		} else {
 			delta = abs( v - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
-			t.equal( acc(), v, 'returns expected value for window '+i );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( acc(), v, 'returns expected value for window '+i );
 		}
 	}
 
@@ -669,15 +670,15 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else if ( v === expected[ i ] ) {
-			t.equal( v, expected[ i ], 'returns expected value for window: '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window: '+i );
 		} else {
 			delta = abs( v - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
-			t.equal( acc(), v, 'returns expected value for window '+i );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( acc(), v, 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -743,11 +744,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -780,11 +781,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mpcorr2/test/test.js b/lib/node_modules/@stdlib/stats/incr/mpcorr2/test/test.js
index 3e283f11a894..d10ba26e1538 100644
--- a/lib/node_modules/@stdlib/stats/incr/mpcorr2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mpcorr2/test/test.js
@@ -27,6 +27,7 @@ var pow = require( '@stdlib/math/base/special/pow' );
 var sqrt = require( '@stdlib/math/base/special/sqrt' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var EPS = require( '@stdlib/constants/float64/eps' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmpcorr2 = require( './../lib' );
 
 
@@ -180,9 +181,9 @@ function datasets( N, M, seed ) {
 	});
 
 	// Generate datasets consisting of (x,y) pairs of varying value ranges...
-	data = new Array( N );
+	data = zeros( N );
 	for ( i = 0; i < N; i++ ) {
-		tmp = new Array( M );
+		tmp = zeros( M );
 		for ( j = 0; j < M; j++ ) {
 			tmp[ j ] = [
 				rand() * pow( 10.0, i ),
@@ -318,12 +319,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmpcorr2( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpcorr2( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.equal( typeof incrmpcorr2( 3, 3.0, 3.14 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpcorr2( 3, 3.0, 3.14 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -365,11 +366,11 @@ tape( 'the accumulator function computes a moving squared sample Pearson product
 			means = mean( [ 0.0, 0.0 ], arr );
 			expected = pcorr2( arr, means[ 0 ], means[ 1 ], false );
 			if ( actual === expected ) {
-				t.equal( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
+				t.strictEqual( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
 			} else {
 				delta = abs( actual - expected );
 				tol = 5.0e5 * EPS * abs( expected );
-				t.equal( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+				t.strictEqual( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
 		}
 	}
@@ -413,11 +414,11 @@ tape( 'the accumulator function computes a moving squared sample Pearson product
 			}
 			expected = pcorr2( arr, means[ 0 ], means[ 1 ], true );
 			if ( actual === expected ) {
-				t.equal( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
+				t.strictEqual( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
 			} else {
 				delta = abs( actual - expected );
 				tol = 5.0e5 * EPS * abs( expected );
-				t.equal( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+				t.strictEqual( delta < tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
 		}
 	}
@@ -460,11 +461,11 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 		means = mean( [ 0.0, 0.0 ], d );
 		expected = pcorr2( d, means[ 0 ], means[ 1 ], false );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value. window: '+i+'.' );
+			t.strictEqual( actual, expected, 'returns expected value. window: '+i+'.' );
 		} else {
 			delta = abs( actual - expected );
 			tol = 2.0 * EPS * abs( expected );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -506,11 +507,11 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 		}
 		expected = pcorr2( d, means[ 0 ], means[ 1 ], true );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value. window: '+i+'.' );
+			t.strictEqual( actual, expected, 'returns expected value. window: '+i+'.' );
 		} else {
 			delta = abs( actual - expected );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -518,20 +519,20 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmpcorr2( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known means)', function test( t ) {
 	var acc = incrmpcorr2( 3, 3.0, 3.14 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if only one datum has been provided and the means are unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmpcorr2( 3 );
 	acc( 2.0, 3.14 );
-	t.equal( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -550,7 +551,7 @@ tape( 'if the window size is `1` and the means are unknown, the accumulator func
 	acc = incrmpcorr2( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		r = acc( randu()*100.0, randu()*100.0 );
-		t.equal( r, 0.0, 'returns 0' );
+		t.strictEqual( r, 0.0, 'returns 0' );
 	}
 	t.end();
 });
@@ -630,15 +631,15 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else if ( v === expected[ i ] ) {
-			t.equal( v, expected[ i ], 'returns expected value for window: '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window: '+i );
 		} else {
 			delta = abs( v - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
-			t.equal( acc(), v, 'returns expected value for window '+i );
+			t.strictEqual( delta <= tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( acc(), v, 'returns expected value for window '+i );
 		}
 	}
 
@@ -671,15 +672,15 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else if ( v === expected[ i ] ) {
-			t.equal( v, expected[ i ], 'returns expected value for window: '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window: '+i );
 		} else {
 			delta = abs( v - expected[ i ] );
 			tol = EPS * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
-			t.equal( acc(), v, 'returns expected value for window '+i );
+			t.strictEqual( delta <= tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( acc(), v, 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -745,11 +746,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -782,11 +783,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mpcorrdist/test/test.js b/lib/node_modules/@stdlib/stats/incr/mpcorrdist/test/test.js
index 459f5087f4f8..e5cd45b21cde 100644
--- a/lib/node_modules/@stdlib/stats/incr/mpcorrdist/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mpcorrdist/test/test.js
@@ -27,6 +27,7 @@ var pow = require( '@stdlib/math/base/special/pow' );
 var sqrt = require( '@stdlib/math/base/special/sqrt' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var EPS = require( '@stdlib/constants/float64/eps' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmpcorrdist = require( './../lib' );
 
 
@@ -186,9 +187,9 @@ function datasets( N, M, seed ) {
 	});
 
 	// Generate datasets consisting of (x,y) pairs of varying value ranges...
-	data = new Array( N );
+	data = zeros( N );
 	for ( i = 0; i < N; i++ ) {
-		tmp = new Array( M );
+		tmp = zeros( M );
 		for ( j = 0; j < M; j++ ) {
 			tmp[ j ] = [
 				rand() * pow( 10.0, i ),
@@ -324,12 +325,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmpcorrdist( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpcorrdist( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.equal( typeof incrmpcorrdist( 3, 3.0, 3.14 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpcorrdist( 3, 3.0, 3.14 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -373,7 +374,7 @@ tape( 'the accumulator function computes a moving sample Pearson product-moment
 			means = mean( [ 0.0, 0.0 ], arr );
 			expected = pcorrdist( arr, means[ 0 ], means[ 1 ], false );
 			if ( actual === expected ) {
-				t.equal( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
+				t.strictEqual( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
 			} else {
 				if ( actual < 0.0 ) {
 					actual = 0.0; // NOTE: this addresses occasional negative values due to accumulated floating-point error. Based on observation, typically `|actual| ≅ |expected|`, but `actual < 0` and `expected > 0`, suggesting that a sign got "flipped" along the way due to, e.g., operations which theoretically should compute to the same value, but do not due to floating-point error.
@@ -384,7 +385,7 @@ tape( 'the accumulator function computes a moving sample Pearson product-moment
 				} else {
 					tol = 1.0e6 * EPS * abs( expected );
 				}
-				t.equal( delta <= tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+				t.strictEqual( delta <= tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
 		}
 	}
@@ -430,11 +431,11 @@ tape( 'the accumulator function computes a moving sample Pearson product-moment
 			}
 			expected = pcorrdist( arr, means[ 0 ], means[ 1 ], true );
 			if ( actual === expected ) {
-				t.equal( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
+				t.strictEqual( actual, expected, 'returns expected value. dataset: '+i+'. window: '+j+'.' );
 			} else {
 				delta = abs( actual - expected );
 				tol = 1.0e6 * EPS * abs( expected );
-				t.equal( delta <= tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+				t.strictEqual( delta <= tol, true, 'dataset: '+i+'. window: '+j+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 			}
 		}
 	}
@@ -477,11 +478,11 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 		means = mean( [ 0.0, 0.0 ], d );
 		expected = pcorrdist( d, means[ 0 ], means[ 1 ], false );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value. window: '+i+'.' );
+			t.strictEqual( actual, expected, 'returns expected value. window: '+i+'.' );
 		} else {
 			delta = abs( actual - expected );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -523,11 +524,11 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 		}
 		expected = pcorrdist( d, means[ 0 ], means[ 1 ], true );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value. window: '+i+'.' );
+			t.strictEqual( actual, expected, 'returns expected value. window: '+i+'.' );
 		} else {
 			delta = abs( actual - expected );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -535,20 +536,20 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmpcorrdist( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known means)', function test( t ) {
 	var acc = incrmpcorrdist( 3, 3.0, 3.14 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if only one datum has been provided and the means are unknown, the accumulator function returns `1`', function test( t ) {
 	var acc = incrmpcorrdist( 3 );
 	acc( 2.0, 3.14 );
-	t.equal( acc(), 1.0, 'returns 1' );
+	t.strictEqual( acc(), 1.0, 'returns 1' );
 	t.end();
 });
 
@@ -567,7 +568,7 @@ tape( 'if the window size is `1` and the means are unknown, the accumulator func
 	acc = incrmpcorrdist( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		r = acc( randu()*100.0, randu()*100.0 );
-		t.equal( r, 1.0, 'returns expected value' );
+		t.strictEqual( r, 1.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -647,10 +648,10 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else if ( v === expected[ i ] ) {
-			t.equal( v, expected[ i ], 'returns expected value for window: '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window: '+i );
 		} else {
 			delta = abs( v - expected[ i ] );
 			if ( expected[ i ] === 0.0 ) {
@@ -658,8 +659,8 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 			} else {
 				tol = 1.0 * EPS * abs( expected[ i ] );
 			}
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
-			t.equal( acc(), v, 'returns expected value for window '+i );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( acc(), v, 'returns expected value for window '+i );
 		}
 	}
 
@@ -692,10 +693,10 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else if ( v === expected[ i ] ) {
-			t.equal( v, expected[ i ], 'returns expected value for window: '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window: '+i );
 		} else {
 			delta = abs( v - expected[ i ] );
 			if ( expected[ i ] === 0.0 ) {
@@ -703,8 +704,8 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 			} else {
 				tol = 1.0 * EPS * abs( expected[ i ] );
 			}
-			t.equal( delta < tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
-			t.equal( acc(), v, 'returns expected value for window '+i );
+			t.strictEqual( delta < tol, true, 'window: '+i+'. expected: '+expected[ i ]+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( acc(), v, 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -770,11 +771,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -807,11 +808,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mpe/test/test.js b/lib/node_modules/@stdlib/stats/incr/mpe/test/test.js
index 3a430e6ebcc1..b2a7a92a6dca 100644
--- a/lib/node_modules/@stdlib/stats/incr/mpe/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mpe/test/test.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmpe(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpe(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrmpe();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -78,11 +78,11 @@ tape( 'the accumulator function incrementally computes the mean percentage error
 		expected = 100.0 * ( sum/(i+1) );
 		actual = acc( x, y );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value' );
+			t.strictEqual( actual, expected, 'returns expected value' );
 		} else {
 			delta = abs( expected - actual );
 			tol = 10.0 * EPS * abs( expected );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -110,6 +110,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	expected = 100.0 / 3.0 * ((1.0/3.0) + (2.0/5.0) + (9.0/10.0));
 	delta = abs( expected - actual );
 	tol = 1.0 * EPS * abs( expected );
-	t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+	t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mprod/test/test.js b/lib/node_modules/@stdlib/stats/incr/mprod/test/test.js
index 2384a3043f3a..925a0fa24247 100644
--- a/lib/node_modules/@stdlib/stats/incr/mprod/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mprod/test/test.js
@@ -74,7 +74,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmprod( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmprod( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -111,13 +111,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 15.0, 'returns expected value' );
+	t.strictEqual( acc(), 15.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmprod( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -175,9 +175,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -199,7 +199,7 @@ tape( 'the accumulator function incrementally computes a moving product (special
 			acc( 1.0/x );
 		}
 	}
-	t.equal( acc(), 1.0, 'returns expected value' );
+	t.strictEqual( acc(), 1.0, 'returns expected value' );
 	t.end();
 });
 
@@ -209,7 +209,7 @@ tape( 'the accumulator function can return a result which overflows', function t
 	acc( 5.0e300 );
 	acc( 1.0e300 );
 
-	t.equal( acc(), PINF, 'returns infinity' );
+	t.strictEqual( acc(), PINF, 'returns infinity' );
 	t.end();
 });
 
@@ -237,7 +237,7 @@ tape( 'overflow may be transient', function test( t ) {
 	delta = abs( expected - acc() );
 	tol = EPSILON * abs( expected );
 
-	t.equal( delta <= tol, true, 'within tolerance. Expected: '+expected+'. Actual: '+acc()+'. Delta: '+delta+'. Tol: '+tol+'.' );
+	t.strictEqual( delta <= tol, true, 'within tolerance. Expected: '+expected+'. Actual: '+acc()+'. Delta: '+delta+'. Tol: '+tol+'.' );
 	t.end();
 });
 
@@ -247,7 +247,7 @@ tape( 'the accumulator function can return a result which underflows', function
 	acc( 4.0e-302 );
 	acc( 9.0e-303 );
 
-	t.equal( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -271,14 +271,14 @@ tape( 'underflow may be transient', function test( t ) {
 	acc( x );
 	acc( y );
 
-	t.equal( acc(), 0.0, 'returns 0 due to underflow' );
+	t.strictEqual( acc(), 0.0, 'returns 0 due to underflow' );
 
 	acc( z );
 
 	delta = abs( acc() - expected );
 	tol = EPSILON * abs( expected );
 
-	t.equal( delta <= tol, true, 'within tolerance. Expected: '+expected+'. Actual: '+acc()+'. Delta: '+delta+'. Tol: '+tol+'.' );
+	t.strictEqual( delta <= tol, true, 'within tolerance. Expected: '+expected+'. Actual: '+acc()+'. Delta: '+delta+'. Tol: '+tol+'.' );
 	t.end();
 });
 
@@ -301,7 +301,7 @@ tape( 'if provided values of normal magnitude (i.e., far away from the extremes)
 		acc( r );
 		prod *= r;
 	}
-	t.equal( acc(), prod, 'equals native multiplication' );
+	t.strictEqual( acc(), prod, 'equals native multiplication' );
 	t.end();
 });
 
@@ -313,16 +313,16 @@ tape( 'if provided `+infinity`, the accumulator function returns `+-infinity` (u
 	acc = incrmprod( 3 );
 	acc( 5.0 );
 
-	t.equal( acc(), 5.0, 'returns expected value' );
+	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( PINF );
-	t.equal( acc(), PINF, 'returns +infinity' );
+	t.strictEqual( acc(), PINF, 'returns +infinity' );
 
 	acc( 3.0 );
-	t.equal( acc(), PINF, 'returns +infinity' );
+	t.strictEqual( acc(), PINF, 'returns +infinity' );
 
 	acc( -4.0 );
-	t.equal( acc(), NINF, 'returns -infinity' );
+	t.strictEqual( acc(), NINF, 'returns -infinity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		x = ( randu()*100.0 ) - 50.0;
@@ -343,16 +343,16 @@ tape( 'if provided `-infinity`, the accumulator function returns `+-infinity` (u
 	acc = incrmprod( 3 );
 	acc( 5.0 );
 
-	t.equal( acc(), 5.0, 'returns expected value' );
+	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( NINF );
-	t.equal( acc(), NINF, 'returns -infinity' );
+	t.strictEqual( acc(), NINF, 'returns -infinity' );
 
 	acc( 3.0 );
-	t.equal( acc(), NINF, 'returns -infinity' );
+	t.strictEqual( acc(), NINF, 'returns -infinity' );
 
 	acc( -4.0 );
-	t.equal( acc(), PINF, 'returns +infinity' );
+	t.strictEqual( acc(), PINF, 'returns +infinity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		x = ( randu()*100.0 ) - 50.0;
@@ -373,23 +373,23 @@ tape( 'if provided `+infinity`, the accumulator function returns `NaN` if also p
 	acc = incrmprod( 3 );
 	acc( 5.0 );
 
-	t.equal( acc(), 5.0, 'returns expected value' );
+	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( PINF );
-	t.equal( acc(), PINF, 'returns +infinity' );
+	t.strictEqual( acc(), PINF, 'returns +infinity' );
 
 	acc( 0.0 );
-	t.equal( isnan( acc() ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc() ), true, 'returns NaN' );
 
 	acc( 3.0 );
-	t.equal( isnan( acc() ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc() ), true, 'returns NaN' );
 
 	acc( 4.0 );
-	t.equal( isnan( acc() ), false, 'does not return NaN' );
+	t.strictEqual( isnan( acc() ), false, 'does not return NaN' );
 
 	for ( i = 0; i < 10; i++ ) {
 		p = acc( i+1 );
-		t.equal( isnan( p ), false, 'does not return NaN' );
+		t.strictEqual( isnan( p ), false, 'does not return NaN' );
 	}
 	t.end();
 });
@@ -402,23 +402,23 @@ tape( 'if provided `-infinity`, the accumulator function returns `NaN` if also p
 	acc = incrmprod( 3 );
 	acc( 5.0 );
 
-	t.equal( acc(), 5.0, 'returns expected value' );
+	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( NINF );
-	t.equal( acc(), NINF, 'returns -infinity' );
+	t.strictEqual( acc(), NINF, 'returns -infinity' );
 
 	acc( 0.0 );
-	t.equal( isnan( acc() ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc() ), true, 'returns NaN' );
 
 	acc( 3.0 );
-	t.equal( isnan( acc() ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc() ), true, 'returns NaN' );
 
 	acc( 4.0 );
-	t.equal( isnan( acc() ), false, 'does not return NaN' );
+	t.strictEqual( isnan( acc() ), false, 'does not return NaN' );
 
 	for ( i = 0; i < 10; i++ ) {
 		p = acc( i+1 );
-		t.equal( isnan( p ), false, 'does not return NaN' );
+		t.strictEqual( isnan( p ), false, 'does not return NaN' );
 	}
 	t.end();
 });
@@ -431,20 +431,20 @@ tape( 'if provided `0`, the accumulator function returns `0` (no +-infinity)', f
 	acc = incrmprod( 3 );
 	acc( 5.0 );
 
-	t.equal( acc(), 5.0, 'returns expected value' );
+	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( 0.0 );
-	t.equal( acc(), 0.0, 'returns 0.0' );
+	t.strictEqual( acc(), 0.0, 'returns 0.0' );
 
 	acc( 3.0 );
-	t.equal( acc(), 0.0, 'returns 0.0' );
+	t.strictEqual( acc(), 0.0, 'returns 0.0' );
 
 	acc( 4.0 );
-	t.equal( acc(), 0.0, 'returns 0.0' );
+	t.strictEqual( acc(), 0.0, 'returns 0.0' );
 
 	for ( i = 0; i < 10; i++ ) {
 		p = acc( i+1 );
-		t.equal( p > 0.0, true, 'does not return 0.0' );
+		t.strictEqual( p > 0.0, true, 'does not return 0.0' );
 	}
 	t.end();
 });
@@ -456,29 +456,29 @@ tape( 'the accumulator function returns a signed zero', function test( t ) {
 
 	acc = incrmprod( 3 );
 	p = acc( -0.0 );
-	t.equal( isNegativeZero( p ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( p ), true, 'returns -0' );
 
 	p = acc( -0.0 );
-	t.equal( isPositiveZero( p ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( p ), true, 'returns +0' );
 
 	for ( i = 0; i < 100; i++ ) {
 		p = acc( -0.0 );
-		t.equal( isNegativeZero( p ), true, 'returns -0' );
+		t.strictEqual( isNegativeZero( p ), true, 'returns -0' );
 	}
 
 	acc = incrmprod( 4 );
 	p = acc( -0.0 );
-	t.equal( isNegativeZero( p ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( p ), true, 'returns -0' );
 
 	p = acc( -0.0 );
-	t.equal( isPositiveZero( p ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( p ), true, 'returns +0' );
 
 	p = acc( -0.0 );
-	t.equal( isNegativeZero( p ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( p ), true, 'returns -0' );
 
 	for ( i = 0; i < 100; i++ ) {
 		p = acc( -0.0 );
-		t.equal( isPositiveZero( p ), true, 'returns +0' );
+		t.strictEqual( isPositiveZero( p ), true, 'returns +0' );
 	}
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mrange/test/test.js b/lib/node_modules/@stdlib/stats/incr/mrange/test/test.js
index 249f0efc5612..1f82d38e2f52 100644
--- a/lib/node_modules/@stdlib/stats/incr/mrange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mrange/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmrange( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmrange( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -117,13 +117,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 1.0, 'returns expected value' );
+	t.strictEqual( acc(), 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmrange( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -359,9 +359,9 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( expected[ i ] === 0.0 ) {
-			t.equal( isNegativeZero( v ), isNegativeZero( expected[ i ] ), 'returns expected value for window '+i );
+			t.strictEqual( isNegativeZero( v ), isNegativeZero( expected[ i ] ), 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -461,9 +461,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mrmse/test/test.js b/lib/node_modules/@stdlib/stats/incr/mrmse/test/test.js
index 0a67b111b021..b6e06e74c628 100644
--- a/lib/node_modules/@stdlib/stats/incr/mrmse/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mrmse/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmrmse( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmrmse( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -104,11 +104,11 @@ tape( 'the accumulator function computes a moving root mean squared error increm
 	for ( i = 0; i < N; i++ ) {
 		actual = acc( data[i][0], data[i][1] );
 		if ( actual === expected[i] ) {
-			t.equal( actual, expected[i], 'returns expected value' );
+			t.strictEqual( actual, expected[i], 'returns expected value' );
 		} else {
 			delta = abs( expected[i] - actual );
 			tol = 1.0 * EPS * abs( expected[i] );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -128,13 +128,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[i][0], data[i][1] );
 	}
-	t.equal( acc(), sqrt( 145.0/2.0 ), 'returns expected value' );
+	t.strictEqual( acc(), sqrt( 145.0/2.0 ), 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmrmse( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -194,11 +194,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -251,11 +251,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mrss/test/test.js b/lib/node_modules/@stdlib/stats/incr/mrss/test/test.js
index 85e27a0c1911..088e476bfb8c 100644
--- a/lib/node_modules/@stdlib/stats/incr/mrss/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mrss/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmrss( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmrss( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -96,11 +96,11 @@ tape( 'the accumulator function computes a moving residual sum of squares increm
 	for ( i = 0; i < N; i++ ) {
 		actual = acc( data[i][0], data[i][1] );
 		if ( actual === expected[i] ) {
-			t.equal( actual, expected[i], 'returns expected value' );
+			t.strictEqual( actual, expected[i], 'returns expected value' );
 		} else {
 			delta = abs( expected[i] - actual );
 			tol = 1.0 * EPS * abs( expected[i] );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -120,13 +120,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[i][0], data[i][1] );
 	}
-	t.equal( acc(), 145.0, 'returns expected value' );
+	t.strictEqual( acc(), 145.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmrss( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -186,11 +186,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -243,11 +243,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mse/test/test.js b/lib/node_modules/@stdlib/stats/incr/mse/test/test.js
index 233bc762dad9..8774e53a2e50 100644
--- a/lib/node_modules/@stdlib/stats/incr/mse/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mse/test/test.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmse(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmse(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrmse();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -80,11 +80,11 @@ tape( 'the accumulator function incrementally computes the mean squared error',
 		expected = sum / (i+1);
 		actual = acc( x, y );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value' );
+			t.strictEqual( actual, expected, 'returns expected value' );
 		} else {
 			delta = abs( expected - actual );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -112,6 +112,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	expected = ( 1.0 + 64.0 + 81.0 ) / 3.0;
 	delta = abs( expected - actual );
 	tol = 1.0 * EPS * abs( expected );
-	t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+	t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/mstdev/test/test.js
index 224eaf1c9559..19f84d55fe7b 100644
--- a/lib/node_modules/@stdlib/stats/incr/mstdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mstdev/test/test.js
@@ -125,12 +125,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmstdev( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmstdev( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.equal( typeof incrmstdev( 3, 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmstdev( 3, 3.0 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -208,7 +208,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length-1; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), sqrt( 0.5 ), 'returns current corrected sample standard deviation' );
+	t.strictEqual( acc(), sqrt( 0.5 ), 'returns current corrected sample standard deviation' );
 
 	acc( data[ data.length-1 ] );
 
@@ -217,7 +217,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	delta = abs( actual - expected );
 	tol = EPS * expected;
 
-	t.equal( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+	t.strictEqual( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 	t.end();
 });
 
@@ -235,7 +235,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length-1; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), sqrt( 6.5 ), 'returns current unbiased sample variance' );
+	t.strictEqual( acc(), sqrt( 6.5 ), 'returns current unbiased sample variance' );
 
 	acc( data[ data.length-1 ] );
 
@@ -244,26 +244,26 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	delta = abs( actual - expected );
 	tol = EPS * expected;
 
-	t.equal( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+	t.strictEqual( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmstdev( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known mean)', function test( t ) {
 	var acc = incrmstdev( 3, 3.0 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if only one datum has been provided and the mean is unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmstdev( 3 );
 	acc( 2.0 );
-	t.equal( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -282,7 +282,7 @@ tape( 'if the window size is `1` and the mean is unknown, the accumulator functi
 	acc = incrmstdev( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		s = acc( randu() * 100.0 );
-		t.equal( s, 0.0, 'returns 0' );
+		t.strictEqual( s, 0.0, 'returns 0' );
 	}
 	t.end();
 });
@@ -354,11 +354,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -418,11 +418,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -482,11 +482,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -546,11 +546,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/msum/test/test.js b/lib/node_modules/@stdlib/stats/incr/msum/test/test.js
index 88ed8ecf0928..7e1bc4713e24 100644
--- a/lib/node_modules/@stdlib/stats/incr/msum/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/msum/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmsum( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmsum( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -101,13 +101,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 8.0, 'returns expected value' );
+	t.strictEqual( acc(), 8.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmsum( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -165,9 +165,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/msumabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/msumabs/test/test.js
index d67c3f7f293f..2f68df63e33b 100644
--- a/lib/node_modules/@stdlib/stats/incr/msumabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/msumabs/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmsumabs( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmsumabs( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -101,13 +101,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 8.0, 'returns expected value' );
+	t.strictEqual( acc(), 8.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmsumabs( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -165,9 +165,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/msumabs2/test/test.js b/lib/node_modules/@stdlib/stats/incr/msumabs2/test/test.js
index 723ddd9157c3..cbbb3f7c5209 100644
--- a/lib/node_modules/@stdlib/stats/incr/msumabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/msumabs2/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmsumabs2( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmsumabs2( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -101,13 +101,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 34.0, 'returns expected value' );
+	t.strictEqual( acc(), 34.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmsumabs2( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -165,9 +165,9 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/msummary/test/test.js b/lib/node_modules/@stdlib/stats/incr/msummary/test/test.js
index 10c3e4cf62cd..0902d926cc67 100644
--- a/lib/node_modules/@stdlib/stats/incr/msummary/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/msummary/test/test.js
@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmsummary = require( './../lib' );
 
 
@@ -63,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmsummary( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmsummary( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -84,7 +85,7 @@ tape( 'the accumulator function incrementally computes a moving summary', functi
 	data = [ 2.0, 3.0, -2.0, 4.0, 3.0, 4.0 ];
 	N = data.length;
 
-	actual = new Array( N );
+	actual = zeros( N );
 
 	acc = incrmsummary( 3 );
 	for ( i = 0; i < N; i++ ) {
diff --git a/lib/node_modules/@stdlib/stats/incr/msumprod/test/test.js b/lib/node_modules/@stdlib/stats/incr/msumprod/test/test.js
index 7c25e7ece4bb..8a40da1ea220 100644
--- a/lib/node_modules/@stdlib/stats/incr/msumprod/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/msumprod/test/test.js
@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmsumprod = require( './../lib' );
 
 
@@ -64,7 +65,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmsumprod( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmsumprod( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -88,7 +89,7 @@ tape( 'the accumulator function computes a moving sum of products incrementally'
 
 	acc = incrmsumprod( 3 );
 
-	actual = new Array( N );
+	actual = zeros( N );
 	for ( i = 0; i < N; i++ ) {
 		actual[ i ] = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
 	}
@@ -112,13 +113,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ][ 0 ], data[ i ][ 1 ] );
 	}
-	t.equal( acc(), -5.0, 'returns expected value' );
+	t.strictEqual( acc(), -5.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmsumprod( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -178,11 +179,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 
@@ -213,11 +214,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[i][0], data[i][1] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mvariance/test/test.js b/lib/node_modules/@stdlib/stats/incr/mvariance/test/test.js
index 0f382b0638fe..bc2a3d67aff7 100644
--- a/lib/node_modules/@stdlib/stats/incr/mvariance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mvariance/test/test.js
@@ -25,6 +25,7 @@ var randu = require( '@stdlib/random/base/randu' );
 var abs = require( '@stdlib/math/base/special/abs' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var EPS = require( '@stdlib/constants/float64/eps' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmvariance = require( './../lib' );
 
 
@@ -124,12 +125,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmvariance( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmvariance( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.equal( typeof incrmvariance( 3, 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmvariance( 3, 3.0 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -146,7 +147,7 @@ tape( 'the accumulator function computes a moving unbiased sample variance incre
 
 	acc = incrmvariance( 3 );
 
-	actual = new Array( N );
+	actual = zeros( N );
 	for ( i = 0; i < N; i++ ) {
 		actual[ i ] = acc( data[ i ] );
 	}
@@ -169,7 +170,7 @@ tape( 'the accumulator function computes a moving unbiased sample variance incre
 
 	acc = incrmvariance( 3, 2.0 );
 
-	actual = new Array( N );
+	actual = zeros( N );
 	for ( i = 0; i < N; i++ ) {
 		actual[ i ] = acc( data[ i ] );
 	}
@@ -200,7 +201,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length-1; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 0.5, 'returns current unbiased sample variance' );
+	t.strictEqual( acc(), 0.5, 'returns current unbiased sample variance' );
 
 	acc( data[ data.length-1 ] );
 
@@ -209,7 +210,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	delta = abs( actual - expected );
 	tol = EPS * expected;
 
-	t.equal( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+	t.strictEqual( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 	t.end();
 });
 
@@ -227,7 +228,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length-1; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 6.5, 'returns current unbiased sample variance' );
+	t.strictEqual( acc(), 6.5, 'returns current unbiased sample variance' );
 
 	acc( data[ data.length-1 ] );
 
@@ -236,26 +237,26 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	delta = abs( actual - expected );
 	tol = EPS * expected;
 
-	t.equal( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+	t.strictEqual( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmvariance( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known mean)', function test( t ) {
 	var acc = incrmvariance( 3, 3.0 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if only one datum has been provided and the mean is unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmvariance( 3 );
 	acc( 2.0 );
-	t.equal( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -274,7 +275,7 @@ tape( 'if the window size is `1` and the mean is unknown, the accumulator functi
 	acc = incrmvariance( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		s2 = acc( randu() * 100.0 );
-		t.equal( s2, 0.0, 'returns 0' );
+		t.strictEqual( s2, 0.0, 'returns 0' );
 	}
 	t.end();
 });
@@ -346,11 +347,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -410,11 +411,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -474,11 +475,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -538,11 +539,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/mvmr/test/test.js b/lib/node_modules/@stdlib/stats/incr/mvmr/test/test.js
index 9bb38e8acfe7..0043e579f64b 100644
--- a/lib/node_modules/@stdlib/stats/incr/mvmr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mvmr/test/test.js
@@ -25,6 +25,7 @@ var randu = require( '@stdlib/random/base/randu' );
 var abs = require( '@stdlib/math/base/special/abs' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var EPS = require( '@stdlib/constants/float64/eps' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrmvmr = require( './../lib' );
 
 
@@ -124,12 +125,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmvmr( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmvmr( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.equal( typeof incrmvmr( 3, 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmvmr( 3, 3.0 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -155,7 +156,7 @@ tape( 'the accumulator function computes a moving variance-to-mean ratio increme
 
 	acc = incrmvmr( 3 );
 
-	actual = new Array( N );
+	actual = zeros( N );
 	for ( i = 0; i < N; i++ ) {
 		actual[ i ] = acc( data[ i ] );
 	}
@@ -176,7 +177,7 @@ tape( 'the accumulator function computes a moving variance-to-mean ratio increme
 
 	acc = incrmvmr( 3, 2.0 );
 
-	actual = new Array( N );
+	actual = zeros( N );
 	for ( i = 0; i < N; i++ ) {
 		actual[ i ] = acc( data[ i ] );
 	}
@@ -206,7 +207,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length-1; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 0.5/2.5, 'returns expected value' );
+	t.strictEqual( acc(), 0.5/2.5, 'returns expected value' );
 
 	acc( data[ data.length-1 ] );
 
@@ -215,7 +216,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	delta = abs( actual - expected );
 	tol = EPS * expected;
 
-	t.equal( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+	t.strictEqual( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 	t.end();
 });
 
@@ -233,7 +234,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length-1; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 6.5/5.0, 'returns expected value' );
+	t.strictEqual( acc(), 6.5/5.0, 'returns expected value' );
 
 	acc( data[ data.length-1 ] );
 
@@ -242,26 +243,26 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	delta = abs( actual - expected );
 	tol = EPS * expected;
 
-	t.equal( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+	t.strictEqual( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmvmr( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known mean)', function test( t ) {
 	var acc = incrmvmr( 3, 3.0 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if only one datum has been provided and the mean is unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmvmr( 3 );
 	acc( 2.0 );
-	t.equal( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -280,7 +281,7 @@ tape( 'if the window size is `1` and the mean is unknown, the accumulator functi
 	acc = incrmvmr( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		F = acc( randu() * 100.0 );
-		t.equal( F, 0.0, 'returns 0' );
+		t.strictEqual( F, 0.0, 'returns 0' );
 	}
 	t.end();
 });
@@ -352,11 +353,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -416,11 +417,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -480,11 +481,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -544,11 +545,11 @@ tape( 'if provided `NaN`, the accumulated value is `NaN` for at least `W` invoca
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v ), true, 'returns expected value for window '+i );
-			t.equal( isnan( acc() ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( acc() ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/nancount/test/test.js b/lib/node_modules/@stdlib/stats/incr/nancount/test/test.js
index 0ee3afa849dd..5ca97c4da0e8 100644
--- a/lib/node_modules/@stdlib/stats/incr/nancount/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nancount/test/test.js
@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrnancount = require( './../lib' );
 
 
@@ -34,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrnancount(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnancount(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is zero', function test( t ) {
 	var acc = incrnancount();
-	t.equal( acc(), 0, 'returns expected value' );
+	t.strictEqual( acc(), 0, 'returns expected value' );
 	t.end();
 });
 
@@ -57,8 +58,8 @@ tape( 'the accumulator function incrementally computes a count, ignoring `NaN` v
 	data = [ 2.0, 3.0, NaN, 2.0, NaN, 4.0, 3.0, 4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrnancount();
 
@@ -87,6 +88,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 3, 'returns the current accumulated count' );
+	t.strictEqual( acc(), 3, 'returns the current accumulated count' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmaxabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanmaxabs/test/test.js
index 169072da259c..1a4034e9e754 100644
--- a/lib/node_modules/@stdlib/stats/incr/nanmaxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nanmaxabs/test/test.js
@@ -34,13 +34,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrmaxabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmaxabs(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrmaxabs();
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -77,7 +77,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 3.0, 'returns expected value' );
+	t.strictEqual( acc(), 3.0, 'returns expected value' );
 	t.end();
 });
 
@@ -88,13 +88,13 @@ tape( 'the accumulator function correctly handles signed zeros', function test(
 	acc = incrmaxabs();
 
 	v = acc( -0.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = acc( 0.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = acc( -0.0 );
-	t.equal( isPositiveZero( v ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanmean/test/test.js
index 72d8e425cd73..68902cfc8fd0 100644
--- a/lib/node_modules/@stdlib/stats/incr/nanmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nanmean/test/test.js
@@ -34,13 +34,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrnanmean(), 'function', 'returns expected value' );
+	t.strictEqual( typeof incrnanmean(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrnanmean();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -88,6 +88,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 2.0, 'returns expected value' );
+	t.strictEqual( acc(), 2.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmeanabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanmeanabs/test/test.js
index 1252eb13e12c..abba9af442b1 100644
--- a/lib/node_modules/@stdlib/stats/incr/nanmeanabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nanmeanabs/test/test.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrnanmeanabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnanmeanabs(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrnanmeanabs();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -89,6 +89,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 2.0, 'returns expected value' );
+	t.strictEqual( acc(), 2.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanmstdev/test/test.js
index c693f7684b13..9f0fb359ef39 100644
--- a/lib/node_modules/@stdlib/stats/incr/nanmstdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nanmstdev/test/test.js
@@ -124,12 +124,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrnanmstdev( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnanmstdev( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.equal( typeof incrnanmstdev( 3, 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnanmstdev( 3, 3.0 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -207,7 +207,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length-1; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), sqrt( 0.5 ), 'returns current corrected sample standard deviation' );
+	t.strictEqual( acc(), sqrt( 0.5 ), 'returns current corrected sample standard deviation' );
 
 	acc( data[ data.length-1 ] );
 
@@ -216,7 +216,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	delta = abs( actual - expected );
 	tol = EPS * expected;
 
-	t.equal( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+	t.strictEqual( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 	t.end();
 });
 
@@ -234,7 +234,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length-1; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), sqrt( 6.5 ), 'returns current unbiased sample variance' );
+	t.strictEqual( acc(), sqrt( 6.5 ), 'returns current unbiased sample variance' );
 
 	acc( data[ data.length-1 ] );
 
@@ -243,26 +243,26 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	delta = abs( actual - expected );
 	tol = EPS * expected;
 
-	t.equal( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+	t.strictEqual( delta < tol, true, 'expected: '+expected+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrnanmstdev( 3 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known mean)', function test( t ) {
 	var acc = incrnanmstdev( 3, 3.0 );
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
 tape( 'if only one datum has been provided and the mean is unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrnanmstdev( 3 );
 	acc( 2.0 );
-	t.equal( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns 0' );
 	t.end();
 });
 
@@ -281,7 +281,7 @@ tape( 'if the window size is `1` and the mean is unknown, the accumulator functi
 	acc = incrnanmstdev( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		s = acc( randu() * 100.0 );
-		t.equal( s, 0.0, 'returns 0' );
+		t.strictEqual( s, 0.0, 'returns 0' );
 	}
 	t.end();
 });
@@ -329,16 +329,16 @@ tape( 'if provided a NaN, the accumulator function ignores it (unknown mean, W=1
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( expected[i] === null ) {
-			t.equal( v, null, 'returns null for window '+i );
+			t.strictEqual( v, null, 'returns null for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 
 		// Test accumulator without arguments
 		if (expected[i] === null) {
-			t.equal( acc(), null, 'returns correct value for window '+i );
+			t.strictEqual( acc(), null, 'returns correct value for window '+i );
 		} else {
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -374,16 +374,16 @@ tape( 'if provided a NaN, the accumulator function ignores it (known mean, W=1)'
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
 		if ( expected[i] === null ) {
-			t.equal( v, null, 'returns null for window '+i );
+			t.strictEqual( v, null, 'returns null for window '+i );
 		} else {
-			t.equal( v, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v, expected[ i ], 'returns expected value for window '+i );
 		}
 
 		// Test accumulator without arguments
 		if (expected[i] === null) {
-			t.equal( acc(), null, 'returns correct value for window '+i );
+			t.strictEqual( acc(), null, 'returns correct value for window '+i );
 		} else {
-			t.equal( acc(), expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( acc(), expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -396,19 +396,19 @@ tape( 'if provided a sequence of NaN values, the accumulator function should con
 	acc = incrnanmstdev( 3 );
 
 	v = acc( 2.0 );
-	t.equal( v, 0.0, 'returns expected value' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = acc( NaN );
-	t.equal( v, 0.0, 'returns expected value' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = acc( NaN );
-	t.equal( v, 0.0, 'returns expected value' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = acc( NaN );
-	t.equal( v, 0.0, 'returns expected value' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = acc( 3.0 );
-	t.equal( v.toFixed(4), sqrt(0.5).toFixed(4), 'returns expected value' );
+	t.strictEqual( v.toFixed(4), sqrt(0.5).toFixed(4), 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmsum/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanmsum/test/test.js
index e200a742d34b..4f60a40b3d7a 100644
--- a/lib/node_modules/@stdlib/stats/incr/nanmsum/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nanmsum/test/test.js
@@ -33,13 +33,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrnanmsum( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnanmsum( 3 ), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrnanmsum( 3 );
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -106,6 +106,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 3.0, 'returns expected value' );
+	t.strictEqual( acc(), 3.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/nanskewness/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanskewness/test/test.js
index a4144f3c5d71..73d0f41128a7 100644
--- a/lib/node_modules/@stdlib/stats/incr/nanskewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nanskewness/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrnanskewness(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnanskewness(), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -65,7 +65,7 @@ tape( 'the accumulator function incrementally computes a corrected sample skewne
 	for ( i = 0; i < data.length; i++ ) {
 		actual = acc( data[ i ] );
 		if ( expected[ i ] === null ) {
-			t.equal( actual, expected[i], 'returns null' );
+			t.strictEqual( actual, expected[i], 'returns null' );
 		} else {
 			delta = abs( actual - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
@@ -104,16 +104,16 @@ tape( 'the corrected sample skewness is `null` until at least 3 datums have been
 	acc = incrnanskewness();
 
 	skewness = acc();
-	t.equal( skewness, null, 'returns expected value' );
+	t.strictEqual( skewness, null, 'returns expected value' );
 
 	skewness = acc( 2.0 );
-	t.equal( skewness, null, 'returns expected value' );
+	t.strictEqual( skewness, null, 'returns expected value' );
 
 	skewness = acc( 2.0 );
-	t.equal( skewness, null, 'returns expected value' );
+	t.strictEqual( skewness, null, 'returns expected value' );
 
 	skewness = acc( NaN );
-	t.equal( skewness, null, 'returns expected value' );
+	t.strictEqual( skewness, null, 'returns expected value' );
 
 	skewness = acc( 3.0 );
 	t.notEqual( skewness, null, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/stats/incr/nanstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanstdev/test/test.js
index f27d7d1e5b83..c223384a9af7 100644
--- a/lib/node_modules/@stdlib/stats/incr/nanstdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nanstdev/test/test.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrnanstdev(), 'function', 'returns expected value' );
+	t.strictEqual( typeof incrnanstdev(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.equal( typeof incrnanstdev( 3.0 ), 'function', 'returns expected value' );
+	t.strictEqual( typeof incrnanstdev( 3.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -137,7 +137,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 1.0, 'returns expected value' );
+	t.strictEqual( acc(), 1.0, 'returns expected value' );
 	t.end();
 });
 
@@ -151,7 +151,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), sqrt( 0.6666666666666666 ), 'returns expected value' );
+	t.strictEqual( acc(), sqrt( 0.6666666666666666 ), 'returns expected value' );
 	t.end();
 });
 
@@ -162,7 +162,7 @@ tape( 'the corrected sample standard deviation is `null` until at least 1 datum
 	acc = incrnanstdev();
 
 	s = acc();
-	t.equal( s, null, 'returns expected value' );
+	t.strictEqual( s, null, 'returns expected value' );
 
 	s = acc( 3.0 );
 	t.notEqual( s, null, 'returns expected value' );
@@ -180,7 +180,7 @@ tape( 'the corrected sample standard deviation is `null` until at least 1 datum
 	acc = incrnanstdev( 3.0 );
 
 	s = acc();
-	t.equal( s, null, 'returns expected value' );
+	t.strictEqual( s, null, 'returns expected value' );
 
 	s = acc( 3.0 );
 	t.notEqual( s, null, 'returns expected value' );
@@ -198,10 +198,10 @@ tape( 'the corrected sample standard deviation is `0` until at least 2 datums ha
 	acc = incrnanstdev();
 
 	s = acc( 2.0 );
-	t.equal( s, 0.0, 'returns expected value' );
+	t.strictEqual( s, 0.0, 'returns expected value' );
 
 	s = acc();
-	t.equal( s, 0.0, 'returns expected value' );
+	t.strictEqual( s, 0.0, 'returns expected value' );
 
 	s = acc( 3.0 );
 	t.notEqual( s, 0.0, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/stats/incr/nansum/test/test.js b/lib/node_modules/@stdlib/stats/incr/nansum/test/test.js
index fda868188aa7..8c24ae8ca105 100644
--- a/lib/node_modules/@stdlib/stats/incr/nansum/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nansum/test/test.js
@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrnansum = require( './../lib' );
 
 
@@ -34,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrnansum(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnansum(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrnansum();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -57,8 +58,8 @@ tape( 'the accumulator function incrementally computes a sum', function test( t
 	data = [ 2.0, 3.0, 2.0, NaN, 4.0, NaN, 3.0, 4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrnansum();
 
@@ -87,7 +88,7 @@ tape( 'the accumulator function incrementally computes an accurate sum', functio
 	N = data.length;
 
 	expected = [ 1.0, 1.0e100, 1.0e100, 2.0 ];
-	actual = new Array( N );
+	actual = zeros( N );
 
 	acc = incrnansum();
 
@@ -108,6 +109,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 6.0, 'returns the current accumulated sum' );
+	t.strictEqual( acc(), 6.0, 'returns the current accumulated sum' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/nansumabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/nansumabs/test/test.js
index cc41de428adb..44eb1c8060c0 100644
--- a/lib/node_modules/@stdlib/stats/incr/nansumabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nansumabs/test/test.js
@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrnansumabs = require( './../lib' );
 
 
@@ -34,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrnansumabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnansumabs(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrnansumabs();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -57,8 +58,8 @@ tape( 'the accumulator function incrementally computes a sum of absolute values'
 	data = [ 2.0, -3.0, NaN, 2.0, -4.0, NaN, 3.0, -4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrnansumabs();
 
@@ -85,6 +86,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 6.0, 'returns expected value' );
+	t.strictEqual( acc(), 6.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/nansumabs2/test/test.js b/lib/node_modules/@stdlib/stats/incr/nansumabs2/test/test.js
index 6fa13b0f2e5a..0f800a1e143c 100644
--- a/lib/node_modules/@stdlib/stats/incr/nansumabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nansumabs2/test/test.js
@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrnansumabs2 = require( './../lib' );
 
 
@@ -34,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrnansumabs2(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnansumabs2(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrnansumabs2();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -57,8 +58,8 @@ tape( 'the accumulator function incrementally computes a sum of squared absolute
 	data = [ 2.0, -3.0, NaN, 2.0, -4.0, NaN, 3.0, -4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrnansumabs2();
 
@@ -85,6 +86,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 14.0, 'returns expected value' );
+	t.strictEqual( acc(), 14.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/pcorr/test/test.js b/lib/node_modules/@stdlib/stats/incr/pcorr/test/test.js
index c1d06f2208f2..c75524d5397e 100644
--- a/lib/node_modules/@stdlib/stats/incr/pcorr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/pcorr/test/test.js
@@ -88,12 +88,12 @@ tape( 'the function throws an error if provided a non-numeric value for the seco
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrpcorr(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorr(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.equal( typeof incrpcorr( 3.0, -5.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorr( 3.0, -5.0 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -129,7 +129,7 @@ tape( 'the accumulator function incrementally computes a sample correlation coef
 		} else {
 			delta = abs( expected[ i ] - actual );
 			tol = 3.7 * EPS * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -167,7 +167,7 @@ tape( 'the accumulator function incrementally computes a sample correlation coef
 		} else {
 			delta = abs( expected[ i ] - actual );
 			tol = EPS * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -186,7 +186,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < x.length; i++ ) {
 		acc( x[ i ], y[ i ] );
 	}
-	t.equal( acc(), -0.7699852380946451, 'returns expected result' );
+	t.strictEqual( acc(), -0.7699852380946451, 'returns expected result' );
 	t.end();
 });
 
@@ -203,7 +203,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < x.length; i++ ) {
 		acc( x[ i ], y[ i ] );
 	}
-	t.equal( acc(), -0.7699852380946453, 'returns expected result' );
+	t.strictEqual( acc(), -0.7699852380946453, 'returns expected result' );
 	t.end();
 });
 
@@ -214,7 +214,7 @@ tape( 'the sample correlation coefficient is `null` until at least 1 datum has b
 	acc = incrpcorr();
 
 	v = acc();
-	t.equal( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns null' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
@@ -232,7 +232,7 @@ tape( 'the sample correlation coefficient is `null` until at least 1 datum has b
 	acc = incrpcorr( 3.0, -5.0 );
 
 	v = acc();
-	t.equal( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns null' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
@@ -250,10 +250,10 @@ tape( 'the sample correlation coefficient is `0` until at least 2 datums have be
 	acc = incrpcorr();
 
 	v = acc( 2.0, 10.0 );
-	t.equal( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns 0' );
 
 	v = acc();
-	t.equal( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns 0' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, 0.0, 'does not return 0' );
@@ -281,10 +281,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrpcorr();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	data = [
 		[ 1.0, NaN ],
@@ -297,10 +297,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrpcorr();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -322,10 +322,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrpcorr( 3.14, 1.0 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	data = [
 		[ 1.0, NaN ],
@@ -338,10 +338,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrpcorr( 3.14, 1.0 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/pcorr2/test/test.js b/lib/node_modules/@stdlib/stats/incr/pcorr2/test/test.js
index b1fdcf9cf1a1..973c0c809701 100644
--- a/lib/node_modules/@stdlib/stats/incr/pcorr2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/pcorr2/test/test.js
@@ -88,12 +88,12 @@ tape( 'the function throws an error if provided a non-numeric value for the seco
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrpcorr2(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorr2(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.equal( typeof incrpcorr2( 3.0, -5.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorr2( 3.0, -5.0 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -129,7 +129,7 @@ tape( 'the accumulator function incrementally computes a square sample correlati
 		} else {
 			delta = abs( expected[ i ] - actual );
 			tol = 7.0 * EPS * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -167,7 +167,7 @@ tape( 'the accumulator function incrementally computes a squared sample correlat
 		} else {
 			delta = abs( expected[ i ] - actual );
 			tol = 2.0 * EPS * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -186,7 +186,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < x.length; i++ ) {
 		acc( x[ i ], y[ i ] );
 	}
-	t.equal( acc(), 0.7699852380946451 * 0.7699852380946451, 'returns expected result' );
+	t.strictEqual( acc(), 0.7699852380946451 * 0.7699852380946451, 'returns expected result' );
 	t.end();
 });
 
@@ -203,7 +203,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < x.length; i++ ) {
 		acc( x[ i ], y[ i ] );
 	}
-	t.equal( acc(), 0.7699852380946453 * 0.7699852380946453, 'returns expected result' );
+	t.strictEqual( acc(), 0.7699852380946453 * 0.7699852380946453, 'returns expected result' );
 	t.end();
 });
 
@@ -214,7 +214,7 @@ tape( 'the squared sample correlation coefficient is `null` until at least 1 dat
 	acc = incrpcorr2();
 
 	v = acc();
-	t.equal( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns null' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
@@ -232,7 +232,7 @@ tape( 'the squared sample correlation coefficient is `null` until at least 1 dat
 	acc = incrpcorr2( 3.0, -5.0 );
 
 	v = acc();
-	t.equal( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns null' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
@@ -250,10 +250,10 @@ tape( 'the squared sample correlation coefficient is `0` until at least 2 datums
 	acc = incrpcorr2();
 
 	v = acc( 2.0, 10.0 );
-	t.equal( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns 0' );
 
 	v = acc();
-	t.equal( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns 0' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, 0.0, 'does not return 0' );
@@ -281,10 +281,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrpcorr2();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	data = [
 		[ 1.0, NaN ],
@@ -297,10 +297,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrpcorr2();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -322,10 +322,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrpcorr2( 3.14, 1.0 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	data = [
 		[ 1.0, NaN ],
@@ -338,10 +338,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrpcorr2( 3.14, 1.0 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/pcorrdist/test/test.js b/lib/node_modules/@stdlib/stats/incr/pcorrdist/test/test.js
index 8edc5cc780fc..62c2fc9b0c0c 100644
--- a/lib/node_modules/@stdlib/stats/incr/pcorrdist/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/pcorrdist/test/test.js
@@ -88,12 +88,12 @@ tape( 'the function throws an error if provided a non-numeric value for the seco
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrpcorrdist(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrdist(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.equal( typeof incrpcorrdist( 3.0, -5.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrdist( 3.0, -5.0 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -129,7 +129,7 @@ tape( 'the accumulator function incrementally computes a sample correlation dist
 		} else {
 			delta = abs( expected[ i ] - actual );
 			tol = 3.7 * EPS * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -167,7 +167,7 @@ tape( 'the accumulator function incrementally computes a sample correlation dist
 		} else {
 			delta = abs( expected[ i ] - actual );
 			tol = EPS * abs( expected[ i ] );
-			t.equal( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
+			t.strictEqual( delta <= tol, true, 'x: '+x[i]+'. y: '+y[i]+'. expected: '+expected[i]+'. actual: '+actual+'. tol: '+tol+'. delta: '+delta+'.' );
 		}
 	}
 	t.end();
@@ -186,7 +186,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < x.length; i++ ) {
 		acc( x[ i ], y[ i ] );
 	}
-	t.equal( acc(), 1.7699852380946451, 'returns expected result' );
+	t.strictEqual( acc(), 1.7699852380946451, 'returns expected result' );
 	t.end();
 });
 
@@ -203,7 +203,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < x.length; i++ ) {
 		acc( x[ i ], y[ i ] );
 	}
-	t.equal( acc(), 1.7699852380946453, 'returns expected result' );
+	t.strictEqual( acc(), 1.7699852380946453, 'returns expected result' );
 	t.end();
 });
 
@@ -214,7 +214,7 @@ tape( 'the sample correlation distance is `null` until at least 1 datum has been
 	acc = incrpcorrdist();
 
 	v = acc();
-	t.equal( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns null' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, null, 'does not return null' );
@@ -229,7 +229,7 @@ tape( 'the sample correlation distance is `null` until at least 1 datum has been
 	acc = incrpcorrdist( 3.0, -5.0 );
 
 	v = acc();
-	t.equal( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns null' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, null, 'does not return null' );
@@ -244,7 +244,7 @@ tape( 'the sample correlation distance is `1` until at least 2 datums have been
 	acc = incrpcorrdist();
 
 	v = acc( 2.0, 10.0 );
-	t.equal( v, 1.0, 'returns 1' );
+	t.strictEqual( v, 1.0, 'returns 1' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, 1.0, 'does not return 1' );
@@ -269,10 +269,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrpcorrdist();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	data = [
 		[ 1.0, NaN ],
@@ -285,10 +285,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrpcorrdist();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -310,10 +310,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrpcorrdist( 3.14, 1.0 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	data = [
 		[ 1.0, NaN ],
@@ -326,10 +326,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrpcorrdist( 3.14, 1.0 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ][ 0 ], data[ i ][ 1 ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/pcorrdistmat/test/test.js b/lib/node_modules/@stdlib/stats/incr/pcorrdistmat/test/test.js
index ec5fb11476ab..d358d8bd5696 100644
--- a/lib/node_modules/@stdlib/stats/incr/pcorrdistmat/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/pcorrdistmat/test/test.js
@@ -235,7 +235,7 @@ tape( 'the function throws an error if the number of known means does not match
 });
 
 tape( 'the function returns an accumulator function (order)', function test( t ) {
-	t.equal( typeof incrpcorrdistmat( 2 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrdistmat( 2 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -250,7 +250,7 @@ tape( 'the function returns an accumulator function (distance matrix)', function
 	strides = [ 2, 1 ];
 	dist = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.equal( typeof incrpcorrdistmat( dist ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrdistmat( dist ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -265,7 +265,7 @@ tape( 'the function returns an accumulator function (order; known means)', funct
 	strides = [ 1 ];
 	means = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.equal( typeof incrpcorrdistmat( 2, means ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrdistmat( 2, means ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -286,7 +286,7 @@ tape( 'the function returns an accumulator function (distance matrix; known mean
 	strides = [ 1 ];
 	means = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.equal( typeof incrpcorrdistmat( dist, means ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrdistmat( dist, means ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -641,7 +641,7 @@ tape( 'the accumulator function incrementally computes a sample Pearson product-
 				} else {
 					delta = abs( e - v );
 					tol = 3.0 * EPS * abs( e );
-					t.equal( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+					t.strictEqual( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
 				}
 			}
 		}
@@ -712,7 +712,7 @@ tape( 'the accumulator function incrementally computes a sample Pearson product-
 				} else {
 					delta = abs( e - v );
 					tol = 3.0 * EPS * abs( e );
-					t.equal( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+					t.strictEqual( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
 				}
 			}
 		}
@@ -780,7 +780,7 @@ tape( 'the accumulator function incrementally computes a sample Pearson product-
 				} else {
 					delta = abs( e - v );
 					tol = 3.0 * EPS * abs( e );
-					t.equal( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+					t.strictEqual( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
 				}
 			}
 		}
@@ -855,7 +855,7 @@ tape( 'the accumulator function incrementally computes a sample Pearson product-
 				} else {
 					delta = abs( e - v );
 					tol = 3.0 * EPS * abs( e );
-					t.equal( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+					t.strictEqual( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
 				}
 			}
 		}
diff --git a/lib/node_modules/@stdlib/stats/incr/pcorrmat/test/test.js b/lib/node_modules/@stdlib/stats/incr/pcorrmat/test/test.js
index ea8746ccde97..f70b20686051 100644
--- a/lib/node_modules/@stdlib/stats/incr/pcorrmat/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/pcorrmat/test/test.js
@@ -235,7 +235,7 @@ tape( 'the function throws an error if the number of known means does not match
 });
 
 tape( 'the function returns an accumulator function (order)', function test( t ) {
-	t.equal( typeof incrpcorrmat( 2 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrmat( 2 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -250,7 +250,7 @@ tape( 'the function returns an accumulator function (correlation matrix)', funct
 	strides = [ 2, 1 ];
 	corr = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.equal( typeof incrpcorrmat( corr ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrmat( corr ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -265,7 +265,7 @@ tape( 'the function returns an accumulator function (order; known means)', funct
 	strides = [ 1 ];
 	means = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.equal( typeof incrpcorrmat( 2, means ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrmat( 2, means ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -286,7 +286,7 @@ tape( 'the function returns an accumulator function (correlation matrix; known m
 	strides = [ 1 ];
 	means = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.equal( typeof incrpcorrmat( corr, means ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrmat( corr, means ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -641,7 +641,7 @@ tape( 'the accumulator function incrementally computes a sample Pearson product-
 				} else {
 					delta = abs( e - v );
 					tol = 3.0 * EPS * abs( e );
-					t.equal( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+					t.strictEqual( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
 				}
 			}
 		}
@@ -712,7 +712,7 @@ tape( 'the accumulator function incrementally computes a sample Pearson product-
 				} else {
 					delta = abs( e - v );
 					tol = 3.0 * EPS * abs( e );
-					t.equal( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+					t.strictEqual( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
 				}
 			}
 		}
@@ -780,7 +780,7 @@ tape( 'the accumulator function incrementally computes a sample Pearson product-
 				} else {
 					delta = abs( e - v );
 					tol = 3.0 * EPS * abs( e );
-					t.equal( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+					t.strictEqual( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
 				}
 			}
 		}
@@ -855,7 +855,7 @@ tape( 'the accumulator function incrementally computes a sample Pearson product-
 				} else {
 					delta = abs( e - v );
 					tol = 3.0 * EPS * abs( e );
-					t.equal( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
+					t.strictEqual( delta <= tol, true, 'i: '+i+'. j: '+j+'. k: '+k+'. expected: '+e+'. actual: '+v+'. tol: '+tol+'. delta: '+delta+'.' );
 				}
 			}
 		}
diff --git a/lib/node_modules/@stdlib/stats/incr/range/test/test.js b/lib/node_modules/@stdlib/stats/incr/range/test/test.js
index 1e698bb99e88..988764daebd8 100644
--- a/lib/node_modules/@stdlib/stats/incr/range/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/range/test/test.js
@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrrange = require( './../lib' );
 
 
@@ -34,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrrange(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrrange(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'if not provided any values, the initial returned range is `null`', function test( t ) {
 	var acc = incrrange();
-	t.equal( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns null' );
 	t.end();
 });
 
@@ -58,8 +59,8 @@ tape( 'the accumulator function incrementally computes a range', function test(
 	data = [ 2.0, 3.0, 2.0, 4.0, 3.0, 4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrrange();
 
@@ -89,7 +90,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 5.0, 'returns the current accumulated range' );
+	t.strictEqual( acc(), 5.0, 'returns the current accumulated range' );
 	t.end();
 });
 
@@ -103,6 +104,6 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/rmse/test/test.js b/lib/node_modules/@stdlib/stats/incr/rmse/test/test.js
index 1cb57c38aa36..97e622090149 100644
--- a/lib/node_modules/@stdlib/stats/incr/rmse/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/rmse/test/test.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrrmse(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrrmse(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrrmse();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -81,11 +81,11 @@ tape( 'the accumulator function incrementally computes the root mean squared err
 		expected = sqrt( sum/(i+1) );
 		actual = acc( x, y );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value' );
+			t.strictEqual( actual, expected, 'returns expected value' );
 		} else {
 			delta = abs( expected - actual );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -113,6 +113,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	expected = sqrt( ( 1.0+64.0+81.0 ) / 3.0 );
 	delta = abs( expected - actual );
 	tol = 1.0 * EPS * abs( expected );
-	t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+	t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/rss/test/test.js b/lib/node_modules/@stdlib/stats/incr/rss/test/test.js
index d808fcf7f1fd..a00473c88c49 100644
--- a/lib/node_modules/@stdlib/stats/incr/rss/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/rss/test/test.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrrss(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrrss(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrrss();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -80,11 +80,11 @@ tape( 'the accumulator function incrementally computes the residual sum of squar
 		expected = sum;
 		actual = acc( x, y );
 		if ( actual === expected ) {
-			t.equal( actual, expected, 'returns expected value' );
+			t.strictEqual( actual, expected, 'returns expected value' );
 		} else {
 			delta = abs( expected - actual );
 			tol = 1.0 * EPS * abs( expected );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -112,6 +112,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	expected = 1.0 + 64.0 + 81.0;
 	delta = abs( expected - actual );
 	tol = 1.0 * EPS * abs( expected );
-	t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
+	t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected+'. Delta: '+delta+'. Tol: '+tol+'.' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/skewness/test/test.js b/lib/node_modules/@stdlib/stats/incr/skewness/test/test.js
index 9e73523dd5b3..5b9e33318660 100644
--- a/lib/node_modules/@stdlib/stats/incr/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/skewness/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrskewness(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrskewness(), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -64,7 +64,7 @@ tape( 'the accumulator function incrementally computes a corrected sample skewne
 	for ( i = 0; i < data.length; i++ ) {
 		actual = acc( data[ i ] );
 		if ( expected[ i ] === null ) {
-			t.equal( actual, expected[i], 'returns null' );
+			t.strictEqual( actual, expected[i], 'returns null' );
 		} else {
 			delta = abs( actual - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
@@ -103,13 +103,13 @@ tape( 'the corrected sample skewness is `null` until at least 3 datums have been
 	acc = incrskewness();
 
 	skewness = acc();
-	t.equal( skewness, null, 'returns null' );
+	t.strictEqual( skewness, null, 'returns null' );
 
 	skewness = acc( 2.0 );
-	t.equal( skewness, null, 'returns null' );
+	t.strictEqual( skewness, null, 'returns null' );
 
 	skewness = acc( 2.0 );
-	t.equal( skewness, null, 'returns null' );
+	t.strictEqual( skewness, null, 'returns null' );
 
 	skewness = acc( 3.0 );
 	t.notEqual( skewness, null, 'does not return null' );
@@ -127,9 +127,9 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrskewness();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/stdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/stdev/test/test.js
index a7883a549ecd..788fa482da10 100644
--- a/lib/node_modules/@stdlib/stats/incr/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/stdev/test/test.js
@@ -35,12 +35,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrstdev(), 'function', 'returns expected value' );
+	t.strictEqual( typeof incrstdev(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.equal( typeof incrstdev( 3.0 ), 'function', 'returns expected value' );
+	t.strictEqual( typeof incrstdev( 3.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -138,7 +138,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 1.0, 'returns expected value' );
+	t.strictEqual( acc(), 1.0, 'returns expected value' );
 	t.end();
 });
 
@@ -152,7 +152,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), sqrt( 0.6666666666666666 ), 'returns expected value' );
+	t.strictEqual( acc(), sqrt( 0.6666666666666666 ), 'returns expected value' );
 	t.end();
 });
 
@@ -163,7 +163,7 @@ tape( 'the corrected sample standard deviation is `null` until at least 1 datum
 	acc = incrstdev();
 
 	s = acc();
-	t.equal( s, null, 'returns expected value' );
+	t.strictEqual( s, null, 'returns expected value' );
 
 	s = acc( 3.0 );
 	t.notEqual( s, null, 'returns expected value' );
@@ -181,7 +181,7 @@ tape( 'the corrected sample standard deviation is `null` until at least 1 datum
 	acc = incrstdev( 3.0 );
 
 	s = acc();
-	t.equal( s, null, 'returns expected value' );
+	t.strictEqual( s, null, 'returns expected value' );
 
 	s = acc( 3.0 );
 	t.notEqual( s, null, 'returns expected value' );
@@ -199,10 +199,10 @@ tape( 'the corrected sample standard deviation is `0` until at least 2 datums ha
 	acc = incrstdev();
 
 	s = acc( 2.0 );
-	t.equal( s, 0.0, 'returns expected value' );
+	t.strictEqual( s, 0.0, 'returns expected value' );
 
 	s = acc();
-	t.equal( s, 0.0, 'returns expected value' );
+	t.strictEqual( s, 0.0, 'returns expected value' );
 
 	s = acc( 3.0 );
 	t.notEqual( s, 0.0, 'returns expected value' );
@@ -223,10 +223,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrstdev();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -240,9 +240,9 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrstdev( 3.14 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/sum/test/test.js b/lib/node_modules/@stdlib/stats/incr/sum/test/test.js
index 1cf98a4615b3..be7143676b58 100644
--- a/lib/node_modules/@stdlib/stats/incr/sum/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/sum/test/test.js
@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrsum = require( './../lib' );
 
 
@@ -33,13 +34,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrsum(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrsum(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrsum();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -56,8 +57,8 @@ tape( 'the accumulator function incrementally computes a sum', function test( t
 	data = [ 2.0, 3.0, 2.0, 4.0, 3.0, 4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrsum();
 
@@ -84,7 +85,7 @@ tape( 'the accumulator function incrementally computes an accurate sum', functio
 	N = data.length;
 
 	expected = [ 1.0, 1.0e100, 1.0e100, 2.0 ];
-	actual = new Array( N );
+	actual = zeros( N );
 
 	acc = incrsum();
 
@@ -105,6 +106,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 6.0, 'returns the current accumulated sum' );
+	t.strictEqual( acc(), 6.0, 'returns the current accumulated sum' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/sumabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/sumabs/test/test.js
index b1d234b6ca13..1f0025ee3334 100644
--- a/lib/node_modules/@stdlib/stats/incr/sumabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/sumabs/test/test.js
@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrsumabs = require( './../lib' );
 
 
@@ -33,13 +34,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrsumabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrsumabs(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrsumabs();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -56,8 +57,8 @@ tape( 'the accumulator function incrementally computes a sum of absolute values'
 	data = [ 2.0, -3.0, 2.0, -4.0, 3.0, -4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrsumabs();
 
@@ -82,6 +83,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 6.0, 'returns expected value' );
+	t.strictEqual( acc(), 6.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/sumabs2/test/test.js b/lib/node_modules/@stdlib/stats/incr/sumabs2/test/test.js
index df8b30eef60c..a6917e738ec7 100644
--- a/lib/node_modules/@stdlib/stats/incr/sumabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/sumabs2/test/test.js
@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrsumabs2 = require( './../lib' );
 
 
@@ -33,13 +34,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrsumabs2(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrsumabs2(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrsumabs2();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -56,8 +57,8 @@ tape( 'the accumulator function incrementally computes a sum of squared absolute
 	data = [ 2.0, -3.0, 2.0, -4.0, 3.0, -4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrsumabs2();
 
@@ -82,6 +83,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 14.0, 'returns expected value' );
+	t.strictEqual( acc(), 14.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/summary/test/test.js b/lib/node_modules/@stdlib/stats/incr/summary/test/test.js
index ebcffda664d1..1378957a77df 100644
--- a/lib/node_modules/@stdlib/stats/incr/summary/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/summary/test/test.js
@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrsummary = require( './../lib' );
 
 
@@ -33,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrsummary(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrsummary(), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -54,7 +55,7 @@ tape( 'the accumulator function incrementally computes a summary', function test
 	data = [ 2.0, 3.0, -2.0, 4.0, 3.0, 4.0 ];
 	N = data.length;
 
-	actual = new Array( N );
+	actual = zeros( N );
 
 	acc = incrsummary();
 	for ( i = 0; i < N; i++ ) {
diff --git a/lib/node_modules/@stdlib/stats/incr/sumprod/test/test.js b/lib/node_modules/@stdlib/stats/incr/sumprod/test/test.js
index 8adabe564136..99dc55acc872 100644
--- a/lib/node_modules/@stdlib/stats/incr/sumprod/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/sumprod/test/test.js
@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrsumprod = require( './../lib' );
 
 
@@ -33,13 +34,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrsumprod(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrsumprod(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrsumprod();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -64,8 +65,8 @@ tape( 'the accumulator function incrementally computes a sum of products (aka do
 	];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrsumprod();
 
@@ -95,6 +96,6 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ][ 0 ], data[ i ][ 1 ] );
 	}
-	t.equal( acc(), 1.0, 'returns expected value' );
+	t.strictEqual( acc(), 1.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/test/test.js b/lib/node_modules/@stdlib/stats/incr/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/stats/incr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/variance/test/test.js b/lib/node_modules/@stdlib/stats/incr/variance/test/test.js
index e5966a6bd4b5..43931e4b6a46 100644
--- a/lib/node_modules/@stdlib/stats/incr/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/variance/test/test.js
@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrvariance = require( './../lib' );
 
 
@@ -34,12 +35,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrvariance(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrvariance(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.equal( typeof incrvariance( 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrvariance( 3.0 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -90,7 +91,7 @@ tape( 'the accumulator function incrementally computes an unbiased sample varian
 
 	acc = incrvariance();
 
-	actual = new Array( data.length );
+	actual = zeros( data.length );
 	for ( i = 0; i < data.length; i++ ) {
 		actual[ i ] = acc( data[ i ] );
 	}
@@ -119,7 +120,7 @@ tape( 'the accumulator function incrementally computes an unbiased sample varian
 
 	acc = incrvariance( 3.0 );
 
-	actual = new Array( data.length );
+	actual = zeros( data.length );
 	for ( i = 0; i < data.length; i++ ) {
 		actual[ i ] = acc( data[ i ] );
 	}
@@ -137,7 +138,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 1.0, 'returns the current accumulated unbiased sample variance' );
+	t.strictEqual( acc(), 1.0, 'returns the current accumulated unbiased sample variance' );
 	t.end();
 });
 
@@ -151,7 +152,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 0.6666666666666666, 'returns the current accumulated unbiased sample variance' );
+	t.strictEqual( acc(), 0.6666666666666666, 'returns the current accumulated unbiased sample variance' );
 	t.end();
 });
 
@@ -162,7 +163,7 @@ tape( 'the sample variance is `null` until at least 1 datum has been provided (u
 	acc = incrvariance();
 
 	s2 = acc();
-	t.equal( s2, null, 'returns null' );
+	t.strictEqual( s2, null, 'returns null' );
 
 	s2 = acc( 3.0 );
 	t.notEqual( s2, null, 'does not return null' );
@@ -180,7 +181,7 @@ tape( 'the sample variance is `null` until at least 1 datum has been provided (k
 	acc = incrvariance( 3.0 );
 
 	s2 = acc();
-	t.equal( s2, null, 'returns null' );
+	t.strictEqual( s2, null, 'returns null' );
 
 	s2 = acc( 3.0 );
 	t.notEqual( s2, null, 'does not return null' );
@@ -198,10 +199,10 @@ tape( 'the sample variance is `0` until at least 2 datums have been provided (un
 	acc = incrvariance();
 
 	s2 = acc( 2.0 );
-	t.equal( s2, 0.0, 'returns 0' );
+	t.strictEqual( s2, 0.0, 'returns 0' );
 
 	s2 = acc();
-	t.equal( s2, 0.0, 'returns 0' );
+	t.strictEqual( s2, 0.0, 'returns 0' );
 
 	s2 = acc( 3.0 );
 	t.notEqual( s2, 0.0, 'does not return 0' );
@@ -222,10 +223,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrvariance();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -239,9 +240,9 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrvariance( 3.14 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/vmr/test/test.js b/lib/node_modules/@stdlib/stats/incr/vmr/test/test.js
index 7c712a90f35f..b6c93b645f7f 100644
--- a/lib/node_modules/@stdlib/stats/incr/vmr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/vmr/test/test.js
@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var incrvmr = require( './../lib' );
 
 
@@ -34,12 +35,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrvmr(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrvmr(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.equal( typeof incrvmr( 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrvmr( 3.0 ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -90,7 +91,7 @@ tape( 'the accumulator function incrementally computes a variance-to-mean ratio'
 
 	acc = incrvmr();
 
-	actual = new Array( data.length );
+	actual = zeros( data.length );
 	for ( i = 0; i < data.length; i++ ) {
 		actual[ i ] = acc( data[ i ] );
 	}
@@ -119,7 +120,7 @@ tape( 'the accumulator function incrementally computes a variance-to-mean ratio
 
 	acc = incrvmr( 3.0 );
 
-	actual = new Array( data.length );
+	actual = zeros( data.length );
 	for ( i = 0; i < data.length; i++ ) {
 		actual[ i ] = acc( data[ i ] );
 	}
@@ -137,7 +138,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 1.0/2.0, 'returns expected value' );
+	t.strictEqual( acc(), 1.0/2.0, 'returns expected value' );
 	t.end();
 });
 
@@ -151,7 +152,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 	for ( i = 0; i < data.length; i++ ) {
 		acc( data[ i ] );
 	}
-	t.equal( acc(), 0.6666666666666666/2.0, 'returns expected value' );
+	t.strictEqual( acc(), 0.6666666666666666/2.0, 'returns expected value' );
 	t.end();
 });
 
@@ -162,7 +163,7 @@ tape( 'the accumulated value is `null` until at least 1 datum has been provided
 	acc = incrvmr();
 
 	D = acc();
-	t.equal( D, null, 'returns null' );
+	t.strictEqual( D, null, 'returns null' );
 
 	D = acc( 3.0 );
 	t.notEqual( D, null, 'does not return null' );
@@ -180,7 +181,7 @@ tape( 'the accumulated value is `null` until at least 1 datum has been provided
 	acc = incrvmr( 3.0 );
 
 	D = acc();
-	t.equal( D, null, 'returns null' );
+	t.strictEqual( D, null, 'returns null' );
 
 	D = acc( 3.0 );
 	t.notEqual( D, null, 'does not return null' );
@@ -198,10 +199,10 @@ tape( 'the accumulated value is `0` until at least 2 datums have been provided (
 	acc = incrvmr();
 
 	D = acc( 2.0 );
-	t.equal( D, 0.0, 'returns 0' );
+	t.strictEqual( D, 0.0, 'returns 0' );
 
 	D = acc();
-	t.equal( D, 0.0, 'returns 0' );
+	t.strictEqual( D, 0.0, 'returns 0' );
 
 	D = acc( 3.0 );
 	t.notEqual( D, 0.0, 'does not return 0' );
@@ -222,10 +223,10 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrvmr();
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -239,9 +240,9 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for all futur
 	acc = incrvmr( 3.14 );
 	for ( i = 0; i < data.length; i++ ) {
 		v = acc( data[ i ] );
-		t.equal( isnan( v ), true, 'returns expected value' );
-		t.equal( isnan( acc() ), true, 'returns expected value' );
+		t.strictEqual( isnan( v ), true, 'returns expected value' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
-	t.equal( isnan( acc() ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/wmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/wmean/test/test.js
index a238dac9005f..718a86b72cbe 100644
--- a/lib/node_modules/@stdlib/stats/incr/wmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/wmean/test/test.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.equal( typeof incrwmean(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrwmean(), 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrwmean();
-	t.equal( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -95,28 +95,28 @@ tape( 'if not provided arguments, the accumulator function returns the current w
 	for ( i = 0; i < dataX.length; i++ ) {
 		acc( dataX[ i ], dataW[ i ] );
 	}
-	t.equal( acc(), 2.2, 'returns the current accumulated mean' );
+	t.strictEqual( acc(), 2.2, 'returns the current accumulated mean' );
 	t.end();
 });
 
 tape( 'if not provided a weight, the accumulator function returns `NaN`', function test( t ) {
 	var acc = incrwmean();
-	t.equal( isnan( acc( 2.0 ) ), true, 'returns NaN' );
-	t.equal( isnan( acc( 3.14 ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc( 2.0 ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc( 3.14 ) ), true, 'returns NaN' );
 	t.end();
 });
 
 tape( 'if provided `NaN` for either a value or a weight, the accumulator function returns `NaN`', function test( t ) {
 	var acc = incrwmean();
-	t.equal( isnan( acc( 2.0, NaN ) ), true, 'returns NaN' );
-	t.equal( isnan( acc( 3.14, NaN ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc( 2.0, NaN ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc( 3.14, NaN ) ), true, 'returns NaN' );
 
 	acc = incrwmean();
-	t.equal( isnan( acc( NaN, 1.0 ) ), true, 'returns NaN' );
-	t.equal( isnan( acc( NaN, 1.0 ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc( NaN, 1.0 ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc( NaN, 1.0 ) ), true, 'returns NaN' );
 
 	acc = incrwmean();
-	t.equal( isnan( acc( NaN, NaN ) ), true, 'returns NaN' );
-	t.equal( isnan( acc( NaN, NaN ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc( NaN, NaN ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc( NaN, NaN ) ), true, 'returns NaN' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cugmean/test/test.js b/lib/node_modules/@stdlib/stats/iter/cugmean/test/test.js
index a30551f23b7e..38b4071043d1 100644
--- a/lib/node_modules/@stdlib/stats/iter/cugmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cugmean/test/test.js
@@ -83,20 +83,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 		expected.push( acc( values[ i ] ) );
 	}
 	it = itercugmean( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,9 +118,9 @@ tape( 'if an iterated value is a non-numeric value, the computed geometric mean
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -133,9 +133,9 @@ tape( 'if an iterated value is a non-numeric value, the computed geometric mean
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -148,20 +148,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercugmean( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -173,20 +173,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercugmean( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -210,16 +210,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercugmean( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -237,7 +237,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercugmean( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -255,7 +255,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercugmean( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cuhmean/test/test.js b/lib/node_modules/@stdlib/stats/iter/cuhmean/test/test.js
index 9b659c66589c..74d92b524c0b 100644
--- a/lib/node_modules/@stdlib/stats/iter/cuhmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cuhmean/test/test.js
@@ -83,20 +83,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 		expected.push( acc( values[ i ] ) );
 	}
 	it = itercuhmean( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,9 +118,9 @@ tape( 'if an iterated value is a non-numeric value, the computed harmonic mean i
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -133,9 +133,9 @@ tape( 'if an iterated value is a non-numeric value, the computed harmonic mean i
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -148,20 +148,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercuhmean( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -173,20 +173,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercuhmean( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -210,16 +210,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercuhmean( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -237,7 +237,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercuhmean( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -255,7 +255,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercuhmean( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cumax/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumax/test/test.js
index 0d50fe883bf5..f8e0a17d871b 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumax/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumax/test/test.js
@@ -77,20 +77,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 3.0, 3.0, 4.0, 4.0, 4.0 ];
 
 	it = itercumax( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,9 +110,9 @@ tape( 'if an iterated value is a non-numeric value, the computed maximum value i
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -124,9 +124,9 @@ tape( 'if an iterated value is a non-numeric value, the computed maximum value i
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -139,20 +139,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumax( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,20 +164,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumax( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -201,16 +201,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercumax( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -228,7 +228,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercumax( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercumax( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cumaxabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumaxabs/test/test.js
index 8190334c3099..8980af4e2003 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumaxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumaxabs/test/test.js
@@ -77,20 +77,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 3.0, 3.0, 4.0, 4.0, 4.0 ];
 
 	it = itercumaxabs( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,9 +110,9 @@ tape( 'if an iterated value is a non-numeric value, the computed maximum value i
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -124,9 +124,9 @@ tape( 'if an iterated value is a non-numeric value, the computed maximum value i
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -139,20 +139,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumaxabs( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,20 +164,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumaxabs( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -201,16 +201,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercumaxabs( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -228,7 +228,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercumaxabs( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercumaxabs( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cumean/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumean/test/test.js
index aa6caba1fc21..fd898b89c9b9 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumean/test/test.js
@@ -77,20 +77,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0/1.0, 5.0/2.0, 7.0/3.0, 11.0/4.0, 14.0/5.0, 18.0/6.0 ];
 
 	it = itercumean( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,9 +110,9 @@ tape( 'if an iterated value is a non-numeric value, the computed mean is `NaN`',
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -124,9 +124,9 @@ tape( 'if an iterated value is a non-numeric value, the computed mean is `NaN`',
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -139,20 +139,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumean( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,20 +164,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumean( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -201,16 +201,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercumean( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -228,7 +228,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercumean( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercumean( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cumeanabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumeanabs/test/test.js
index 3f04956534f6..cf2291052f5c 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumeanabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumeanabs/test/test.js
@@ -77,20 +77,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0/1.0, 5.0/2.0, 7.0/3.0, 11.0/4.0, 14.0/5.0, 18.0/6.0 ];
 
 	it = itercumeanabs( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,9 +110,9 @@ tape( 'if an iterated value is a non-numeric value, the computed mean is `NaN`',
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -124,9 +124,9 @@ tape( 'if an iterated value is a non-numeric value, the computed mean is `NaN`',
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -139,20 +139,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumeanabs( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,20 +164,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumeanabs( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -201,16 +201,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercumeanabs( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -228,7 +228,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercumeanabs( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercumeanabs( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cumeanabs2/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumeanabs2/test/test.js
index 15a7bf2a4339..086d078aadeb 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumeanabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumeanabs2/test/test.js
@@ -81,25 +81,25 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 4.0/1.0, 13.0/2.0, 17.0/3.0, 33.0/4.0, 42.0/5.0, 58.0/6.0 ];
 
 	it = itercumeanabs2( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 
 		actual = v.value;
 		if ( actual === expected[i] ) {
-			t.equal( actual, expected[i], 'returns expected value' );
+			t.strictEqual( actual, expected[i], 'returns expected value' );
 		} else {
 			delta = abs( expected[i] - actual );
 			tol = 1.0 * EPS * abs( expected[i] );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -119,9 +119,9 @@ tape( 'if an iterated value is a non-numeric value, the computed mean is `NaN`',
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -133,9 +133,9 @@ tape( 'if an iterated value is a non-numeric value, the computed mean is `NaN`',
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -148,20 +148,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumeanabs2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -173,20 +173,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumeanabs2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -210,16 +210,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercumeanabs2( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -237,7 +237,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercumeanabs2( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -255,7 +255,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercumeanabs2( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cumidrange/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumidrange/test/test.js
index eef10f225a38..194f6c248f26 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumidrange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumidrange/test/test.js
@@ -77,20 +77,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 2.5, 2.5, 3.0, 3.0, 3.0 ];
 
 	it = itercumidrange( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,9 +110,9 @@ tape( 'if an iterated value is a non-numeric value, the computed mid-range is `N
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -124,9 +124,9 @@ tape( 'if an iterated value is a non-numeric value, the computed mid-range is `N
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -139,20 +139,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumidrange( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,20 +164,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumidrange( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -201,16 +201,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercumidrange( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -228,7 +228,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercumidrange( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercumidrange( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cumin/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumin/test/test.js
index a04095fd3049..4f2618015fb5 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumin/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumin/test/test.js
@@ -77,20 +77,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 2.0, -2.0, -2.0, -2.0, -2.0 ];
 
 	it = itercumin( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,9 +110,9 @@ tape( 'if an iterated value is a non-numeric value, the computed minimum value i
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -124,9 +124,9 @@ tape( 'if an iterated value is a non-numeric value, the computed minimum value i
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -139,20 +139,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumin( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,20 +164,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumin( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -201,16 +201,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercumin( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -228,7 +228,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercumin( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercumin( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cuminabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/cuminabs/test/test.js
index 3765efc92ed6..d58e44ef33cc 100644
--- a/lib/node_modules/@stdlib/stats/iter/cuminabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cuminabs/test/test.js
@@ -77,20 +77,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ];
 
 	it = itercuminabs( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,9 +110,9 @@ tape( 'if an iterated value is a non-numeric value, the computed minimum value i
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -124,9 +124,9 @@ tape( 'if an iterated value is a non-numeric value, the computed minimum value i
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -139,20 +139,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercuminabs( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,20 +164,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercuminabs( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -201,16 +201,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercuminabs( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -228,7 +228,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercuminabs( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercuminabs( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cuprod/test/test.js b/lib/node_modules/@stdlib/stats/iter/cuprod/test/test.js
index 175a73d4458a..647b5f8bcfb5 100644
--- a/lib/node_modules/@stdlib/stats/iter/cuprod/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cuprod/test/test.js
@@ -77,20 +77,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 6.0, 12.0, 48.0, 144.0, 576.0 ];
 
 	it = itercuprod( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,9 +110,9 @@ tape( 'if an iterated value is a non-numeric value, the computed product is `NaN
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -124,9 +124,9 @@ tape( 'if an iterated value is a non-numeric value, the computed product is `NaN
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -139,20 +139,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercuprod( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,20 +164,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercuprod( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -201,16 +201,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercuprod( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -228,7 +228,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercuprod( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercuprod( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/curange/test/test.js b/lib/node_modules/@stdlib/stats/iter/curange/test/test.js
index dee74d2e62d6..0bb05f518ae0 100644
--- a/lib/node_modules/@stdlib/stats/iter/curange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/curange/test/test.js
@@ -77,20 +77,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 0.0, 1.0, 1.0, 2.0, 2.0, 2.0 ];
 
 	it = itercurange( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,9 +110,9 @@ tape( 'if an iterated value is a non-numeric value, the computed range is `NaN`'
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -124,9 +124,9 @@ tape( 'if an iterated value is a non-numeric value, the computed range is `NaN`'
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -139,20 +139,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercurange( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,20 +164,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercurange( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -201,16 +201,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercurange( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -228,7 +228,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercurange( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercurange( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cusum/test/test.js b/lib/node_modules/@stdlib/stats/iter/cusum/test/test.js
index f9860edda727..c5a6c806059c 100644
--- a/lib/node_modules/@stdlib/stats/iter/cusum/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cusum/test/test.js
@@ -77,20 +77,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 5.0, 7.0, 11.0, 14.0, 18.0 ];
 
 	it = itercusum( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,9 +110,9 @@ tape( 'if an iterated value is a non-numeric value, the computed sum is `NaN`',
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -124,9 +124,9 @@ tape( 'if an iterated value is a non-numeric value, the computed sum is `NaN`',
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -139,20 +139,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercusum( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,20 +164,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercusum( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -201,16 +201,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercusum( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -228,7 +228,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercusum( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercusum( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cusumabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/cusumabs/test/test.js
index 198b88a9e344..979b61aa9d39 100644
--- a/lib/node_modules/@stdlib/stats/iter/cusumabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cusumabs/test/test.js
@@ -77,20 +77,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 5.0, 7.0, 11.0, 14.0, 18.0 ];
 
 	it = itercusumabs( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,9 +110,9 @@ tape( 'if an iterated value is a non-numeric value, the computed sum is `NaN`',
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -124,9 +124,9 @@ tape( 'if an iterated value is a non-numeric value, the computed sum is `NaN`',
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -139,20 +139,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercusumabs( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,20 +164,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercusumabs( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -201,16 +201,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercusumabs( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -228,7 +228,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercusumabs( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercusumabs( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/cusumabs2/test/test.js b/lib/node_modules/@stdlib/stats/iter/cusumabs2/test/test.js
index db0fc487c33c..770126f05972 100644
--- a/lib/node_modules/@stdlib/stats/iter/cusumabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cusumabs2/test/test.js
@@ -77,20 +77,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 4.0, 13.0, 17.0, 33.0, 42.0, 58.0 ];
 
 	it = itercusumabs2( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,9 +110,9 @@ tape( 'if an iterated value is a non-numeric value, the computed sum is `NaN`',
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 
@@ -124,9 +124,9 @@ tape( 'if an iterated value is a non-numeric value, the computed sum is `NaN`',
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for iteration '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for iteration '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for iteration '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for iteration '+i );
 		}
 	}
 	t.end();
@@ -139,20 +139,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercusumabs2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,20 +164,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercusumabs2( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -201,16 +201,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itercusumabs2( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -228,7 +228,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itercusumabs2( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itercusumabs2( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/mmax/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmax/test/test.js
index dfb6f55d1b6e..fda39b239872 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmax/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmax/test/test.js
@@ -107,20 +107,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 3.0, 3.0, 4.0, 4.0, 4.0 ];
 
 	it = itermmax( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'if an iterated value is a non-numeric value, the computed maximum value i
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmax( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmax( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itermmax( rand, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itermmax( randu(), 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itermmax( rand, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/mmaxabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmaxabs/test/test.js
index 5ac12b554eba..6c90ef30d128 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmaxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmaxabs/test/test.js
@@ -107,20 +107,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 3.0, 3.0, 4.0, 4.0, 4.0 ];
 
 	it = itermmaxabs( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'if an iterated value is a non-numeric value, the computed maximum absolut
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmaxabs( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmaxabs( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itermmaxabs( rand, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itermmaxabs( randu(), 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itermmaxabs( rand, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/mmean/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmean/test/test.js
index 4138f8e5c7e4..7a2522c9494b 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmean/test/test.js
@@ -107,20 +107,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 2.5, 7.0/3.0, 3.0, 3.0, 11.0/3.0 ];
 
 	it = itermmean( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'if an iterated value is a non-numeric value, the computed mean is `NaN` f
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmean( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmean( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itermmean( rand, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itermmean( randu(), 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itermmean( rand, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/mmeanabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmeanabs/test/test.js
index 1f89fe88bab2..e1d07702e1ab 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmeanabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmeanabs/test/test.js
@@ -107,20 +107,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 2.5, 7.0/3.0, 3.0, 3.0, 11.0/3.0 ];
 
 	it = itermmeanabs( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'if an iterated value is a non-numeric value, the computed mean is `NaN` f
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmeanabs( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmeanabs( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itermmeanabs( rand, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itermmeanabs( randu(), 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itermmeanabs( rand, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/mmeanabs2/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmeanabs2/test/test.js
index 6477b7c60f05..fc805aaeaded 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmeanabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmeanabs2/test/test.js
@@ -111,25 +111,25 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 4.0, 6.5, 17.0/3.0, 29.0/3.0, 29.0/3.0, 41.0/3.0 ];
 
 	it = itermmeanabs2( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 
 		actual = v.value;
 		if ( actual === expected[i] ) {
-			t.equal( actual, expected[i], 'returns expected value' );
+			t.strictEqual( actual, expected[i], 'returns expected value' );
 		} else {
 			delta = abs( expected[i] - actual );
 			tol = 1.0 * EPS * abs( expected[i] );
-			t.equal( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. Actual: '+actual+'. Expected: '+expected[i]+'. Delta: '+delta+'. Tol: '+tol+'.' );
 		}
 	}
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -190,9 +190,9 @@ tape( 'if an iterated value is a non-numeric value, the computed mean is `NaN` f
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -205,20 +205,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmeanabs2( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -230,20 +230,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmeanabs2( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -267,16 +267,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itermmeanabs2( rand, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -294,7 +294,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itermmeanabs2( randu(), 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -312,7 +312,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itermmeanabs2( rand, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/mmidrange/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmidrange/test/test.js
index f02341afc131..bdea03bfb198 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmidrange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmidrange/test/test.js
@@ -107,20 +107,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 2.5, 2.5, 3.0, 3.0, 3.5 ];
 
 	it = itermmidrange( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'if an iterated value is a non-numeric value, the computed mid-range is `N
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmidrange( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmidrange( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itermmidrange( rand, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itermmidrange( randu(), 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itermmidrange( rand, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/mmin/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmin/test/test.js
index 92dba89d70af..71b71225e7b6 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmin/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmin/test/test.js
@@ -107,20 +107,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 2.0, 2.0, 2.0, 2.0, 3.0 ];
 
 	it = itermmin( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'if an iterated value is a non-numeric value, the computed minimum value i
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmin( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmin( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itermmin( rand, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itermmin( randu(), 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itermmin( rand, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/mminabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/mminabs/test/test.js
index f3d1e6dbd2f7..d31b1f851f6b 100644
--- a/lib/node_modules/@stdlib/stats/iter/mminabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mminabs/test/test.js
@@ -107,20 +107,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 2.0, 2.0, 2.0, 2.0, 3.0 ];
 
 	it = itermminabs( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'if an iterated value is a non-numeric value, the computed minimum absolut
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermminabs( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermminabs( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itermminabs( rand, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itermminabs( randu(), 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itermminabs( rand, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/mprod/test/test.js b/lib/node_modules/@stdlib/stats/iter/mprod/test/test.js
index 8d9a86e6f0ae..8c495949a07d 100644
--- a/lib/node_modules/@stdlib/stats/iter/mprod/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mprod/test/test.js
@@ -107,20 +107,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 6.0, 12.0, 24.0, 24.0, 48.0 ];
 
 	it = itermprod( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'if an iterated value is a non-numeric value, the computed product is `NaN
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermprod( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermprod( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itermprod( rand, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itermprod( randu(), 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itermprod( rand, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/mrange/test/test.js b/lib/node_modules/@stdlib/stats/iter/mrange/test/test.js
index d20e101c7395..d63def63f274 100644
--- a/lib/node_modules/@stdlib/stats/iter/mrange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mrange/test/test.js
@@ -107,20 +107,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 0.0, 1.0, 1.0, 2.0, 2.0, 1.0 ];
 
 	it = itermrange( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'if an iterated value is a non-numeric value, the computed range is `NaN`
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermrange( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermrange( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itermrange( rand, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itermrange( randu(), 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itermrange( rand, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/msum/test/test.js b/lib/node_modules/@stdlib/stats/iter/msum/test/test.js
index 7d48ce638e05..3e361b264a21 100644
--- a/lib/node_modules/@stdlib/stats/iter/msum/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/msum/test/test.js
@@ -107,20 +107,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 5.0, 7.0, 9.0, 9.0, 11.0 ];
 
 	it = itermsum( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'if an iterated value is a non-numeric value, the computed sum is `NaN` fo
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermsum( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermsum( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itermsum( rand, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itermsum( randu(), 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itermsum( rand, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/msumabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/msumabs/test/test.js
index fbc724fbf908..eeabce8f4eb4 100644
--- a/lib/node_modules/@stdlib/stats/iter/msumabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/msumabs/test/test.js
@@ -107,20 +107,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 2.0, 5.0, 7.0, 9.0, 9.0, 11.0 ];
 
 	it = itermsumabs( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'if an iterated value is a non-numeric value, the computed sum is `NaN` fo
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermsumabs( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermsumabs( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itermsumabs( rand, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itermsumabs( randu(), 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itermsumabs( rand, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/msumabs2/test/test.js b/lib/node_modules/@stdlib/stats/iter/msumabs2/test/test.js
index 03be1c8faae6..683dabce3bb7 100644
--- a/lib/node_modules/@stdlib/stats/iter/msumabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/msumabs2/test/test.js
@@ -107,20 +107,20 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	expected = [ 4.0, 13.0, 17.0, 29.0, 29.0, 41.0 ];
 
 	it = itermsumabs2( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'if an iterated value is a non-numeric value, the computed sum is `NaN` fo
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
 		if ( isnan( expected[ i ] ) ) {
-			t.equal( isnan( v.value ), true, 'returns expected value for window '+i );
+			t.strictEqual( isnan( v.value ), true, 'returns expected value for window '+i );
 		} else {
-			t.equal( v.value, expected[ i ], 'returns expected value for window '+i );
+			t.strictEqual( v.value, expected[ i ], 'returns expected value for window '+i );
 		}
 	}
 	t.end();
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermsumabs2( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermsumabs2( randu(), 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = itermsumabs2( rand, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = itermsumabs2( randu(), 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = itermsumabs2( rand, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/iter/test/test.js b/lib/node_modules/@stdlib/stats/iter/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/stats/iter/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/kde2d/test/test.js b/lib/node_modules/@stdlib/stats/kde2d/test/test.js
index 3b42d0dbdf4f..ccc349cd0685 100644
--- a/lib/node_modules/@stdlib/stats/kde2d/test/test.js
+++ b/lib/node_modules/@stdlib/stats/kde2d/test/test.js
@@ -215,18 +215,18 @@ tape( 'the function computes the same values with `ndarray` and numeric array in
 
 	// Check x
 	for ( i = 0; i < n; i++ ) {
-		t.equal(actualND.x[i], actualNumeric.x[i], 'xND: '+actualND.x[i]+', xNumeric: '+actualNumeric.x[i]);
+		t.strictEqual(actualND.x[i], actualNumeric.x[i], 'xND: '+actualND.x[i]+', xNumeric: '+actualNumeric.x[i]);
 	}
 
 	// Check y
 	for ( i = 0; i < n; i++ ) {
-		t.equal(actualND.y[i], actualNumeric.y[i], 'yND: '+actualND.y[i]+', yNumeric: '+actualNumeric.y[i]);
+		t.strictEqual(actualND.y[i], actualNumeric.y[i], 'yND: '+actualND.y[i]+', yNumeric: '+actualNumeric.y[i]);
 	}
 
 	// Check z
 	for ( i = 0; i < n; i++ ) {
 		for ( j = 0; j < n; j++ ) {
-			t.equal(actualND.z.get(i, j), actualNumeric.z.get(i, j), 'zND: '+actualND.z.get(i, j)+', zNumeric: '+actualNumeric.z.get(i, j));
+			t.strictEqual(actualND.z.get(i, j), actualNumeric.z.get(i, j), 'zND: '+actualND.z.get(i, j)+', zNumeric: '+actualNumeric.z.get(i, j));
 		}
 	}
 
@@ -245,7 +245,7 @@ tape( 'the function correctly computes 2 dimensional normal KDE for a small data
 	// Check x
 	for ( i = 0; i < actual.x.length; i++ ) {
 		if ( actual.x[i] === expectedSmall.x[i] ) {
-			t.equal( actual.x[i], expectedSmall.x[i], 'x: '+actual.x[i]+', expected: '+expectedSmall.x[i] );
+			t.strictEqual( actual.x[i], expectedSmall.x[i], 'x: '+actual.x[i]+', expected: '+expectedSmall.x[i] );
 		} else {
 			delta = abs( actual.x[i] - expectedSmall.x[ i ] );
 			tol = 200.0 * EPS * abs( expectedSmall.x[ i ] );
@@ -256,7 +256,7 @@ tape( 'the function correctly computes 2 dimensional normal KDE for a small data
 	// Check y
 	for ( i = 0; i < actual.y.length; i++ ) {
 		if ( actual.y[i] === expectedSmall.y[i] ) {
-			t.equal( actual.y[i], expectedSmall.y[i], 'x: '+actual.y[i]+', expected: '+expectedSmall.y[i] );
+			t.strictEqual( actual.y[i], expectedSmall.y[i], 'x: '+actual.y[i]+', expected: '+expectedSmall.y[i] );
 		} else {
 			delta = abs( actual.y[i] - expectedSmall.y[ i ] );
 			tol = 200.0 * EPS * abs( expectedSmall.y[ i ] );
@@ -268,7 +268,7 @@ tape( 'the function correctly computes 2 dimensional normal KDE for a small data
 	for ( i = 0; i < actual.x.length; i++ ) {
 		for ( j = 0; j < actual.y.length; j++ ) {
 			if ( actual.z.get(i, j) === expectedSmall.z[i][j] ) {
-				t.equal( actual.z.get(i, j), expectedSmall.z[i][j], 'z: '+actual.z.get(i, j)+', expected: '+expectedSmall.z[i][j] );
+				t.strictEqual( actual.z.get(i, j), expectedSmall.z[i][j], 'z: '+actual.z.get(i, j)+', expected: '+expectedSmall.z[i][j] );
 			} else {
 				delta = abs( actual.z.get(i, j) - expectedSmall.z[i][j] );
 				tol = 1500.0 * EPS * abs( expectedSmall.z[i][j] );
@@ -292,7 +292,7 @@ tape( 'the function correctly computes 2 dimensional normal KDE for a medium dat
 	// Check x
 	for ( i = 0; i < actual.x.length; i++ ) {
 		if ( actual.x[i] === expected.x[i] ) {
-			t.equal( actual.x[i], expected.x[i], 'x: '+actual.x[i]+', expected: '+expected.x[i] );
+			t.strictEqual( actual.x[i], expected.x[i], 'x: '+actual.x[i]+', expected: '+expected.x[i] );
 		} else {
 			delta = abs( actual.x[i] - expected.x[ i ] );
 			tol = 500.0 * EPS * abs( expected.x[ i ] );
@@ -303,7 +303,7 @@ tape( 'the function correctly computes 2 dimensional normal KDE for a medium dat
 	// Check y
 	for ( i = 0; i < actual.y.length; i++ ) {
 		if ( actual.y[i] === expected.y[i] ) {
-			t.equal( actual.y[i], expected.y[i], 'x: '+actual.y[i]+', expected: '+expected.y[i] );
+			t.strictEqual( actual.y[i], expected.y[i], 'x: '+actual.y[i]+', expected: '+expected.y[i] );
 		} else {
 			delta = abs( actual.y[i] - expected.y[ i ] );
 			tol = 200.0 * EPS * abs( expected.y[ i ] );
@@ -315,7 +315,7 @@ tape( 'the function correctly computes 2 dimensional normal KDE for a medium dat
 	for ( i = 0; i < actual.x.length; i++ ) {
 		for ( j = 0; j < actual.y.length; j++ ) {
 			if ( actual.z.get(i, j) === expected.z[i][j] ) {
-				t.equal( actual.z.get(i, j), expected.z[i][j], 'z: '+actual.z.get(i, j)+', expected: '+expected.z[i][j] );
+				t.strictEqual( actual.z.get(i, j), expected.z[i][j], 'z: '+actual.z.get(i, j)+', expected: '+expected.z[i][j] );
 			} else {
 				delta = abs( actual.z.get(i, j) - expected.z[i][j] );
 				tol = 2000.0 * EPS * abs( expected.z[i][j] );
@@ -339,7 +339,7 @@ tape( 'the function correctly computes 2 dimensional normal KDE for a large data
 	// Check x
 	for ( i = 0; i < actual.x.length; i++ ) {
 		if ( actual.x[i] === expected2.x[i] ) {
-			t.equal( actual.x[i], expected2.x[i], 'x: '+actual.x[i]+', expected2: '+expected2.x[i] );
+			t.strictEqual( actual.x[i], expected2.x[i], 'x: '+actual.x[i]+', expected2: '+expected2.x[i] );
 		} else {
 			delta = abs( actual.x[i] - expected2.x[ i ] );
 			tol = 250.0 * EPS * abs( expected2.x[ i ] );
@@ -350,7 +350,7 @@ tape( 'the function correctly computes 2 dimensional normal KDE for a large data
 	// Check y
 	for ( i = 0; i < actual.y.length; i++ ) {
 		if ( actual.y[i] === expected2.y[i] ) {
-			t.equal( actual.y[i], expected2.y[i], 'x: '+actual.y[i]+', expected2: '+expected2.y[i] );
+			t.strictEqual( actual.y[i], expected2.y[i], 'x: '+actual.y[i]+', expected2: '+expected2.y[i] );
 		} else {
 			delta = abs( actual.y[i] - expected2.y[ i ] );
 			tol = 500.0 * EPS * abs( expected2.y[ i ] );
@@ -362,7 +362,7 @@ tape( 'the function correctly computes 2 dimensional normal KDE for a large data
 	for ( i = 0; i < actual.x.length; i++ ) {
 		for ( j = 0; j < actual.y.length; j++ ) {
 			if ( actual.z.get(i, j) === expected2.z[i][j] ) {
-				t.equal( actual.z.get(i, j), expected2.z[i][j], 'z: '+actual.z.get(i, j)+', expected2: '+expected2.z[i][j] );
+				t.strictEqual( actual.z.get(i, j), expected2.z[i][j], 'z: '+actual.z.get(i, j)+', expected2: '+expected2.z[i][j] );
 			} else {
 				delta = abs( actual.z.get(i, j) - expected2.z[i][j] );
 				tol = 2000.0 * EPS * abs( expected2.z[i][j] );
diff --git a/lib/node_modules/@stdlib/stats/kde2d/test/test.validate.js b/lib/node_modules/@stdlib/stats/kde2d/test/test.validate.js
index a497618447c8..85f6327af076 100644
--- a/lib/node_modules/@stdlib/stats/kde2d/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/kde2d/test/test.validate.js
@@ -55,7 +55,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns a type error if provided an `h` option which is not
 		err = validate( {}, {
 			'h': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -111,7 +111,7 @@ tape( 'the function returns a type error if provided an `h` option that is a pos
 		err = validate( {}, {
 			'h': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -150,7 +150,7 @@ tape( 'the function returns a type error if provided an `n` option which is not
 		err = validate( {}, {
 			'n': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -186,7 +186,7 @@ tape( 'the function returns a type error if provided an `xMax` option that is no
 		err = validate( {}, {
 			'xMax': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -222,7 +222,7 @@ tape( 'the function returns a type error if provided an `xMin` option that is no
 		err = validate( {}, {
 			'xMin': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -258,7 +258,7 @@ tape( 'the function returns a type error if provided a `yMax` option that is not
 		err = validate( {}, {
 			'yMax': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -294,7 +294,7 @@ tape( 'the function returns a type error if provided a `yMin` option that is not
 		err = validate( {}, {
 			'yMin': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -317,7 +317,7 @@ tape( 'the function returns a type error if provided a `kernel` option that does
 		err = validate( {}, {
 			'kernel': values[i]
 		});
-		t.equal( err instanceof Error, true, 'returns a Error when provided '+values[i] );
+		t.strictEqual( err instanceof Error, true, 'returns a Error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -338,7 +338,7 @@ tape( 'the function returns a type error if provided a `kernel` option that is n
 		err = validate( {}, {
 			'kernel': values[i]
 		});
-		t.equal( err instanceof Error, true, 'returns a Error when provided '+values[i] );
+		t.strictEqual( err instanceof Error, true, 'returns a Error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -372,7 +372,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -395,7 +395,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/kruskal-test/test/test.js b/lib/node_modules/@stdlib/stats/kruskal-test/test/test.js
index 2381a63e3055..c95c479f78de 100644
--- a/lib/node_modules/@stdlib/stats/kruskal-test/test/test.js
+++ b/lib/node_modules/@stdlib/stats/kruskal-test/test/test.js
@@ -219,13 +219,13 @@ tape( 'the function returns an object with a `.print()` method for printing a fo
 
 	out = kruskalTest( x, y, z );
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 
 	out = kruskalTest( x, y, z, {
 		'alpha': 0.01
 	});
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -242,7 +242,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'digits': 6
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -258,8 +258,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'decision': false
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -274,7 +274,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	out = kruskalTest( x, y, z );
 	table = out.print( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/kruskal-test/test/test.validate.js b/lib/node_modules/@stdlib/stats/kruskal-test/test/test.validate.js
index f202e380474d..fe14730a1a64 100644
--- a/lib/node_modules/@stdlib/stats/kruskal-test/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/kruskal-test/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns a type error if provided a `groups` option which is
 		err = validate( {}, {
 			'groups': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -145,7 +145,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/kstest/test/test.get_cdf.js b/lib/node_modules/@stdlib/stats/kstest/test/test.get_cdf.js
index c3c640937ec8..5de7691c5b1b 100644
--- a/lib/node_modules/@stdlib/stats/kstest/test/test.get_cdf.js
+++ b/lib/node_modules/@stdlib/stats/kstest/test/test.get_cdf.js
@@ -58,31 +58,31 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns the correct CDF if provided a valid input string', function test( t ) {
-	t.equal( getCDF( 'arcsine' ), arcsineCDF );
-	t.equal( getCDF( 'beta' ), betaCDF );
-	t.equal( getCDF( 'betaprime' ), betaprimeCDF );
-	t.equal( getCDF( 'cauchy' ), cauchyCDF );
-	t.equal( getCDF( 'chi' ), chiCDF );
-	t.equal( getCDF( 'chisquare' ), chisquareCDF );
-	t.equal( getCDF( 'cosine' ), cosineCDF );
-	t.equal( getCDF( 'erlang' ), erlangCDF );
-	t.equal( getCDF( 'exponential' ), exponentialCDF );
-	t.equal( getCDF( 'f' ), fCDF );
-	t.equal( getCDF( 'frechet' ), frechetCDF );
-	t.equal( getCDF( 'gamma' ), gammaCDF );
-	t.equal( getCDF( 'gumbel' ), gumbelCDF );
-	t.equal( getCDF( 'invgamma' ), invgammaCDF );
-	t.equal( getCDF( 'kumaraswamy' ), kumaraswamyCDF );
-	t.equal( getCDF( 'laplace' ), laplaceCDF );
-	t.equal( getCDF( 'logistic' ), logisticCDF );
-	t.equal( getCDF( 'lognormal' ), lognormalCDF );
-	t.equal( getCDF( 'normal' ), normalCDF );
-	t.equal( getCDF( 'pareto-type1' ), paretoCDF );
-	t.equal( getCDF( 'rayleigh' ), rayleighCDF );
-	t.equal( getCDF( 't' ), tCDF );
-	t.equal( getCDF( 'triangular' ), triangularCDF );
-	t.equal( getCDF( 'uniform' ), uniformCDF );
-	t.equal( getCDF( 'weibull' ), weibullCDF );
+	t.strictEqual( getCDF( 'arcsine' ), arcsineCDF );
+	t.strictEqual( getCDF( 'beta' ), betaCDF );
+	t.strictEqual( getCDF( 'betaprime' ), betaprimeCDF );
+	t.strictEqual( getCDF( 'cauchy' ), cauchyCDF );
+	t.strictEqual( getCDF( 'chi' ), chiCDF );
+	t.strictEqual( getCDF( 'chisquare' ), chisquareCDF );
+	t.strictEqual( getCDF( 'cosine' ), cosineCDF );
+	t.strictEqual( getCDF( 'erlang' ), erlangCDF );
+	t.strictEqual( getCDF( 'exponential' ), exponentialCDF );
+	t.strictEqual( getCDF( 'f' ), fCDF );
+	t.strictEqual( getCDF( 'frechet' ), frechetCDF );
+	t.strictEqual( getCDF( 'gamma' ), gammaCDF );
+	t.strictEqual( getCDF( 'gumbel' ), gumbelCDF );
+	t.strictEqual( getCDF( 'invgamma' ), invgammaCDF );
+	t.strictEqual( getCDF( 'kumaraswamy' ), kumaraswamyCDF );
+	t.strictEqual( getCDF( 'laplace' ), laplaceCDF );
+	t.strictEqual( getCDF( 'logistic' ), logisticCDF );
+	t.strictEqual( getCDF( 'lognormal' ), lognormalCDF );
+	t.strictEqual( getCDF( 'normal' ), normalCDF );
+	t.strictEqual( getCDF( 'pareto-type1' ), paretoCDF );
+	t.strictEqual( getCDF( 'rayleigh' ), rayleighCDF );
+	t.strictEqual( getCDF( 't' ), tCDF );
+	t.strictEqual( getCDF( 'triangular' ), triangularCDF );
+	t.strictEqual( getCDF( 'uniform' ), uniformCDF );
+	t.strictEqual( getCDF( 'weibull' ), weibullCDF );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/kstest/test/test.js b/lib/node_modules/@stdlib/stats/kstest/test/test.js
index 090221698661..a2121616c94c 100644
--- a/lib/node_modules/@stdlib/stats/kstest/test/test.js
+++ b/lib/node_modules/@stdlib/stats/kstest/test/test.js
@@ -27,6 +27,7 @@ var uniformCDF = require( '@stdlib/stats/base/dists/uniform/cdf' );
 var abs = require( '@stdlib/math/base/special/abs' );
 var Float64Array = require( '@stdlib/array/float64' );
 var EPS = require( '@stdlib/constants/float64/eps' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var kstest = require( './../lib' );
 
 
@@ -324,7 +325,7 @@ tape( 'the `.print()` method allows printing a formatted output table', function
 
 		Test Decision: Fail to reject null in favor of alternative at 5% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 	t.end();
 });
 
@@ -339,7 +340,7 @@ tape( 'the `.print()` method allows printing a formatted output table for a one-
 		'seed': 338
 	});
 
-	x = new Array( 100 );
+	x = zeros( 100 );
 	for ( i = 0; i < x.length; i++ ) {
 		x[ i ] = runif();
 	}
@@ -373,7 +374,7 @@ tape( 'the `.print()` method allows printing a formatted output table for a one-
 		Test Decision: Reject null in favor of alternative at 5% significance level
 	*/
 
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 	t.end();
 });
 
@@ -395,7 +396,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 
 		Test Decision: Fail to reject null in favor of alternative at 5% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -416,8 +417,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 			statistic: 0.25
 
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -428,7 +429,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	out = kstest( [ 0.25, 0.5, 0.75 ], 'uniform', 0.0, 1.0 );
 	table = out.print( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/kstest/test/test.validate.js b/lib/node_modules/@stdlib/stats/kstest/test/test.validate.js
index c52257aaafb8..6df21ce1cf0f 100644
--- a/lib/node_modules/@stdlib/stats/kstest/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/kstest/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns a type error if provided an `alternative` option whi
 		err = validate( {}, {
 			'alternative': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns a type error if provided a `sorted` option which is
 		err = validate( {}, {
 			'sorted': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -151,7 +151,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -172,7 +172,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/levene-test/test/test.js b/lib/node_modules/@stdlib/stats/levene-test/test/test.js
index aae952c7d8a3..3bc2383126c3 100644
--- a/lib/node_modules/@stdlib/stats/levene-test/test/test.js
+++ b/lib/node_modules/@stdlib/stats/levene-test/test/test.js
@@ -194,13 +194,13 @@ tape( 'the function returns an object with a `.print()` method for printing a fo
 
 	out = leveneTest( x, y, z );
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 
 	out = leveneTest( x, y, z, {
 		'alpha': 0.01
 	});
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns a string' );
 
 	t.end();
 });
@@ -217,7 +217,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'digits': 6
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -233,8 +233,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'decision': false
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -249,7 +249,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	out = leveneTest( x, y, z );
 	table = out.print( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/levene-test/test/test.validate.js b/lib/node_modules/@stdlib/stats/levene-test/test/test.validate.js
index d78cb1a86a49..166b2f7bd9c9 100644
--- a/lib/node_modules/@stdlib/stats/levene-test/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/levene-test/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns a type error if provided a `groups` option which is
 		err = validate( {}, {
 			'groups': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -145,7 +145,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/lowess/test/test.validate.js b/lib/node_modules/@stdlib/stats/lowess/test/test.validate.js
index 65f1a9c624d3..216d6180257d 100644
--- a/lib/node_modules/@stdlib/stats/lowess/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/lowess/test/test.validate.js
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -78,7 +78,7 @@ tape( 'the function returns an error if provided an `f` option which is not a po
 		err = validate( {}, {
 			'f': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function returns an error if provided an `nsteps` option which is not
 		err = validate( {}, {
 			'nsteps': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'the function returns an error if provided a `delta` option which is not a
 		err = validate( {}, {
 			'delta': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the function returns an error if provided a `sorted` option which is not
 		err = validate( {}, {
 			'sorted': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -176,7 +176,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -195,7 +195,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/padjust/test/test.js b/lib/node_modules/@stdlib/stats/padjust/test/test.js
index ab8462791fb0..c0466365a0e3 100644
--- a/lib/node_modules/@stdlib/stats/padjust/test/test.js
+++ b/lib/node_modules/@stdlib/stats/padjust/test/test.js
@@ -208,7 +208,7 @@ tape( 'the function returns adjusted p-values (using Bonferroni correction)', fu
 	out = padjust( pvals, 'bonferroni' );
 	for ( i = 0; i < pvals.length; i++ ) {
 		if ( out[ i ] === expected[ i ] ) {
-			t.equal( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
+			t.strictEqual( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
 		} else {
 			delta = abs( out[ i ] - expected[i] );
 			tol = 15.0 * EPS * abs( expected[i] );
@@ -231,7 +231,7 @@ tape( 'the function returns adjusted p-values (using Benjamini & Yekutieli corre
 	out = padjust( pvals, 'by' );
 	for ( i = 0; i < pvals.length; i++ ) {
 		if ( out[ i ] === expected[ i ] ) {
-			t.equal( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
+			t.strictEqual( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
 		} else {
 			delta = abs( out[ i ] - expected[i] );
 			tol = 20.0 * EPS * abs( expected[i] );
@@ -254,7 +254,7 @@ tape( 'the function returns adjusted p-values (using False Discovery Rate contro
 	out = padjust( pvals, 'bh' );
 	for ( i = 0; i < pvals.length; i++ ) {
 		if ( out[ i ] === expected[ i ] ) {
-			t.equal( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
+			t.strictEqual( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
 		} else {
 			delta = abs( out[ i ] - expected[i] );
 			tol = 20.0 * EPS * abs( expected[i] );
@@ -277,7 +277,7 @@ tape( 'the function returns adjusted p-values (using Holm\'s correction)', funct
 	out = padjust( pvals, 'holm' );
 	for ( i = 0; i < pvals.length; i++ ) {
 		if ( out[ i ] === expected[ i ] ) {
-			t.equal( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
+			t.strictEqual( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
 		} else {
 			delta = abs( out[ i ] - expected[i] );
 			tol = 20.0 * EPS * abs( expected[i] );
@@ -300,7 +300,7 @@ tape( 'the function returns adjusted p-values (using Hommel\'s method)', functio
 	out = padjust( pvals, 'hommel' );
 	for ( i = 0; i < pvals.length; i++ ) {
 		if ( out[ i ] === expected[ i ] ) {
-			t.equal( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
+			t.strictEqual( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
 		} else {
 			delta = abs( out[ i ] - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
@@ -323,7 +323,7 @@ tape( 'the function returns adjusted p-values (custom number of comparisons)', f
 	out = padjust( pvals, 'bh', CUSTOM.n );
 	for ( i = 0; i < pvals.length; i++ ) {
 		if ( out[ i ] === expected[ i ] ) {
-			t.equal( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
+			t.strictEqual( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
 		} else {
 			delta = abs( out[ i ] - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
@@ -346,7 +346,7 @@ tape( 'the function returns adjusted p-values using Hommel\'s method (custom num
 	out = padjust( pvals, 'hommel', CUSTOM_HOMMEL.n );
 	for ( i = 0; i < pvals.length; i++ ) {
 		if ( out[ i ] === expected[ i ] ) {
-			t.equal( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
+			t.strictEqual( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
 		} else {
 			delta = abs( out[ i ] - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
@@ -369,7 +369,7 @@ tape( 'the function returns adjusted p-values using the Benjamini & Yekutieli co
 	out = padjust( pvals, 'by', CUSTOM_BY.n );
 	for ( i = 0; i < pvals.length; i++ ) {
 		if ( out[ i ] === expected[ i ] ) {
-			t.equal( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
+			t.strictEqual( out[ i ], expected[ i ], 'p: '+pvals[i]+'. adj: '+out[ i ]+'. E: '+expected[i]+'.' );
 		} else {
 			delta = abs( out[ i ] - expected[i] );
 			tol = 10.0 * EPS * abs( expected[i] );
diff --git a/lib/node_modules/@stdlib/stats/pcorrtest/test/test.js b/lib/node_modules/@stdlib/stats/pcorrtest/test/test.js
index fca5d9a3f642..6946282330b2 100644
--- a/lib/node_modules/@stdlib/stats/pcorrtest/test/test.js
+++ b/lib/node_modules/@stdlib/stats/pcorrtest/test/test.js
@@ -328,7 +328,7 @@ tape( 'the function returns an object with a `.print()` method', function test(
 	y = [ 2, 3, 2, 1, 2 ];
 	out = pcorrtest( x, y );
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -346,7 +346,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'digits': 6
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = pcorrtest( x, y, {
 		'alternative': 'less'
@@ -354,7 +354,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'digits': 6
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = pcorrtest( x, y, {
 		'alternative': 'greater'
@@ -362,7 +362,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'digits': 6
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	t.end();
 });
@@ -381,8 +381,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'decision': false
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 
 	out = pcorrtest( x, y, {
 		'alternative': 'less'
@@ -390,8 +390,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'decision': false
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 
 	out = pcorrtest( x, y, {
 		'alternative': 'greater'
@@ -399,8 +399,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'decision': false
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 
 	t.end();
 });
@@ -415,7 +415,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	y = [ 2, 3, 2, 1, 2 ];
 	out = pcorrtest( x, y );
 	table = out.print( {} );
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/pcorrtest/test/test.validate.js b/lib/node_modules/@stdlib/stats/pcorrtest/test/test.validate.js
index 80dea899ea32..99701de0b507 100644
--- a/lib/node_modules/@stdlib/stats/pcorrtest/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/pcorrtest/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -101,7 +101,7 @@ tape( 'the function returns a type error if provided an `alternative` option whi
 		err = validate( {}, {
 			'alternative': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -126,7 +126,7 @@ tape( 'the function returns a type error if provided a `rho` option which is not
 		err = validate( {}, {
 			'rho': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -173,7 +173,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/ranks/test/test.validate.js b/lib/node_modules/@stdlib/stats/ranks/test/test.validate.js
index 5d0a00b9f816..8748d5596cc1 100644
--- a/lib/node_modules/@stdlib/stats/ranks/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/ranks/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns a type error if provided a `missing` option which is
 		err = validate( {}, {
 			'missing': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns a type error if provided an `method` option which is
 		err = validate( {}, {
 			'method': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -149,7 +149,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/strided/test/test.js b/lib/node_modules/@stdlib/stats/strided/test/test.js
index d1e6eeb4039e..30bee535777f 100644
--- a/lib/node_modules/@stdlib/stats/strided/test/test.js
+++ b/lib/node_modules/@stdlib/stats/strided/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'returns expected value' );
+	t.strictEqual( keys.length > 0, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/test/test.js b/lib/node_modules/@stdlib/stats/test/test.js
index a261db95f34a..df360f20efc5 100644
--- a/lib/node_modules/@stdlib/stats/test/test.js
+++ b/lib/node_modules/@stdlib/stats/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains statistical functions', function test( t ) {
 	var keys = objectKeys( stats );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/ttest/test/test.js b/lib/node_modules/@stdlib/stats/ttest/test/test.js
index 1a4b58ba6c79..cafdad77cdc9 100644
--- a/lib/node_modules/@stdlib/stats/ttest/test/test.js
+++ b/lib/node_modules/@stdlib/stats/ttest/test/test.js
@@ -479,7 +479,7 @@ tape( 'the function returns an object with a `.print()` method for generating a
 
 		Test Decision: Reject null in favor of alternative at 5% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = ttest( x, {
 		'alternative': 'less'
@@ -497,7 +497,7 @@ tape( 'the function returns an object with a `.print()` method for generating a
 
 		Test Decision: Fail to reject null in favor of alternative at 5% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = ttest( x, {
 		'alternative': 'greater',
@@ -516,7 +516,7 @@ tape( 'the function returns an object with a `.print()` method for generating a
 
 		Test Decision: Fail to reject null in favor of alternative at 5% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -542,7 +542,7 @@ tape( 'the function returns an object with a `.print()` method for generating a
 
 		Test Decision: Fail to reject null in favor of alternative at 5% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -568,7 +568,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 
 		Test Decision: Reject null in favor of alternative at 5% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -593,8 +593,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 			95% confidence interval: [0.0368,3.9632]
 
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -607,7 +607,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	out = ttest( x );
 	table = out.print( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/ttest/test/test.validate.js b/lib/node_modules/@stdlib/stats/ttest/test/test.validate.js
index 3ad46177bd97..4ee0603dc1b6 100644
--- a/lib/node_modules/@stdlib/stats/ttest/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/ttest/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns an error if not provided an options object', functio
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns an error if provided an `alpha` option which is not
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function returns an error if provided an `alpha` option which is not
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof RangeError, true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( err instanceof RangeError, true, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function returns an error if provided an `alternative` option which i
 		err = validate( {}, {
 			'alternative': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the function returns an error if provided an unrecognized/unsupported `al
 		err = validate( {}, {
 			'alternative': values[i]
 		});
-		t.equal( err instanceof Error, true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( err instanceof Error, true, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
@@ -166,7 +166,7 @@ tape( 'the function returns an error if provided a `mu` option which is not a nu
 		err = validate( {}, {
 			'mu': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
@@ -192,7 +192,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'sets option values' );
 
 	t.end();
@@ -213,7 +213,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/ttest2/test/test.js b/lib/node_modules/@stdlib/stats/ttest2/test/test.js
index 74532c681d84..cb937db7db48 100644
--- a/lib/node_modules/@stdlib/stats/ttest2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/ttest2/test/test.js
@@ -267,8 +267,8 @@ tape( 'the function performs a two-sample t-test assuming the true difference in
 	});
 
 	// Tested against R:
-	t.equal( out.pValue, diff.pValue, 'returns correct p-value' );
-	t.equal( out.statistic, diff.statistic, 'returns correct test statistic' );
+	t.strictEqual( out.pValue, diff.pValue, 'returns correct p-value' );
+	t.strictEqual( out.statistic, diff.statistic, 'returns correct test statistic' );
 
 	expected = diff.lower;
 	delta = abs( out.ci[0] - expected );
@@ -308,7 +308,7 @@ tape( 'the function performs a one-sided Welch two-sample t-test assuming unequa
 	tol = 2.0 * EPS * abs( expected );
 	t.ok( delta <= tol, 'within tolerance. direction: less. a: ['+a+']. b: ['+b+']. statistic: '+out.statistic+'. E: '+expected+'. Δ: '+delta+'. tol: '+tol );
 
-	t.equal( out.ci[0], NINF, 'returns -Infinity as lower bound of CI' );
+	t.strictEqual( out.ci[0], NINF, 'returns -Infinity as lower bound of CI' );
 
 	expected = less.upper;
 	delta = abs( out.ci[1] - expected );
@@ -335,7 +335,7 @@ tape( 'the function performs a one-sided Welch two-sample t-test assuming unequa
 	tol = 7.0 * EPS * abs( expected );
 	t.ok( delta <= tol, 'within tolerance. direction: greater. a: ['+a+']. b: ['+b+']. lower CI: '+out.ci[0]+'. E: '+expected+'. Δ: '+delta+'. tol: '+tol );
 
-	t.equal( out.ci[1], PINF, 'returns Infinity as upper bound of CI' );
+	t.strictEqual( out.ci[1], PINF, 'returns Infinity as upper bound of CI' );
 
 	t.end();
 });
@@ -361,7 +361,7 @@ tape( 'the function returns an object with a `.print()` method for generating a
 
 		Test Decision: Fail to reject null in favor of alternative at 5% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = ttest2( x, y, {
 		'alternative': 'less'
@@ -378,7 +378,7 @@ tape( 'the function returns an object with a `.print()` method for generating a
 
 		Test Decision: Fail to reject null in favor of alternative at 5% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = ttest2( x, y, {
 		'alternative': 'greater'
@@ -395,7 +395,7 @@ tape( 'the function returns an object with a `.print()` method for generating a
 
 		Test Decision: Fail to reject null in favor of alternative at 5% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -422,7 +422,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 
 		Test Decision: Reject null in favor of alternative at 5% significance level
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -448,8 +448,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 			95% confidence interval: [0.1097,3.9903]
 
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -464,7 +464,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	out = ttest2( x, y );
 	table = out.print( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/ttest2/test/test.validate.js b/lib/node_modules/@stdlib/stats/ttest2/test/test.validate.js
index 31e3bb2f10a6..3bd2bd9bc414 100644
--- a/lib/node_modules/@stdlib/stats/ttest2/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/ttest2/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns a type error if provided an `alternative` option whi
 		err = validate( {}, {
 			'alternative': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns a type error if provided a `difference` option which
 		err = validate( {}, {
 			'difference': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -150,7 +150,7 @@ tape( 'the function returns a type error if provided a `variance` option which i
 		err = validate( {}, {
 			'variance': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -178,7 +178,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -199,7 +199,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/vartest/test/test.js b/lib/node_modules/@stdlib/stats/vartest/test/test.js
index 0794f2ed8022..c2fb0c7d2cfc 100644
--- a/lib/node_modules/@stdlib/stats/vartest/test/test.js
+++ b/lib/node_modules/@stdlib/stats/vartest/test/test.js
@@ -204,7 +204,7 @@ tape( 'the function performs a two-sample F-test assuming the true ratio of the
 	});
 
 	// Tested against R:
-	t.equal( out.pValue, diff.pValue, 'returns correct p-value' );
+	t.strictEqual( out.pValue, diff.pValue, 'returns correct p-value' );
 
 	expected = diff.statistic;
 	delta = abs( out.statistic - expected );
@@ -249,7 +249,7 @@ tape( 'the function performs a one-sided two-sample F-test', function test( t )
 	tol = 1.0 * EPS * abs( expected );
 	t.ok( delta <= tol, 'within tolerance. direction: less. a: ['+a+']. b: ['+b+']. statistic: '+out.statistic+'. E: '+expected+'. Δ: '+delta+'. tol: '+tol );
 
-	t.equal( out.ci[0], 0.0, 'returns 0 as lower bound of CI' );
+	t.strictEqual( out.ci[0], 0.0, 'returns 0 as lower bound of CI' );
 
 	expected = less.upper;
 	delta = abs( out.ci[1] - expected );
@@ -276,7 +276,7 @@ tape( 'the function performs a one-sided two-sample F-test', function test( t )
 	tol = 1.0 * EPS * abs( expected );
 	t.ok( delta <= tol, 'within tolerance. direction: greater. a: ['+a+']. b: ['+b+']. lower CI: '+out.ci[0]+'. E: '+expected+'. Δ: '+delta+'. tol: '+tol );
 
-	t.equal( out.ci[1], PINF, 'returns Infinity as upper bound of CI' );
+	t.strictEqual( out.ci[1], PINF, 'returns Infinity as upper bound of CI' );
 
 	t.end();
 });
@@ -306,7 +306,7 @@ tape( 'the function returns an object with a `.print()` method for generating a
 
 		Exited with status 0
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = vartest( x, y, {
 		'alternative': 'less'
@@ -325,7 +325,7 @@ tape( 'the function returns an object with a `.print()` method for generating a
 
 		Exited with status 0
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = vartest( x, y, {
 		'alternative': 'greater'
@@ -344,7 +344,7 @@ tape( 'the function returns an object with a `.print()` method for generating a
 
 		Exited with status 0
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -374,7 +374,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 		Test Decision: Reject null in favor of alternative at 5% significance level
 	*/
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -401,8 +401,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 			variance of y: 312.5 (df of y: 7)
 			95% confidence interval: [1.8962,38.3853]
 	*/
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -417,7 +417,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	out = vartest( x, y );
 	table = out.print( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/vartest/test/test.validate.js b/lib/node_modules/@stdlib/stats/vartest/test/test.validate.js
index bb55b67c03f9..d2b75d89f7bc 100644
--- a/lib/node_modules/@stdlib/stats/vartest/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/vartest/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns a type error if provided an `alternative` option whi
 		err = validate( {}, {
 			'alternative': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function returns a type error if provided a `ratio` option which is n
 		err = validate( {}, {
 			'ratio': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -153,7 +153,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/wilcoxon/test/test.js b/lib/node_modules/@stdlib/stats/wilcoxon/test/test.js
index 7b32db6039e0..db61fb2698c0 100644
--- a/lib/node_modules/@stdlib/stats/wilcoxon/test/test.js
+++ b/lib/node_modules/@stdlib/stats/wilcoxon/test/test.js
@@ -527,20 +527,20 @@ tape( 'the function returns an object with a `.print()` method for generating a
 	x = [ 0, 1, 2, 3, 4 ];
 	out = wilcoxon( x );
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = wilcoxon( x, {
 		'alternative': 'less'
 	});
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = wilcoxon( x, {
 		'alternative': 'greater',
 		'mu': 10
 	});
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -556,7 +556,7 @@ tape( 'the function returns an object with a `.print()` method for generating a
 		'alpha': 0.01
 	});
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -570,7 +570,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'digits': 6
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -584,8 +584,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'decision': false
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -598,7 +598,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	out = wilcoxon( x );
 	table = out.print( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/wilcoxon/test/test.validate.js b/lib/node_modules/@stdlib/stats/wilcoxon/test/test.validate.js
index 5471c9f2996d..2231b487377a 100644
--- a/lib/node_modules/@stdlib/stats/wilcoxon/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/wilcoxon/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns a type error if provided an `alternative` option whi
 		err = validate( {}, {
 			'alternative': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns a type error if provided an `zeroMethod` option whic
 		err = validate( {}, {
 			'zeroMethod': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -150,7 +150,7 @@ tape( 'the function returns a type error if provided a `mu` option which is not
 		err = validate( {}, {
 			'mu': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -175,7 +175,7 @@ tape( 'the function returns a type error if provided a `correction` option which
 		err = validate( {}, {
 			'correction': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -200,7 +200,7 @@ tape( 'the function returns a type error if provided an `exact` option which is
 		err = validate( {}, {
 			'exact': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -232,7 +232,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -253,7 +253,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/ztest/test/test.js b/lib/node_modules/@stdlib/stats/ztest/test/test.js
index 05b796e5f338..91a5a1071b30 100644
--- a/lib/node_modules/@stdlib/stats/ztest/test/test.js
+++ b/lib/node_modules/@stdlib/stats/ztest/test/test.js
@@ -26,6 +26,7 @@ var contains = require( '@stdlib/assert/contains' );
 var isArray = require( '@stdlib/assert/is-array' );
 var NINF = require( '@stdlib/constants/float64/ninf' );
 var PINF = require( '@stdlib/constants/float64/pinf' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var ztest = require( './../lib' );
 
 
@@ -178,7 +179,7 @@ tape( 'the function computes a one-sample two-sided z-test', function test( t )
 		'seed': 338
 	});
 
-	x = new Array( 100 );
+	x = zeros( 100 );
 	for ( i = 0; i < x.length; i++ ) {
 		x[ i ] = rnorm( 0.0, 1.0 );
 	}
@@ -204,7 +205,7 @@ tape( 'the function computes a one-sample one-sided z-test', function test( t )
 		'seed': 338
 	});
 
-	x = new Array( 100 );
+	x = zeros( 100 );
 	for ( i = 0; i < x.length; i++ ) {
 		x[ i ] = rnorm( 0.0, 1.0 );
 	}
@@ -244,7 +245,7 @@ tape( 'the function computes a one-sample two-sided z-test with a custom signifi
 		'seed': 383
 	});
 
-	x = new Array( 100 );
+	x = zeros( 100 );
 	for ( i = 0; i < x.length; i++ ) {
 		x[ i ] = rnorm( 0.0, 1.0 );
 	}
@@ -273,7 +274,7 @@ tape( 'the function correctly computes a one-sample one-sided z-test with a cust
 		'seed': 338
 	});
 
-	x = new Array( 100 );
+	x = zeros( 100 );
 	for ( i = 0; i < x.length; i++ ) {
 		x[ i ] = rnorm( 0.0, 1.0 );
 	}
@@ -315,20 +316,20 @@ tape( 'the function returns an object with a `.print()` method for generating a
 	x = [ 0, 1, 2, 3, 4 ];
 	out = ztest( x, 2.0 );
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = ztest( x, 2.0, {
 		'alternative': 'less'
 	});
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = ztest( x, 2.0, {
 		'alternative': 'greater',
 		'mu': 2
 	});
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -342,7 +343,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'digits': 6
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -356,8 +357,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'decision': false
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -370,7 +371,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	out = ztest( x, 2.0 );
 	table = out.print( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/ztest/test/test.validate.js b/lib/node_modules/@stdlib/stats/ztest/test/test.validate.js
index 9786dc43ff32..54242153ad1e 100644
--- a/lib/node_modules/@stdlib/stats/ztest/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/ztest/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns a type error if provided an `alternative` option whi
 		err = validate( {}, {
 			'alternative': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns a type error if provided a `mu` option which is not
 		err = validate( {}, {
 			'mu': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -151,7 +151,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -172,7 +172,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/ztest2/test/test.js b/lib/node_modules/@stdlib/stats/ztest2/test/test.js
index a7a5736f593b..39761dec49a3 100644
--- a/lib/node_modules/@stdlib/stats/ztest2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/ztest2/test/test.js
@@ -26,6 +26,7 @@ var contains = require( '@stdlib/assert/contains' );
 var isArray = require( '@stdlib/assert/is-array' );
 var NINF = require( '@stdlib/constants/float64/ninf' );
 var PINF = require( '@stdlib/constants/float64/pinf' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var ztest2 = require( './../lib' );
 
 
@@ -215,8 +216,8 @@ tape( 'the function computes a two-sample two-sided z-test', function test( t )
 		'seed': 338
 	});
 
-	x = new Array( 100 );
-	y = new Array( 100 );
+	x = zeros( 100 );
+	y = zeros( 100 );
 	for ( i = 0; i < x.length; i++ ) {
 		x[ i ] = rnorm( 0.0, 1.0 );
 		y[ i ] = rnorm( 0.0, 1.0 );
@@ -245,8 +246,8 @@ tape( 'the function computes a two-sample one-sided z-test', function test( t )
 		'seed': 338
 	});
 
-	x = new Array( 100 );
-	y = new Array( 100 );
+	x = zeros( 100 );
+	y = zeros( 100 );
 	for ( i = 0; i < x.length; i++ ) {
 		x[ i ] = rnorm( 0.0, 1.0 );
 		y[ i ] = rnorm( 2.0, 1.0 );
@@ -290,8 +291,8 @@ tape( 'the function computes a two-sample two-sided z-test with a custom signifi
 		'seed': 383
 	});
 
-	x = new Array( 100 );
-	y = new Array( 100 );
+	x = zeros( 100 );
+	y = zeros( 100 );
 	for ( i = 0; i < x.length; i++ ) {
 		x[ i ] = rnorm( 0.0, 1.0 );
 		y[ i ] = rnorm( 3.0, 1.0 );
@@ -323,8 +324,8 @@ tape( 'the function correctly computes a two-sample one-sided z-test with a cust
 		'seed': 338
 	});
 
-	x = new Array( 100 );
-	y = new Array( 100 );
+	x = zeros( 100 );
+	y = zeros( 100 );
 	for ( i = 0; i < x.length; i++ ) {
 		x[ i ] = rnorm( 1.0, 1.0 );
 		y[ i ] = rnorm( 0.0, 1.0 );
@@ -371,19 +372,19 @@ tape( 'the function returns an object with a `.print()` method for generating a
 	y = [ 3, 2, 1, 5, 6, 2, 3 ];
 	out = ztest2( x, y, 1.0, 2.0 );
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = ztest2( x, y, 1.0, 2.0, {
 		'alternative': 'less'
 	});
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 
 	out = ztest2( x, y, 1.0, 2.0, {
 		'alternative': 'greater'
 	});
 	table = out.print();
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -399,7 +400,7 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'digits': 6
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
@@ -415,8 +416,8 @@ tape( 'the function returns an object with a `.print()` method that accepts a `d
 	table = out.print({
 		'decision': false
 	});
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
-	t.equal( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( contains( table, 'Test Decision' ), false, 'table does not contain test decision' );
 	t.end();
 });
 
@@ -431,7 +432,7 @@ tape( 'the function returns an object with a `.print()` method that accepts an `
 	out = ztest2( x, y, 2.0, 1.0 );
 	table = out.print( {} );
 
-	t.equal( typeof table, 'string', 'returns a pretty-printed table' );
+	t.strictEqual( typeof table, 'string', 'returns a pretty-printed table' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/ztest2/test/test.validate.js b/lib/node_modules/@stdlib/stats/ztest2/test/test.validate.js
index 7ed64ed58b1f..4a8cc38f2b65 100644
--- a/lib/node_modules/@stdlib/stats/ztest2/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/ztest2/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns a range error if provided a `alpha` option which is
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof RangeError, true, 'returns a RangeError when provided '+values[i] );
+		t.strictEqual( err instanceof RangeError, true, 'returns a RangeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function returns a type error if provided an `alternative` option whi
 		err = validate( {}, {
 			'alternative': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'the function returns a type error if provided a `difference` option which
 		err = validate( {}, {
 			'difference': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -170,7 +170,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -191,7 +191,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();

From f9651e6411b4ebd3c95dcc6b46c02e6d5be009fa Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Wed, 13 Aug 2025 22:45:02 -0500
Subject: [PATCH 07/32] test: use .strictEqual() instead of .equal() and fix
 lint errors

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/assert/contains/test/test.js      |  56 ++++----
 .../assert/is-absolute-path/test/test.js      |   8 +-
 .../is-absolute-path/test/test.posix.js       |   2 +-
 .../is-absolute-path/test/test.win32.js       |   2 +-
 .../is-accessor-property-in/test/test.js      |  42 +++---
 .../assert/is-accessor-property/test/test.js  |  36 ++---
 .../@stdlib/assert/is-array-like/test/test.js |  10 +-
 .../@stdlib/assert/is-array/test/test.js      |  11 +-
 .../test/es2015-arrow-function/index.js       |   2 +-
 .../@stdlib/assert/is-big-endian/test/test.js |   4 +-
 .../assert/is-binary-string/test/test.js      |   6 +-
 .../assert/is-blank-string/test/test.js       |   6 +-
 .../assert/is-boolean-array/test/test.js      |  20 ++-
 .../@stdlib/assert/is-boolean/test/test.js    |   4 +-
 .../assert/is-boolean/test/test.main.js       |  10 +-
 .../assert/is-boolean/test/test.object.js     |  16 +--
 .../assert/is-boolean/test/test.primitive.js  |  10 +-
 .../is-boolean/test/test.try2serialize.js     |  10 +-
 .../assert/is-boxed-primitive/test/test.js    |  14 +-
 .../assert/is-browser/test/test.browser.js    |   2 +-
 .../assert/is-browser/test/test.main.js       |   8 +-
 .../@stdlib/assert/is-buffer/test/test.js     |   6 +-
 .../is-centrosymmetric-matrix/test/test.js    |  18 +--
 .../assert/is-circular-array/test/test.js     |   6 +-
 .../is-circular-plain-object/test/test.js     |   8 +-
 .../@stdlib/assert/is-circular/test/test.js   |  18 +--
 .../assert/is-complex-like/test/test.js       |   8 +-
 .../is-complex-typed-array-like/test/test.js  |   4 +-
 .../@stdlib/assert/is-complex/test/test.js    |   6 +-
 .../@stdlib/assert/is-complex128/test/test.js |   4 +-
 .../is-complex128matrix-like/test/test.js     |   6 +-
 .../is-complex128ndarray-like/test/test.js    |   6 +-
 .../is-complex128vector-like/test/test.js     |   6 +-
 .../@stdlib/assert/is-complex64/test/test.js  |   4 +-
 .../is-complex64matrix-like/test/test.js      |   6 +-
 .../is-complex64ndarray-like/test/test.js     |   6 +-
 .../is-complex64vector-like/test/test.js      |   6 +-
 .../@stdlib/assert/is-composite/test/test.js  |   4 +-
 .../assert/is-composite/test/test.main.js     |  48 +++----
 .../assert/is-composite/test/test.object.js   |  36 ++---
 .../is-composite/test/test.primitive.js       |  30 ++--
 .../is-configurable-property-in/test/test.js  |  32 ++---
 .../is-configurable-property/test/test.js     |  28 ++--
 .../assert/is-cube-number/test/test.js        |   4 +-
 .../assert/is-cube-number/test/test.main.js   |   6 +-
 .../assert/is-cube-number/test/test.object.js |   8 +-
 .../is-cube-number/test/test.primitive.js     |   6 +-
 .../assert/is-current-year/test/test.js       |   6 +-
 .../@stdlib/assert/is-darwin/test/test.js     |   4 +-
 .../assert/is-data-property-in/test/test.js   |  30 ++--
 .../assert/is-data-property/test/test.js      |  28 ++--
 .../assert/is-docker/test/test.browser.js     |   2 +-
 .../assert/is-domain-name/test/test.js        |  16 +--
 .../assert/is-duration-string/test/test.js    |   6 +-
 .../is-electron-main/test/test.browser.js     |   2 +-
 .../is-electron-renderer/test/test.browser.js |   2 +-
 .../assert/is-electron/test/test.browser.js   |   2 +-
 .../assert/is-email-address/test/test.js      |   4 +-
 .../is-enumerable-property-in/test/test.js    |  34 ++---
 .../is-enumerable-property/test/test.js       |  40 +++---
 .../@stdlib/assert/is-even/test/test.js       |   4 +-
 .../@stdlib/assert/is-even/test/test.main.js  |   6 +-
 .../assert/is-even/test/test.object.js        |   6 +-
 .../assert/is-even/test/test.primitive.js     |   6 +-
 .../assert/is-float32matrix-like/test/test.js |   6 +-
 .../is-float32ndarray-like/test/test.js       |   6 +-
 .../assert/is-float32vector-like/test/test.js |   6 +-
 .../assert/is-float64matrix-like/test/test.js |   6 +-
 .../is-float64ndarray-like/test/test.js       |   6 +-
 .../assert/is-float64vector-like/test/test.js |   6 +-
 .../test/es2015-generator/index.js            |   4 +-
 .../is-generator-object-like/test/test.js     |   4 +-
 .../test/es2015-generator/index.js            |   4 +-
 .../assert/is-generator-object/test/test.js   |   2 +-
 .../assert/is-integer-array/test/test.js      |  22 +--
 .../@stdlib/assert/is-integer/test/test.js    |   4 +-
 .../assert/is-integer/test/test.main.js       |   6 +-
 .../assert/is-integer/test/test.object.js     |   6 +-
 .../assert/is-integer/test/test.primitive.js  |   6 +-
 .../assert/is-iterable-like/test/test.js      |   6 +-
 .../assert/is-iterator-like/test/test.js      |   6 +-
 .../@stdlib/assert/is-json/test/test.js       |   2 +-
 .../@stdlib/assert/is-kebabcase/test/test.js  |   8 +-
 .../assert/is-little-endian/test/test.js      |   4 +-
 .../assert/is-matrix-like/test/test.js        |   6 +-
 .../assert/is-mobile/test/test.browser.js     |   6 +-
 .../assert/is-multi-slice/test/test.js        |   4 +-
 .../is-named-typed-tuple-like/test/test.js    |   6 +-
 .../@stdlib/assert/is-nan-array/test/test.js  |  30 ++--
 .../@stdlib/assert/is-nan/test/test.js        |   4 +-
 .../@stdlib/assert/is-nan/test/test.main.js   |   6 +-
 .../@stdlib/assert/is-nan/test/test.object.js |  10 +-
 .../assert/is-nan/test/test.primitive.js      |  10 +-
 .../test/test.js                              |   8 +-
 .../assert/is-ndarray-like/test/test.js       |   6 +-
 .../assert/is-negative-finite/test/test.js    |   4 +-
 .../is-negative-finite/test/test.main.js      |   6 +-
 .../is-negative-finite/test/test.object.js    |   6 +-
 .../is-negative-finite/test/test.primitive.js |   6 +-
 .../is-negative-integer-array/test/test.js    |  24 ++--
 .../assert/is-negative-integer/test/test.js   |   4 +-
 .../is-negative-integer/test/test.main.js     |   8 +-
 .../is-negative-integer/test/test.object.js   |   6 +-
 .../test/test.primitive.js                    |   6 +-
 .../is-negative-number-array/test/test.js     |  24 ++--
 .../assert/is-negative-number/test/test.js    |   4 +-
 .../is-negative-number/test/test.main.js      |   6 +-
 .../is-negative-number/test/test.object.js    |  10 +-
 .../is-negative-number/test/test.primitive.js |   8 +-
 .../assert/is-node/test/test.browser.js       |   2 +-
 .../@stdlib/assert/is-node/test/test.main.js  |  26 ++--
 .../test/test.js                              |  36 ++---
 .../is-nonconfigurable-property/test/test.js  |  26 ++--
 .../is-nonenumerable-property-in/test/test.js |  36 ++---
 .../is-nonenumerable-property/test/test.js    |  26 ++--
 .../assert/is-nonnegative-finite/test/test.js |   4 +-
 .../is-nonnegative-finite/test/test.main.js   |   6 +-
 .../is-nonnegative-finite/test/test.object.js |   8 +-
 .../test/test.primitive.js                    |  10 +-
 .../is-nonnegative-integer-array/test/test.js |  24 ++--
 .../is-nonnegative-integer/test/test.js       |   4 +-
 .../is-nonnegative-integer/test/test.main.js  |   6 +-
 .../test/test.object.js                       |   6 +-
 .../test/test.primitive.js                    |   6 +-
 .../is-nonnegative-number-array/test/test.js  |  24 ++--
 .../assert/is-nonnegative-number/test/test.js |   4 +-
 .../is-nonnegative-number/test/test.main.js   |   6 +-
 .../is-nonnegative-number/test/test.object.js |   8 +-
 .../test/test.primitive.js                    |   8 +-
 .../assert/is-nonpositive-finite/test/test.js |   4 +-
 .../is-nonpositive-finite/test/test.main.js   |   6 +-
 .../is-nonpositive-finite/test/test.object.js |   6 +-
 .../test/test.primitive.js                    |   6 +-
 .../is-nonpositive-integer-array/test/test.js |  24 ++--
 .../is-nonpositive-integer/test/test.js       |   4 +-
 .../is-nonpositive-integer/test/test.main.js  |   6 +-
 .../test/test.object.js                       |   6 +-
 .../test/test.primitive.js                    |   6 +-
 .../is-nonpositive-number-array/test/test.js  |  24 ++--
 .../assert/is-nonpositive-number/test/test.js |   4 +-
 .../is-nonpositive-number/test/test.main.js   |   6 +-
 .../is-nonpositive-number/test/test.object.js |   6 +-
 .../test/test.primitive.js                    |   6 +-
 .../is-nonsymmetric-matrix/test/test.js       |  14 +-
 .../@stdlib/assert/is-null-array/test/test.js |   8 +-
 .../@stdlib/assert/is-null/test/test.js       |   4 +-
 .../assert/is-numeric-array/test/test.js      |   4 +-
 .../assert/is-object-array/test/test.js       |   8 +-
 .../assert/is-object-like/test/test.array.js  |   6 +-
 .../assert/is-object-like/test/test.js        |  24 ++--
 .../@stdlib/assert/is-object/test/test.js     |  10 +-
 .../@stdlib/assert/is-odd/test/test.js        |   4 +-
 .../@stdlib/assert/is-odd/test/test.main.js   |   6 +-
 .../@stdlib/assert/is-odd/test/test.object.js |  10 +-
 .../assert/is-odd/test/test.primitive.js      |   6 +-
 .../@stdlib/assert/is-pascalcase/test/test.js |   6 +-
 .../is-persymmetric-matrix/test/test.js       |  14 +-
 .../assert/is-plain-object/test/test.js       |  24 ++--
 .../assert/is-positive-finite/test/test.js    |   4 +-
 .../is-positive-finite/test/test.main.js      |   6 +-
 .../is-positive-finite/test/test.object.js    |   8 +-
 .../is-positive-finite/test/test.primitive.js |   8 +-
 .../is-positive-integer-array/test/test.js    |  24 ++--
 .../assert/is-positive-integer/test/test.js   |   4 +-
 .../is-positive-integer/test/test.main.js     |   6 +-
 .../is-positive-integer/test/test.object.js   |   6 +-
 .../test/test.primitive.js                    |   6 +-
 .../is-positive-number-array/test/test.js     |  24 ++--
 .../assert/is-positive-number/test/test.js    |   4 +-
 .../is-positive-number/test/test.main.js      |   6 +-
 .../is-positive-number/test/test.object.js    |   6 +-
 .../is-positive-number/test/test.primitive.js |   6 +-
 .../@stdlib/assert/is-prime/test/test.js      |   4 +-
 .../@stdlib/assert/is-prime/test/test.main.js |  22 +--
 .../assert/is-prime/test/test.object.js       |  24 ++--
 .../assert/is-prime/test/test.primitive.js    |  18 +--
 .../assert/is-primitive-array/test/test.js    |  10 +-
 .../@stdlib/assert/is-primitive/test/test.js  |  16 +--
 .../@stdlib/assert/is-prng-like/test/test.js  |   6 +-
 .../assert/is-probability-array/test/test.js  |  32 ++---
 .../assert/is-probability/test/test.js        |   4 +-
 .../assert/is-probability/test/test.main.js   |   6 +-
 .../assert/is-probability/test/test.object.js |   6 +-
 .../is-probability/test/test.primitive.js     |   6 +-
 .../is-read-only-property-in/test/test.js     |  48 +++----
 .../assert/is-read-only-property/test/test.js |  42 +++---
 .../is-read-write-property-in/test/test.js    |  34 ++---
 .../is-read-write-property/test/test.js       |  34 ++---
 .../is-readable-property-in/test/test.js      |  30 ++--
 .../assert/is-readable-property/test/test.js  |  30 ++--
 .../assert/is-regexp-string/test/test.js      |   8 +-
 .../assert/is-relative-path/test/test.js      |   8 +-
 .../is-relative-path/test/test.posix.js       |   2 +-
 .../is-relative-path/test/test.win32.js       |   2 +-
 .../assert/is-safe-integer-array/test/test.js |  42 +++---
 .../@stdlib/assert/is-semver/test/test.js     |  10 +-
 .../test/test.js                              |  18 +--
 .../is-skew-persymmetric-matrix/test/test.js  |  14 +-
 .../is-skew-symmetric-matrix/test/test.js     |  14 +-
 .../@stdlib/assert/is-slice/test/test.js      |   4 +-
 .../@stdlib/assert/is-snakecase/test/test.js  |   8 +-
 .../assert/is-square-matrix/test/test.js      |  10 +-
 .../assert/is-square-number/test/test.js      |   4 +-
 .../assert/is-square-number/test/test.main.js |   6 +-
 .../is-square-number/test/test.object.js      |   8 +-
 .../is-square-number/test/test.primitive.js   |   6 +-
 .../is-square-triangular-number/test/test.js  |   4 +-
 .../test/test.main.js                         |   6 +-
 .../test/test.object.js                       |   8 +-
 .../test/test.primitive.js                    |   6 +-
 .../@stdlib/assert/is-startcase/test/test.js  |   8 +-
 .../assert/is-string-array/test/test.js       |  12 +-
 .../@stdlib/assert/is-string/test/test.js     |   4 +-
 .../assert/is-string/test/test.main.js        |   6 +-
 .../assert/is-string/test/test.object.js      |  12 +-
 .../assert/is-string/test/test.primitive.js   |   6 +-
 .../assert/is-string/test/test.try2valueof.js |   6 +-
 .../is-struct-constructor-like/test/test.js   |   6 +-
 .../@stdlib/assert/is-struct/test/test.js     |   4 +-
 .../assert/is-symmetric-matrix/test/test.js   |  14 +-
 .../is-touch-device/test/test.browser.js      |  14 +-
 .../assert/is-triangular-number/test/test.js  |   4 +-
 .../is-triangular-number/test/test.main.js    |   6 +-
 .../is-triangular-number/test/test.object.js  |   8 +-
 .../test/test.primitive.js                    |   6 +-
 .../assert/is-typed-array-like/test/test.js   |   4 +-
 .../@stdlib/assert/is-unc-path/test/test.js   |   4 +-
 .../assert/is-undefined-or-null/test/test.js  |   4 +-
 .../@stdlib/assert/is-undefined/test/test.js  |   4 +-
 .../@stdlib/assert/is-uri/test/test.js        |   4 +-
 .../assert/is-vector-like/test/test.js        |   6 +-
 .../assert/is-web-worker/test/test.main.js    |  16 +--
 .../assert/is-well-formed-string/test/test.js |   4 +-
 .../is-well-formed-string/test/test.main.js   |   6 +-
 .../is-well-formed-string/test/test.object.js |   6 +-
 .../test/test.primitive.js                    |   6 +-
 .../@stdlib/assert/is-windows/test/test.js    |   4 +-
 .../is-writable-property-in/test/test.js      |  28 ++--
 .../assert/is-writable-property/test/test.js  |  28 ++--
 .../is-write-only-property-in/test/test.js    |  44 +++---
 .../is-write-only-property/test/test.js       |  40 +++---
 .../@stdlib/assert/tools/test/test.js         |   2 +-
 .../@stdlib/constants/array/test/test.js      |   2 +-
 .../complex128/num-bytes/test/test.js         |   2 +-
 .../@stdlib/constants/complex128/test/test.js |   2 +-
 .../complex64/num-bytes/test/test.js          |   2 +-
 .../@stdlib/constants/complex64/test/test.js  |   2 +-
 .../float16/exponent-bias/test/test.js        |   2 +-
 .../float16/max-safe-integer/test/test.js     |   2 +-
 .../constants/float16/max/test/test.js        |   2 +-
 .../float16/min-safe-integer/test/test.js     |   2 +-
 .../constants/float16/ninf/test/test.js       |   2 +-
 .../constants/float16/num-bytes/test/test.js  |   2 +-
 .../constants/float16/pinf/test/test.js       |   2 +-
 .../constants/float16/precision/test/test.js  |   2 +-
 .../float16/smallest-normal/test/test.js      |   2 +-
 .../float16/smallest-subnormal/test/test.js   |   2 +-
 .../@stdlib/constants/float16/test/test.js    |   2 +-
 .../constants/float32/apery/test/test.js      |   2 +-
 .../constants/float32/catalan/test/test.js    |   2 +-
 .../@stdlib/constants/float32/e/test/test.js  |   2 +-
 .../constants/float32/eulergamma/test/test.js |   2 +-
 .../float32/exponent-bias/test/test.js        |   2 +-
 .../constants/float32/fourth-pi/test/test.js  |   2 +-
 .../float32/fourth-root-eps/test/test.js      |   2 +-
 .../float32/half-ln-two/test/test.js          |   2 +-
 .../constants/float32/half-pi/test/test.js    |   2 +-
 .../constants/float32/ln-half/test/test.js    |   2 +-
 .../constants/float32/ln-pi/test/test.js      |   2 +-
 .../float32/ln-sqrt-two-pi/test/test.js       |   2 +-
 .../constants/float32/ln-ten/test/test.js     |   2 +-
 .../constants/float32/ln-two-pi/test/test.js  |   2 +-
 .../constants/float32/ln-two/test/test.js     |   2 +-
 .../constants/float32/log10-e/test/test.js    |   2 +-
 .../constants/float32/log2-e/test/test.js     |   2 +-
 .../test/test.js                              |   2 +-
 .../float32/max-base10-exponent/test/test.js  |   2 +-
 .../max-base2-exponent-subnormal/test/test.js |   2 +-
 .../float32/max-base2-exponent/test/test.js   |   2 +-
 .../constants/float32/max-ln/test/test.js     |   4 +-
 .../float32/max-safe-integer/test/test.js     |   2 +-
 .../constants/float32/max/test/test.js        |   2 +-
 .../test/test.js                              |   2 +-
 .../float32/min-base10-exponent/test/test.js  |   2 +-
 .../min-base2-exponent-subnormal/test/test.js |   2 +-
 .../float32/min-base2-exponent/test/test.js   |   2 +-
 .../constants/float32/min-ln/test/test.js     |   4 +-
 .../float32/min-safe-integer/test/test.js     |   2 +-
 .../constants/float32/ninf/test/test.js       |   2 +-
 .../constants/float32/num-bytes/test/test.js  |   2 +-
 .../float32/num-significand-bits/test/test.js |   2 +-
 .../constants/float32/phi/test/test.js        |   4 +-
 .../constants/float32/pi-squared/test/test.js |   2 +-
 .../@stdlib/constants/float32/pi/test/test.js |   2 +-
 .../constants/float32/pinf/test/test.js       |   2 +-
 .../constants/float32/precision/test/test.js  |   2 +-
 .../float32/smallest-normal/test/test.js      |   2 +-
 .../float32/smallest-subnormal/test/test.js   |   2 +-
 .../float32/sqrt-half-pi/test/test.js         |   2 +-
 .../constants/float32/sqrt-half/test/test.js  |   2 +-
 .../constants/float32/sqrt-phi/test/test.js   |   4 +-
 .../constants/float32/sqrt-pi/test/test.js    |   2 +-
 .../constants/float32/sqrt-three/test/test.js |   2 +-
 .../float32/sqrt-two-pi/test/test.js          |   2 +-
 .../constants/float32/sqrt-two/test/test.js   |   2 +-
 .../@stdlib/constants/float32/test/test.js    |   2 +-
 .../constants/float32/two-pi/test/test.js     |   2 +-
 .../constants/float64/apery/test/test.js      |   2 +-
 .../constants/float64/catalan/test/test.js    |   2 +-
 .../constants/float64/cbrt-eps/test/test.js   |   2 +-
 .../@stdlib/constants/float64/e/test/test.js  |   2 +-
 .../constants/float64/eps/test/test.js        |   2 +-
 .../constants/float64/eulergamma/test/test.js |   2 +-
 .../float64/exponent-bias/test/test.js        |   2 +-
 .../constants/float64/fourth-pi/test/test.js  |   2 +-
 .../float64/fourth-root-eps/test/test.js      |   2 +-
 .../float64/glaisher-kinkelin/test/test.js    |   2 +-
 .../float64/half-ln-two/test/test.js          |   2 +-
 .../constants/float64/half-pi/test/test.js    |   2 +-
 .../constants/float64/ln-half/test/test.js    |   2 +-
 .../constants/float64/ln-pi/test/test.js      |   2 +-
 .../float64/ln-sqrt-two-pi/test/test.js       |   2 +-
 .../constants/float64/ln-ten/test/test.js     |   2 +-
 .../constants/float64/ln-two-pi/test/test.js  |   2 +-
 .../constants/float64/ln-two/test/test.js     |   2 +-
 .../constants/float64/log10-e/test/test.js    |   2 +-
 .../constants/float64/log2-e/test/test.js     |   2 +-
 .../test/test.js                              |   2 +-
 .../float64/max-base10-exponent/test/test.js  |   2 +-
 .../max-base2-exponent-subnormal/test/test.js |   2 +-
 .../float64/max-base2-exponent/test/test.js   |   2 +-
 .../constants/float64/max-ln/test/test.js     |   4 +-
 .../float64/max-safe-integer/test/test.js     |   2 +-
 .../constants/float64/max/test/test.js        |   4 +-
 .../test/test.js                              |   2 +-
 .../float64/min-base10-exponent/test/test.js  |   2 +-
 .../min-base2-exponent-subnormal/test/test.js |   2 +-
 .../float64/min-base2-exponent/test/test.js   |   2 +-
 .../constants/float64/min-ln/test/test.js     |   4 +-
 .../float64/min-safe-integer/test/test.js     |   2 +-
 .../constants/float64/ninf/test/test.js       |   2 +-
 .../constants/float64/num-bytes/test/test.js  |   2 +-
 .../test/test.js                              |   2 +-
 .../constants/float64/phi/test/test.js        |   4 +-
 .../constants/float64/pi-squared/test/test.js |   2 +-
 .../@stdlib/constants/float64/pi/test/test.js |   2 +-
 .../constants/float64/pinf/test/test.js       |   2 +-
 .../constants/float64/precision/test/test.js  |   2 +-
 .../float64/smallest-normal/test/test.js      |   2 +-
 .../float64/smallest-subnormal/test/test.js   |   2 +-
 .../constants/float64/sqrt-eps/test/test.js   |   2 +-
 .../float64/sqrt-half-pi/test/test.js         |   2 +-
 .../constants/float64/sqrt-half/test/test.js  |   2 +-
 .../constants/float64/sqrt-phi/test/test.js   |   4 +-
 .../constants/float64/sqrt-pi/test/test.js    |   2 +-
 .../constants/float64/sqrt-three/test/test.js |   2 +-
 .../float64/sqrt-two-pi/test/test.js          |   2 +-
 .../constants/float64/sqrt-two/test/test.js   |   2 +-
 .../@stdlib/constants/float64/test/test.js    |   2 +-
 .../constants/float64/two-pi/test/test.js     |   2 +-
 .../@stdlib/constants/int16/max/test/test.js  |   2 +-
 .../@stdlib/constants/int16/min/test/test.js  |   2 +-
 .../constants/int16/num-bytes/test/test.js    |   2 +-
 .../@stdlib/constants/int16/test/test.js      |   2 +-
 .../@stdlib/constants/int32/max/test/test.js  |   2 +-
 .../@stdlib/constants/int32/min/test/test.js  |   2 +-
 .../constants/int32/num-bytes/test/test.js    |   2 +-
 .../@stdlib/constants/int32/test/test.js      |   2 +-
 .../@stdlib/constants/int8/max/test/test.js   |   2 +-
 .../@stdlib/constants/int8/min/test/test.js   |   2 +-
 .../constants/int8/num-bytes/test/test.js     |   2 +-
 .../@stdlib/constants/int8/test/test.js       |   2 +-
 .../path/delimiter-posix/test/test.js         |   2 +-
 .../path/delimiter-win32/test/test.js         |   2 +-
 .../constants/path/delimiter/test/test.js     |   4 +-
 .../constants/path/sep-posix/test/test.js     |   2 +-
 .../constants/path/sep-win32/test/test.js     |   2 +-
 .../@stdlib/constants/path/sep/test/test.js   |   4 +-
 .../@stdlib/constants/test/test.js            |   2 +-
 .../@stdlib/constants/uint16/max/test/test.js |   2 +-
 .../constants/uint16/num-bytes/test/test.js   |   2 +-
 .../@stdlib/constants/uint16/test/test.js     |   2 +-
 .../@stdlib/constants/uint32/max/test/test.js |   2 +-
 .../constants/uint32/num-bytes/test/test.js   |   2 +-
 .../@stdlib/constants/uint32/test/test.js     |   2 +-
 .../@stdlib/constants/uint8/max/test/test.js  |   2 +-
 .../constants/uint8/num-bytes/test/test.js    |   2 +-
 .../@stdlib/constants/uint8/test/test.js      |   2 +-
 .../constants/unicode/max-bmp/test/test.js    |   2 +-
 .../constants/unicode/max/test/test.js        |   2 +-
 .../string/acronym/test/test.validate.js      |   6 +-
 .../@stdlib/string/base/atob/test/test.js     |   4 +-
 .../string/base/capitalize/test/test.js       |   8 +-
 .../string/base/distances/test/test.js        |   2 +-
 .../string/base/ends-with/test/test.js        |   4 +-
 .../@stdlib/string/base/left-pad/test/test.js |  10 +-
 .../string/base/left-trim/test/test.js        |  60 ++++----
 .../string/base/left-trim/test/test.main.js   |  56 ++++----
 .../base/left-trim/test/test.polyfill.js      |  56 ++++----
 .../string/base/lowercase/test/test.js        |   2 +-
 .../@stdlib/string/base/repeat/test/test.js   |  12 +-
 .../string/base/repeat/test/test.main.js      |   8 +-
 .../string/base/repeat/test/test.polyfill.js  |   8 +-
 .../@stdlib/string/base/replace/test/test.js  |   6 +-
 .../string/base/right-pad/test/test.js        |  10 +-
 .../string/base/right-trim/test/test.js       |  58 ++++----
 .../string/base/right-trim/test/test.main.js  |  54 ++++----
 .../base/right-trim/test/test.polyfill.js     |  54 ++++----
 .../string/base/starts-with/test/test.js      |   4 +-
 .../@stdlib/string/base/test/test.js          |   2 +-
 .../@stdlib/string/base/trim/test/test.js     |  72 +++++-----
 .../string/base/trim/test/test.main.js        |  64 ++++-----
 .../string/base/trim/test/test.polyfill.js    |  66 ++++-----
 .../string/base/uncapitalize/test/test.js     |   8 +-
 .../string/base/uppercase/test/test.js        |   2 +-
 .../@stdlib/string/capitalize/test/test.js    |   8 +-
 .../@stdlib/string/left-pad/test/test.js      |  10 +-
 .../@stdlib/string/left-trim/test/test.js     |  56 ++++----
 .../@stdlib/string/lowercase/test/test.js     |   2 +-
 .../@stdlib/string/num2words/test/test.js     |  24 ++--
 .../string/num2words/test/test.validate.js    |   8 +-
 .../@stdlib/string/pad/test/test.js           |  38 +++---
 .../@stdlib/string/pad/test/test.validate.js  |  10 +-
 .../string/remove-punctuation/test/test.js    |  10 +-
 .../string/remove-utf8-bom/test/test.js       |  10 +-
 .../@stdlib/string/remove-words/test/test.js  |  14 +-
 .../@stdlib/string/repeat/test/test.js        |   8 +-
 .../@stdlib/string/replace/test/test.js       |  12 +-
 .../@stdlib/string/right-pad/test/test.js     |  10 +-
 .../@stdlib/string/right-trim/test/test.js    |  54 ++++----
 lib/node_modules/@stdlib/string/test/test.js  |   2 +-
 .../test/test.js                              | 128 +++++++++---------
 .../to-grapheme-cluster-iterator/test/test.js | 128 +++++++++---------
 .../string/to-well-formed/test/test.js        |  16 +--
 .../tools/grapheme-cluster-break/test/test.js |   8 +-
 .../@stdlib/string/tools/test/test.js         |   2 +-
 .../@stdlib/string/trim/test/test.js          |  66 ++++-----
 .../@stdlib/string/uncapitalize/test/test.js  |   8 +-
 .../@stdlib/string/uppercase/test/test.js     |   2 +-
 439 files changed, 2133 insertions(+), 2132 deletions(-)

diff --git a/lib/node_modules/@stdlib/assert/contains/test/test.js b/lib/node_modules/@stdlib/assert/contains/test/test.js
index 4d1729ea33f2..4cb299192f72 100644
--- a/lib/node_modules/@stdlib/assert/contains/test/test.js
+++ b/lib/node_modules/@stdlib/assert/contains/test/test.js
@@ -129,13 +129,13 @@ tape( 'the function returns `true` when a search string is contained in input st
 	var out;
 
 	out = contains( 'Hello World', 'World' );
-	t.equal( out, true, 'returns expected value' );
+	t.strictEqual( out, true, 'returns expected value' );
 
 	out = contains( 'Hello World', ' ' );
-	t.equal( out, true, 'returns expected value' );
+	t.strictEqual( out, true, 'returns expected value' );
 
 	out = contains( 'Hello World', 'Hell' );
-	t.equal( out, true, 'returns expected value' );
+	t.strictEqual( out, true, 'returns expected value' );
 
 	t.end();
 });
@@ -144,13 +144,13 @@ tape( 'the function returns `false` when a search string is not contained in inp
 	var out;
 
 	out = contains( 'Hello World', 'world' );
-	t.equal( out, false, 'returns expected value' );
+	t.strictEqual( out, false, 'returns expected value' );
 
 	out = contains( 'Hello World', '\t' );
-	t.equal( out, false, 'returns expected value' );
+	t.strictEqual( out, false, 'returns expected value' );
 
 	out = contains( 'Hello World', 'Word' );
-	t.equal( out, false, 'returns expected value' );
+	t.strictEqual( out, false, 'returns expected value' );
 
 	t.end();
 });
@@ -159,13 +159,13 @@ tape( 'the function returns `true` when a search value is contained in input arr
 	var out;
 
 	out = contains( [ NaN, null, 3, 'abc' ], 'abc' );
-	t.equal( out, true, 'returns expected value' );
+	t.strictEqual( out, true, 'returns expected value' );
 
 	out = contains( [ NaN, null, 3, 'abc' ], NaN );
-	t.equal( out, true, 'returns expected value' );
+	t.strictEqual( out, true, 'returns expected value' );
 
 	out = contains( [ NaN, null, 3, 'abc' ], null );
-	t.equal( out, true, 'returns expected value' );
+	t.strictEqual( out, true, 'returns expected value' );
 
 	t.end();
 });
@@ -174,13 +174,13 @@ tape( 'the function returns `false` when search value is not contained in input
 	var out;
 
 	out = contains( [ NaN, null, 3, 'abc' ], 'ac' );
-	t.equal( out, false, 'returns expected value' );
+	t.strictEqual( out, false, 'returns expected value' );
 
 	out = contains( [ NaN, null, 3, 'abc' ], false );
-	t.equal( out, false, 'returns expected value' );
+	t.strictEqual( out, false, 'returns expected value' );
 
 	out = contains( [ NaN, null, 3, 'abc' ], 3.5 );
-	t.equal( out, false, 'returns expected value' );
+	t.strictEqual( out, false, 'returns expected value' );
 
 	t.end();
 });
@@ -189,50 +189,50 @@ tape( 'the function supports beginning a search at the specified position', func
 	var out;
 
 	out = contains( 'ABCDEFG', 'A', 1 );
-	t.equal( out, false, 'returns expected value' );
+	t.strictEqual( out, false, 'returns expected value' );
 
 	out = contains( 'ABCDEFG', 'B', 1 );
-	t.equal( out, true, 'returns expected value' );
+	t.strictEqual( out, true, 'returns expected value' );
 
 	out = contains( 'ABCDEFG', 'A', -3 );
-	t.equal( out, true, 'returns expected value' );
+	t.strictEqual( out, true, 'returns expected value' );
 
 	out = contains( [ null, NaN, 2 ], 3, 1 );
-	t.equal( out, false, 'returns expected value' );
+	t.strictEqual( out, false, 'returns expected value' );
 
 	out = contains( [ null, NaN, 2 ], NaN, 1 );
-	t.equal( out, true, 'returns expected value' );
+	t.strictEqual( out, true, 'returns expected value' );
 
 	out = contains( [ null, NaN, 2 ], NaN, -3 );
-	t.equal( out, true, 'returns expected value' );
+	t.strictEqual( out, true, 'returns expected value' );
 
 	out = contains( [ null, NaN, 2 ], NaN, 2 );
-	t.equal( out, false, 'returns expected value' );
+	t.strictEqual( out, false, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an input string and an empty string as the search value', function test( t ) {
-	t.equal( contains( 'abc', '' ), true, 'returns expected value' );
-	t.equal( contains( '', '' ), true, 'returns expected value' );
+	t.strictEqual( contains( 'abc', '' ), true, 'returns expected value' );
+	t.strictEqual( contains( '', '' ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided an empty array-like value', function test( t ) {
-	t.equal( contains( [], '' ), false, 'returns expected value' );
+	t.strictEqual( contains( [], '' ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function does distinguish between positive and negative zero', function test( t ) {
-	t.equal( contains( [ -0.0 ], +0.0 ), false, 'returns expected value' );
-	t.equal( contains( [ +0.0 ], -0.0 ), false, 'returns expected value' );
-	t.equal( contains( [ -0.0 ], -0.0 ), true, 'returns expected value' );
-	t.equal( contains( [ +0.0 ], +0.0 ), true, 'returns expected value' );
+	t.strictEqual( contains( [ -0.0 ], +0.0 ), false, 'returns expected value' );
+	t.strictEqual( contains( [ +0.0 ], -0.0 ), false, 'returns expected value' );
+	t.strictEqual( contains( [ -0.0 ], -0.0 ), true, 'returns expected value' );
+	t.strictEqual( contains( [ +0.0 ], +0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a position which exceeds the maximum index', function test( t ) {
-	t.equal( contains( [ 1 ], 1, 1e5 ), false, 'returns expected value' );
-	t.equal( contains( 'abc', 'a', 1e5 ), false, 'returns expected value' );
+	t.strictEqual( contains( [ 1 ], 1, 1e5 ), false, 'returns expected value' );
+	t.strictEqual( contains( 'abc', 'a', 1e5 ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.js b/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.js
index be9f63899974..28159519bd6e 100644
--- a/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.js
@@ -37,7 +37,7 @@ tape( 'if platform is POSIX, main export is method to test if a string is a POSI
 	var isAbsolutePath = proxyquire( './../lib', {
 		'@stdlib/assert/is-windows': false
 	});
-	t.equal( isAbsolutePath, isAbsolutePath.posix, 'equals posix method' );
+	t.strictEqual( isAbsolutePath, isAbsolutePath.posix, 'equals posix method' );
 	t.end();
 });
 
@@ -45,16 +45,16 @@ tape( 'if platform is Windows, main export is method to test if a string is a Wi
 	var isAbsolutePath = proxyquire( './../lib', {
 		'@stdlib/assert/is-windows': true
 	});
-	t.equal( isAbsolutePath, isAbsolutePath.win32, 'equals win32 method' );
+	t.strictEqual( isAbsolutePath, isAbsolutePath.win32, 'equals win32 method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test if a string is a POSIX absolute path', function test( t ) {
-	t.equal( typeof isAbsolutePath.posix, 'function', 'has a posix method' );
+	t.strictEqual( typeof isAbsolutePath.posix, 'function', 'has a posix method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test if a string is a Windows absolute path', function test( t ) {
-	t.equal( typeof isAbsolutePath.win32, 'function', 'has a win32 method' );
+	t.strictEqual( typeof isAbsolutePath.win32, 'function', 'has a win32 method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.posix.js b/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.posix.js
index 4a1a23cf4e39..523a1793fa6f 100644
--- a/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.posix.js
+++ b/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.posix.js
@@ -49,7 +49,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 	];
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isAbsolutePath( values[ i ] );
-		t.equal( bool, false, 'returns `false` when provided '+values[i] );
+		t.strictEqual( bool, false, 'returns `false` when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.win32.js b/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.win32.js
index 6dac20e0a025..4acef0178e1d 100644
--- a/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.win32.js
+++ b/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.win32.js
@@ -49,7 +49,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 	];
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isAbsolutePath( values[ i ] );
-		t.equal( bool, false, 'returns `false` when provided '+values[i] );
+		t.strictEqual( bool, false, 'returns `false` when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-accessor-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-accessor-property-in/test/test.js
index b1564c9b380e..522540358a1c 100644
--- a/lib/node_modules/@stdlib/assert/is-accessor-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-accessor-property-in/test/test.js
@@ -59,13 +59,13 @@ tape( 'the function returns `true` if an object property has an accessor descrip
 	});
 
 	bool = isAccessorPropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isAccessorPropertyIn( obj, 'b' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isAccessorPropertyIn( obj, 'c' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -108,13 +108,13 @@ tape( 'the function returns `true` if provided an inherited property having an a
 	obj = new Foo();
 
 	bool = isAccessorPropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isAccessorPropertyIn( obj, 'b' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isAccessorPropertyIn( obj, 'c' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -140,19 +140,19 @@ tape( 'the function returns `false` if an object property has a data descriptor'
 		'a': 'b'
 	};
 	bool = isAccessorPropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorPropertyIn( [ 1, 2, 3 ], '1' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorPropertyIn( [ 1, 2, 3 ], 1 );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorPropertyIn( new Foo(), 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorPropertyIn( [ 'a' ], 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -163,7 +163,7 @@ tape( 'the function returns `false` if an object property has a data descriptor'
 	});
 
 	bool = isAccessorPropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -172,10 +172,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isAccessorPropertyIn( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isAccessorPropertyIn( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -189,10 +189,10 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isAccessorPropertyIn( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorPropertyIn( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -215,16 +215,16 @@ tape( 'the function returns `false` if provided an inherited property having a d
 	obj = new Foo();
 
 	bool = isAccessorPropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorPropertyIn( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorPropertyIn( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorPropertyIn( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -233,7 +233,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isAccessorPropertyIn( 'beep', 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-accessor-property/test/test.js b/lib/node_modules/@stdlib/assert/is-accessor-property/test/test.js
index a7aa83f41612..693e13f9090d 100644
--- a/lib/node_modules/@stdlib/assert/is-accessor-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-accessor-property/test/test.js
@@ -59,13 +59,13 @@ tape( 'the function returns `true` if an object property has an accessor descrip
 	});
 
 	bool = isAccessorProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isAccessorProperty( obj, 'b' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isAccessorProperty( obj, 'c' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -91,19 +91,19 @@ tape( 'the function returns `false` if an object property has a data descriptor'
 		'a': 'b'
 	};
 	bool = isAccessorProperty( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorProperty( [ 1, 2, 3 ], '1' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorProperty( [ 1, 2, 3 ], 1 );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorProperty( new Foo(), 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorProperty( [ 'a' ], 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -114,7 +114,7 @@ tape( 'the function returns `false` if an object property has a data descriptor'
 	});
 
 	bool = isAccessorProperty( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -123,10 +123,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isAccessorProperty( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isAccessorProperty( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -140,10 +140,10 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isAccessorProperty( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorProperty( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -165,16 +165,16 @@ tape( 'the function returns `false` if provided an inherited property', function
 	obj = new Foo();
 
 	bool = isAccessorProperty( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorProperty( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorProperty( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isAccessorProperty( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -187,7 +187,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isAccessorProperty( 'beep', 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-array-like/test/test.js b/lib/node_modules/@stdlib/assert/is-array-like/test/test.js
index 1bf2eb1835f6..7df64870e4d6 100644
--- a/lib/node_modules/@stdlib/assert/is-array-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-array-like/test/test.js
@@ -49,26 +49,26 @@ tape( 'the function returns `true` if provided an array-like value', function te
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isArrayLike( values[i] ), true, 'returns true when provided '+values[i] );
+		t.strictEqual( isArrayLike( values[i] ), true, 'returns true when provided '+values[i] );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided an array-like value whose length exceeds the maximum array length', function test( t ) {
 	var o = { 'length': MAX_ARRAY_LENGTH+1 };
-	t.equal( isArrayLike( o ), false, 'returns false' );
+	t.strictEqual( isArrayLike( o ), false, 'returns false' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided an array-like value whose length property is not an integer', function test( t ) {
 	var o = { 'length': 3.14 };
-	t.equal( isArrayLike( o ), false, 'returns false' );
+	t.strictEqual( isArrayLike( o ), false, 'returns false' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided an array-like value whose length property is a negative integer', function test( t ) {
 	var o = { 'length': -1 };
-	t.equal( isArrayLike( o ), false, 'returns false' );
+	t.strictEqual( isArrayLike( o ), false, 'returns false' );
 	t.end();
 });
 
@@ -88,7 +88,7 @@ tape( 'the function returns `false` if not provided an array-like value', functi
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isArrayLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isArrayLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-array/test/test.js b/lib/node_modules/@stdlib/assert/is-array/test/test.js
index 931554fe9028..c84bdc770088 100644
--- a/lib/node_modules/@stdlib/assert/is-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-array/test/test.js
@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
+var zeros = require( '@stdlib/array/base/zeros' );
 var isArray = require( './../lib' );
 
 
@@ -34,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an array', function test( t ) {
-	t.equal( isArray( [] ), true, 'returns true' );
-	t.equal( isArray( new Array( 10 ) ), true, 'returns true' );
+	t.strictEqual( isArray( [] ), true, 'returns true' );
+	t.strictEqual( isArray( zeros( 10 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -55,7 +56,7 @@ tape( 'the function returns `false` if not provided an array', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isArray( values[i] ), false, 'returns false when provided ' + values[i] );
+		t.strictEqual( isArray( values[i] ), false, 'returns false when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -82,9 +83,9 @@ tape( 'the function includes a polyfill for `Array.isArray`', function test( t )
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isArray( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isArray( values[i] ), false, 'returns false when provided '+values[i] );
 	}
-	t.equal( isArray( [] ), true, 'returns true when provided an array' );
+	t.strictEqual( isArray( [] ), true, 'returns true when provided an array' );
 
 	Array.isArray = fcn;
 	t.end();
diff --git a/lib/node_modules/@stdlib/assert/is-arrow-function/test/es2015-arrow-function/index.js b/lib/node_modules/@stdlib/assert/is-arrow-function/test/es2015-arrow-function/index.js
index 77623b1d223a..f051e851d4b6 100644
--- a/lib/node_modules/@stdlib/assert/is-arrow-function/test/es2015-arrow-function/index.js
+++ b/lib/node_modules/@stdlib/assert/is-arrow-function/test/es2015-arrow-function/index.js
@@ -29,6 +29,6 @@ var isArrowFunction = require( './../../lib' );
 // TESTS //
 
 tape( 'the function returns `true` if provided an arrow function', function test( t ) {
-	t.equal( isArrowFunction( () => {} ), true, 'returns true' );
+	t.strictEqual( isArrowFunction( () => {} ), true, 'returns true' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-big-endian/test/test.js b/lib/node_modules/@stdlib/assert/is-big-endian/test/test.js
index ff7c4996b77d..f2c5c77c0059 100644
--- a/lib/node_modules/@stdlib/assert/is-big-endian/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-big-endian/test/test.js
@@ -41,7 +41,7 @@ tape( 'the boolean is `true` if an environment is big endian', function test( t
 		}
 	});
 
-	t.equal( IS_BIG_ENDIAN, true, 'is big endian' );
+	t.strictEqual( IS_BIG_ENDIAN, true, 'is big endian' );
 
 	t.end();
 
@@ -58,7 +58,7 @@ tape( 'the boolean is `false` if an environment is not big endian (e.g., little
 		}
 	});
 
-	t.equal( IS_BIG_ENDIAN, false, 'is not big endian' );
+	t.strictEqual( IS_BIG_ENDIAN, false, 'is not big endian' );
 	t.end();
 
 	// Mock big endian byte order, where most significant bits are last...
diff --git a/lib/node_modules/@stdlib/assert/is-binary-string/test/test.js b/lib/node_modules/@stdlib/assert/is-binary-string/test/test.js
index 1c815df9776c..319a648697ef 100644
--- a/lib/node_modules/@stdlib/assert/is-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-binary-string/test/test.js
@@ -45,13 +45,13 @@ tape( 'the function returns `true` if provided a binary string', function test(
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isBinaryString( values[i] ), true, 'returns true' );
+		t.strictEqual( isBinaryString( values[i] ), true, 'returns true' );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a `String` object, even if the value of the `String` object is a binary string', function test( t ) {
-	t.equal( isBinaryString( new String( '0101' ) ), false, 'returns false' );
+	t.strictEqual( isBinaryString( new String( '0101' ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -75,7 +75,7 @@ tape( 'the function returns `false` if not provided a binary string', function t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isBinaryString( values[i] ), false, 'returns false when provided ' + values[i] );
+		t.strictEqual( isBinaryString( values[i] ), false, 'returns false when provided ' + values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-blank-string/test/test.js b/lib/node_modules/@stdlib/assert/is-blank-string/test/test.js
index 2eb9423144d5..73b06056e0de 100644
--- a/lib/node_modules/@stdlib/assert/is-blank-string/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-blank-string/test/test.js
@@ -44,13 +44,13 @@ tape( 'the function returns `true` if provided a blank string', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isBlankString( values[i] ), true, 'returns true' );
+		t.strictEqual( isBlankString( values[i] ), true, 'returns true' );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a `String` object, even if the value of the `String` object is a blank string', function test( t ) {
-	t.equal( isBlankString( new String( ' ' ) ), false, 'returns false' );
+	t.strictEqual( isBlankString( new String( ' ' ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -74,7 +74,7 @@ tape( 'the function returns `false` if not provided a blank string', function te
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isBlankString( values[i] ), false, 'returns false when provided ' + values[i] );
+		t.strictEqual( isBlankString( values[i] ), false, 'returns false when provided ' + values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-boolean-array/test/test.js b/lib/node_modules/@stdlib/assert/is-boolean-array/test/test.js
index 783cb3d27a65..bc8c4740c2d3 100644
--- a/lib/node_modules/@stdlib/assert/is-boolean-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-boolean-array/test/test.js
@@ -18,8 +18,6 @@
 
 'use strict';
 
-/* eslint-disable no-new-wrappers */
-
 // MODULES //
 
 var tape = require( 'tape' );
@@ -39,17 +37,17 @@ tape( 'the function tests for an array-like object containing only booleans', fu
 	var arr;
 
 	arr = [ true, new Boolean( true ), false, new Boolean( false ) ];
-	t.equal( isBooleanArray( arr ), true, 'returns true' );
+	t.strictEqual( isBooleanArray( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': true,
 		'1': false
 	};
-	t.equal( isBooleanArray( arr ), true, 'returns true' );
+	t.strictEqual( isBooleanArray( arr ), true, 'returns true' );
 
 	arr = [ true, 'true', null ];
-	t.equal( isBooleanArray( arr ), false, 'returns false' );
+	t.strictEqual( isBooleanArray( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -58,17 +56,17 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ true, false, true, false ];
-	t.equal( isBooleanArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isBooleanArray.primitives( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': false,
 		'1': true
 	};
-	t.equal( isBooleanArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isBooleanArray.primitives( arr ), true, 'returns true' );
 
 	arr = [ new Boolean( true ), false, false ];
-	t.equal( isBooleanArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isBooleanArray.primitives( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -77,17 +75,17 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Boolean( true ), new Boolean( false ), new Boolean( true ) ];
-	t.equal( isBooleanArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isBooleanArray.objects( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': new Boolean( true ),
 		'1': new Boolean( true )
 	};
-	t.equal( isBooleanArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isBooleanArray.objects( arr ), true, 'returns true' );
 
 	arr = [ new Boolean( true ), false, false ];
-	t.equal( isBooleanArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isBooleanArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-boolean/test/test.js b/lib/node_modules/@stdlib/assert/is-boolean/test/test.js
index 10a98f6ea488..1513afc1328e 100644
--- a/lib/node_modules/@stdlib/assert/is-boolean/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-boolean/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive boolean', function test( t ) {
-	t.equal( typeof isBoolean.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isBoolean.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a boolean object', function test( t ) {
-	t.equal( typeof isBoolean.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isBoolean.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-boolean/test/test.main.js b/lib/node_modules/@stdlib/assert/is-boolean/test/test.main.js
index 1ce7d7cb1c51..4b54f989f15b 100644
--- a/lib/node_modules/@stdlib/assert/is-boolean/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-boolean/test/test.main.js
@@ -34,10 +34,10 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a boolean', function test( t ) {
-	t.equal( isBoolean( false ), true, 'returns true' );
-	t.equal( isBoolean( new Boolean( false ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
-	t.equal( isBoolean( true ), true, 'returns true' );
-	t.equal( isBoolean( new Boolean( true ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isBoolean( false ), true, 'returns true' );
+	t.strictEqual( isBoolean( new Boolean( false ) ), true, 'returns true' );
+	t.strictEqual( isBoolean( true ), true, 'returns true' );
+	t.strictEqual( isBoolean( new Boolean( true ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `false` if not provided a boolean', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isBoolean( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isBoolean( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-boolean/test/test.object.js b/lib/node_modules/@stdlib/assert/is-boolean/test/test.object.js
index 2f0ed83e844b..52b03cb2e5a9 100644
--- a/lib/node_modules/@stdlib/assert/is-boolean/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-boolean/test/test.object.js
@@ -44,14 +44,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a boolean object', function test( t ) {
-	t.equal( isBoolean( new Boolean( false ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
-	t.equal( isBoolean( new Boolean( true ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isBoolean( new Boolean( false ) ), true, 'returns true' );
+	t.strictEqual( isBoolean( new Boolean( true ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive boolean', function test( t ) {
-	t.equal( isBoolean( true ), false, 'returns false' );
-	t.equal( isBoolean( false ), false, 'returns false' );
+	t.strictEqual( isBoolean( true ), false, 'returns false' );
+	t.strictEqual( isBoolean( false ), false, 'returns false' );
 	t.end();
 });
 
@@ -70,7 +70,7 @@ tape( 'if `Symbol.toStringTag` is supported, the function guards against objects
 	if ( hasToStringTag() ) {
 		mock[ Symbol.toStringTag ] = 'Boolean';
 	}
-	t.equal( isBoolean( mock ), false, 'returns false' );
+	t.strictEqual( isBoolean( mock ), false, 'returns false' );
 	t.end();
 
 	function detect() {
@@ -89,8 +89,8 @@ tape( 'if `Symbol.toStringTag` is not supported, the function attempts to determ
 		'@stdlib/assert/has-tostringtag-support': detect
 	});
 
-	t.equal( isBoolean( new Boolean( true ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
-	t.equal( isBoolean( {} ), false, 'returns false' );
+	t.strictEqual( isBoolean( new Boolean( true ) ), true, 'returns true' );
+	t.strictEqual( isBoolean( {} ), false, 'returns false' );
 
 	t.end();
 
@@ -118,7 +118,7 @@ tape( 'the function returns `false` if not provided a boolean', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isBoolean( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isBoolean( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-boolean/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-boolean/test/test.primitive.js
index 6ee3fc793079..4b4a7f586aaf 100644
--- a/lib/node_modules/@stdlib/assert/is-boolean/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-boolean/test/test.primitive.js
@@ -34,14 +34,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive boolean', function test( t ) {
-	t.equal( isBoolean( true ), true, 'returns true' );
-	t.equal( isBoolean( false ), true, 'returns true' );
+	t.strictEqual( isBoolean( true ), true, 'returns true' );
+	t.strictEqual( isBoolean( false ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a boolean object', function test( t ) {
-	t.equal( isBoolean( new Boolean( true ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
-	t.equal( isBoolean( new Boolean( false ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isBoolean( new Boolean( true ) ), false, 'returns false' );
+	t.strictEqual( isBoolean( new Boolean( false ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns `false` if not provided a boolean', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isBoolean( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isBoolean( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-boolean/test/test.try2serialize.js b/lib/node_modules/@stdlib/assert/is-boolean/test/test.try2serialize.js
index 82403841b555..721ce4cb2062 100644
--- a/lib/node_modules/@stdlib/assert/is-boolean/test/test.try2serialize.js
+++ b/lib/node_modules/@stdlib/assert/is-boolean/test/test.try2serialize.js
@@ -34,14 +34,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if able to serialize', function test( t ) {
-	t.equal( serialize( true ), true, 'returns true' );
-	t.equal( serialize( new Boolean( true ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
-	t.equal( serialize( false ), true, 'returns true' );
-	t.equal( serialize( new Boolean( false ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( serialize( true ), true, 'returns true' );
+	t.strictEqual( serialize( new Boolean( true ) ), true, 'returns true' );
+	t.strictEqual( serialize( false ), true, 'returns true' );
+	t.strictEqual( serialize( new Boolean( false ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if unable to serialize', function test( t ) {
-	t.equal( serialize( {} ), false, 'returns false' );
+	t.strictEqual( serialize( {} ), false, 'returns false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-boxed-primitive/test/test.js b/lib/node_modules/@stdlib/assert/is-boxed-primitive/test/test.js
index ebcee207c164..261af6149c28 100644
--- a/lib/node_modules/@stdlib/assert/is-boxed-primitive/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-boxed-primitive/test/test.js
@@ -50,24 +50,24 @@ tape( 'the function returns `true` if provided a boxed primitive', function test
 	var i;
 
 	values = [
-		new Boolean(), // eslint-disable-line no-new-wrappers
-		new String(), // eslint-disable-line no-new-wrappers
-		new Number() // eslint-disable-line no-new-wrappers
+		new Boolean(),
+		new String(),
+		new Number()
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isBoxedPrimitive( values[i] ), true, 'returns true' );
+		t.strictEqual( isBoxedPrimitive( values[i] ), true, 'returns true' );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided a boxed `Symbol`', opts, function test( t ) {
-	t.equal( isBoxedPrimitive( Object( Symbol( 'symbol' ) ) ), true, 'returns true' );
+	t.strictEqual( isBoxedPrimitive( Object( Symbol( 'symbol' ) ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive `Symbol`', opts, function test( t ) {
-	t.equal( isBoxedPrimitive( Symbol( 'symbol' ) ), false, 'returns false' );
+	t.strictEqual( isBoxedPrimitive( Symbol( 'symbol' ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -85,7 +85,7 @@ tape( 'the function returns `false` if not provided a boxed primitive', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isBoxedPrimitive( values[i] ), false, 'returns false for value: '+values[i] );
+		t.strictEqual( isBoxedPrimitive( values[i] ), false, 'returns false for value: '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-browser/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-browser/test/test.browser.js
index 7eb41b49f36b..91bcad10229e 100644
--- a/lib/node_modules/@stdlib/assert/is-browser/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-browser/test/test.browser.js
@@ -33,6 +33,6 @@ tape( 'main export is a boolean', function test( t ) {
 });
 
 tape( 'the exported value is always `true`', function test( t ) {
-	t.equal( IS_BROWSER, true, 'returns true' );
+	t.strictEqual( IS_BROWSER, true, 'returns true' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-browser/test/test.main.js b/lib/node_modules/@stdlib/assert/is-browser/test/test.main.js
index 63476530fd00..aa6d8c77c14b 100644
--- a/lib/node_modules/@stdlib/assert/is-browser/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-browser/test/test.main.js
@@ -58,7 +58,7 @@ tape( 'the function returns `true` if the runtime is a web browser', function te
 		'./global_scope.js': true
 	});
 
-	t.equal( isBrowser(), true, 'returns true' );
+	t.strictEqual( isBrowser(), true, 'returns true' );
 	t.end();
 
 	function getGlobal() {
@@ -79,7 +79,7 @@ tape( 'the function returns `false` if the runtime is not a web browser (`window
 		'./global_scope.js': true
 	});
 
-	t.equal( isBrowser(), false, 'returns false' );
+	t.strictEqual( isBrowser(), false, 'returns false' );
 	t.end();
 
 	function getGlobal() {
@@ -100,7 +100,7 @@ tape( 'the function returns `false` if the runtime is not a web browser (`window
 		'./global_scope.js': true
 	});
 
-	t.equal( isBrowser(), false, 'returns false' );
+	t.strictEqual( isBrowser(), false, 'returns false' );
 	t.end();
 
 	function getGlobal() {
@@ -121,7 +121,7 @@ tape( 'the function returns `false` if the runtime is not a web browser (`window
 		'./global_scope.js': false
 	});
 
-	t.equal( isBrowser(), false, 'returns false' );
+	t.strictEqual( isBrowser(), false, 'returns false' );
 	t.end();
 
 	function getGlobal() {
diff --git a/lib/node_modules/@stdlib/assert/is-buffer/test/test.js b/lib/node_modules/@stdlib/assert/is-buffer/test/test.js
index e84df7764921..359f7766ad98 100644
--- a/lib/node_modules/@stdlib/assert/is-buffer/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-buffer/test/test.js
@@ -44,7 +44,7 @@ tape( 'if provided a Buffer object, the function returns `true`', function test(
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isBuffer( values[i] ), true, 'returns `true` for value ' + i );
+		t.strictEqual( isBuffer( values[i] ), true, 'returns `true` for value ' + i );
 	}
 	t.end();
 });
@@ -66,7 +66,7 @@ tape( 'if provided any value other than a Buffer object, the function returns `f
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isBuffer( values[i] ), false, 'returns `false` for  value: ' + values[i] );
+		t.strictEqual( isBuffer( values[i] ), false, 'returns `false` for  value: ' + values[i] );
 	}
 
 	function Foo() {
@@ -74,7 +74,7 @@ tape( 'if provided any value other than a Buffer object, the function returns `f
 	}
 	Foo.prototype.isBuffer = null;
 
-	t.equal( isBuffer( new Foo() ), false, 'returns `false` when provided a class with an `isBuffer` method' );
+	t.strictEqual( isBuffer( new Foo() ), false, 'returns `false` when provided a class with an `isBuffer` method' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-centrosymmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-centrosymmetric-matrix/test/test.js
index 272359c4ada8..eeafaf106561 100644
--- a/lib/node_modules/@stdlib/assert/is-centrosymmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-centrosymmetric-matrix/test/test.js
@@ -49,7 +49,7 @@ tape( 'the function returns `true` if provided a centrosymmetric matrix (odd ord
 	];
 	arr = ndarray( 'generic', buffer, [ 5, 5 ], [ 5, 1 ], 0, 'row-major' );
 
-	t.equal( isCentrosymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'the function returns `true` if provided a centrosymmetric matrix (even or
 	];
 	arr = ndarray( 'generic', buffer, [ 6, 6 ], [ 6, 1 ], 0, 'row-major' );
 
-	t.equal( isCentrosymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -90,7 +90,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isCentrosymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 
 	function get( i, j ) {
@@ -101,14 +101,14 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 tape( 'the function returns `false` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.equal( isCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a centrosymmetric matrix (even order)', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 3, 4 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.equal( isCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -123,7 +123,7 @@ tape( 'the function returns `false` if not provided a centrosymmetric matrix (od
 	];
 	arr = ndarray( 'generic', buffer, [ 3, 3 ], [ 3, 1 ], 0, 'row-major' );
 
-	t.equal( isCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -144,7 +144,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.equal( isCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -165,7 +165,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.equal( isCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 
 	function get( i, j ) {
@@ -195,7 +195,7 @@ tape( 'the function returns `false` if not provided a 2-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCentrosymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isCentrosymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-circular-array/test/test.js b/lib/node_modules/@stdlib/assert/is-circular-array/test/test.js
index e491a122c121..46a2aa32e837 100644
--- a/lib/node_modules/@stdlib/assert/is-circular-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-circular-array/test/test.js
@@ -69,7 +69,7 @@ tape( 'the function returns `false` if not provided an array', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCircularArray( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircularArray( values[i] ), false, 'returns false' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns `false` if provided an array not containing a circul
 		arr3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCircularArray( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircularArray( values[i] ), false, 'returns false' );
 	}
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function returns `true` if provided an array containing a circular re
 		arr3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCircularArray( values[i] ), true, 'returns true' );
+		t.strictEqual( isCircularArray( values[i] ), true, 'returns true' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-circular-plain-object/test/test.js b/lib/node_modules/@stdlib/assert/is-circular-plain-object/test/test.js
index d18d13d29ca3..ec66ae7e5b66 100644
--- a/lib/node_modules/@stdlib/assert/is-circular-plain-object/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-circular-plain-object/test/test.js
@@ -45,11 +45,11 @@ tape( 'the function returns `false` if not provided a plain object', function te
 		function noop() {},
 		[],
 		new Date(),
-		new RegExp( '[0-9]' )
+		new RegExp( '[0-9]' ) // eslint-disable-line prefer-regex-literals
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCircularPlainObject( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircularPlainObject( values[i] ), false, 'returns false' );
 	}
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns `false` if provided a plain object not containing a
 		obj3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCircularPlainObject( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircularPlainObject( values[i] ), false, 'returns false' );
 	}
 	t.end();
 });
@@ -117,7 +117,7 @@ tape( 'the function returns `true` if provided a plain object containing a circu
 		obj3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCircularPlainObject( values[i] ), true, 'returns true' );
+		t.strictEqual( isCircularPlainObject( values[i] ), true, 'returns true' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-circular/test/test.js b/lib/node_modules/@stdlib/assert/is-circular/test/test.js
index a37ba8e8ada1..7d0d2c79ad31 100644
--- a/lib/node_modules/@stdlib/assert/is-circular/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-circular/test/test.js
@@ -45,7 +45,7 @@ tape( 'the function returns `false` if not provided an object-like value', funct
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCircular( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircular( values[i] ), false, 'returns false' );
 	}
 	t.end();
 });
@@ -78,10 +78,10 @@ tape( 'the function returns `false` if provided an object not containing a circu
 		obj2,
 		obj3,
 		new Date(),
-		new RegExp( '[0-9]' )
+		new RegExp( '[0-9]' ) // eslint-disable-line prefer-regex-literals
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCircular( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircular( values[i] ), false, 'returns false' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function returns `false` if provided an array not containing a circul
 		arr3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCircular( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircular( values[i] ), false, 'returns false' );
 	}
 	t.end();
 });
@@ -135,7 +135,7 @@ tape( 'the function returns `false` if provided a function not containing a circ
 		fcn3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCircular( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircular( values[i] ), false, 'returns false' );
 	}
 	t.end();
 });
@@ -165,7 +165,7 @@ tape( 'the function returns `true` if provided an object containing a circular r
 	obj3 = {};
 	obj3.self = obj3;
 
-	re = new RegExp( '[0-9]' );
+	re = new RegExp( '[0-9]' ); // eslint-disable-line prefer-regex-literals
 	re.self = re;
 
 	date = new Date();
@@ -179,7 +179,7 @@ tape( 'the function returns `true` if provided an object containing a circular r
 		date
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCircular( values[i] ), true, 'returns true' );
+		t.strictEqual( isCircular( values[i] ), true, 'returns true' );
 	}
 	t.end();
 });
@@ -208,7 +208,7 @@ tape( 'the function returns `true` if provided an array containing a circular re
 		arr3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCircular( values[i] ), true, 'returns true' );
+		t.strictEqual( isCircular( values[i] ), true, 'returns true' );
 	}
 	t.end();
 });
@@ -235,7 +235,7 @@ tape( 'the function returns `true` if provided a function containing a circular
 		fcn3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCircular( values[i] ), true, 'returns true' );
+		t.strictEqual( isCircular( values[i] ), true, 'returns true' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-complex-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex-like/test/test.js
index fc9bb2ad076e..db87d29ecc33 100644
--- a/lib/node_modules/@stdlib/assert/is-complex-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex-like/test/test.js
@@ -38,16 +38,16 @@ tape( 'the function returns `true` if provided a complex number-like object', fu
 	var v;
 
 	v = new Complex64( 3.0, 2.0 );
-	t.equal( isComplexLike( v ), true, 'returns true' );
+	t.strictEqual( isComplexLike( v ), true, 'returns true' );
 
 	v = new Complex128( 3.0, 2.0 );
-	t.equal( isComplexLike( v ), true, 'returns true' );
+	t.strictEqual( isComplexLike( v ), true, 'returns true' );
 
 	v = {
 		're': 1.0,
 		'im': -1.0
 	};
-	t.equal( isComplexLike( v ), true, 'returns true' );
+	t.strictEqual( isComplexLike( v ), true, 'returns true' );
 	t.end();
 });
 
@@ -76,7 +76,7 @@ tape( 'the function returns `false` if not provided a complex number-like object
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComplexLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComplexLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-complex-typed-array-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex-typed-array-like/test/test.js
index d3ff467a6c41..5ed9385f5d93 100644
--- a/lib/node_modules/@stdlib/assert/is-complex-typed-array-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex-typed-array-like/test/test.js
@@ -61,7 +61,7 @@ tape( 'the function returns `true` if provided a complex-typed-array-like object
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComplexTypedArrayLike( values[i] ), true, 'returns true when provided '+values[i] );
+		t.strictEqual( isComplexTypedArrayLike( values[i] ), true, 'returns true when provided '+values[i] );
 	}
 
 	t.end();
@@ -184,7 +184,7 @@ tape( 'the function returns `false` if not provided a complex-typed-array-like o
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComplexTypedArrayLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComplexTypedArrayLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-complex/test/test.js b/lib/node_modules/@stdlib/assert/is-complex/test/test.js
index d153266a2445..560d7d4440cc 100644
--- a/lib/node_modules/@stdlib/assert/is-complex/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex/test/test.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a 64-bit or 128-bit complex number', function test( t ) {
-	t.equal( isComplex( new Complex64( 3.0, 2.0 ) ), true, 'returns true' );
-	t.equal( isComplex( new Complex128( 3.0, 2.0 ) ), true, 'returns true' );
+	t.strictEqual( isComplex( new Complex64( 3.0, 2.0 ) ), true, 'returns true' );
+	t.strictEqual( isComplex( new Complex128( 3.0, 2.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a complex number', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComplex( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComplex( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-complex128/test/test.js b/lib/node_modules/@stdlib/assert/is-complex128/test/test.js
index aa69fe71b4fe..4ff904abf04d 100644
--- a/lib/node_modules/@stdlib/assert/is-complex128/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex128/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a 128-bit complex number', function test( t ) {
-	t.equal( isComplex128( new Complex128( 3.0, 2.0 ) ), true, 'returns true' );
+	t.strictEqual( isComplex128( new Complex128( 3.0, 2.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a 128-bit complex number', f
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComplex128( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComplex128( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-complex128matrix-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex128matrix-like/test/test.js
index 29f9c179403b..bccd17dbab2c 100644
--- a/lib/node_modules/@stdlib/assert/is-complex128matrix-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex128matrix-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 2-dimensional ndarray containing double-precision complex floating-point numbers', function test( t ) {
 	var arr = ndarray( 'complex128', new Complex128Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.equal( isComplex128MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex128MatrixLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isComplex128MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex128MatrixLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -87,7 +87,7 @@ tape( 'the function returns `false` if not provided a 2-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComplex128MatrixLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComplex128MatrixLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-complex128ndarray-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex128ndarray-like/test/test.js
index 12125b5302ac..b77e3bfdc1b5 100644
--- a/lib/node_modules/@stdlib/assert/is-complex128ndarray-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex128ndarray-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided an ndarray containing double-precision complex floating-point numbers', function test( t ) {
 	var arr = ndarray( 'complex128', new Complex128Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.equal( isComplex128ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex128ndarrayLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided an ndarray-like object containing
 		'set': noop
 	};
 
-	t.equal( isComplex128ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex128ndarrayLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns `false` if not provided an ndarray-like object conta
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComplex128ndarrayLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComplex128ndarrayLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-complex128vector-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex128vector-like/test/test.js
index 6e3b01a34b9f..d221375d9c95 100644
--- a/lib/node_modules/@stdlib/assert/is-complex128vector-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex128vector-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 1-dimensional ndarray containing double-precision complex floating-point numbers', function test( t ) {
 	var arr = ndarray( 'complex128', new Complex128Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 4 ], [ 1 ], 0, 'row-major' );
 
-	t.equal( isComplex128VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex128VectorLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 1-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isComplex128VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex128VectorLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -87,7 +87,7 @@ tape( 'the function returns `false` if not provided a 1-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComplex128VectorLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComplex128VectorLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-complex64/test/test.js b/lib/node_modules/@stdlib/assert/is-complex64/test/test.js
index 8a92e2b8bbd4..f35e667a7d05 100644
--- a/lib/node_modules/@stdlib/assert/is-complex64/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex64/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a 64-bit complex number', function test( t ) {
-	t.equal( isComplex64( new Complex64( 3.0, 2.0 ) ), true, 'returns true' );
+	t.strictEqual( isComplex64( new Complex64( 3.0, 2.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `false` if not provided a 64-bit complex number', fu
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComplex64( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComplex64( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-complex64matrix-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex64matrix-like/test/test.js
index 7bbbff9c504b..ab4319138945 100644
--- a/lib/node_modules/@stdlib/assert/is-complex64matrix-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex64matrix-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 2-dimensional ndarray containing single-precision complex floating-point numbers', function test( t ) {
 	var arr = ndarray( 'complex64', new Complex64Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.equal( isComplex64MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex64MatrixLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isComplex64MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex64MatrixLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -87,7 +87,7 @@ tape( 'the function returns `false` if not provided a 2-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComplex64MatrixLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComplex64MatrixLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-complex64ndarray-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex64ndarray-like/test/test.js
index 84bff8e57b1b..ada63714d77a 100644
--- a/lib/node_modules/@stdlib/assert/is-complex64ndarray-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex64ndarray-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided an ndarray containing single-precision complex floating-point numbers', function test( t ) {
 	var arr = ndarray( 'complex64', new Complex64Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.equal( isComplex64ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex64ndarrayLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided an ndarray-like object containing
 		'set': noop
 	};
 
-	t.equal( isComplex64ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex64ndarrayLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns `false` if not provided an ndarray-like object conta
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComplex64ndarrayLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComplex64ndarrayLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-complex64vector-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex64vector-like/test/test.js
index 73ce66b9fe37..1b300d49d62d 100644
--- a/lib/node_modules/@stdlib/assert/is-complex64vector-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex64vector-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 1-dimensional ndarray containing single-precision complex floating-point numbers', function test( t ) {
 	var arr = ndarray( 'complex64', new Complex64Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 4 ], [ 1 ], 0, 'row-major' );
 
-	t.equal( isComplex64VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex64VectorLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 1-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isComplex64VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex64VectorLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -87,7 +87,7 @@ tape( 'the function returns `false` if not provided a 1-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComplex64VectorLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComplex64VectorLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-composite/test/test.js b/lib/node_modules/@stdlib/assert/is-composite/test/test.js
index cca6c53613db..e3f6136babf8 100644
--- a/lib/node_modules/@stdlib/assert/is-composite/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-composite/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test primitives', function test( t ) {
-	t.equal( typeof isComposite.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isComposite.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test objects', function test( t ) {
-	t.equal( typeof isComposite.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isComposite.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-composite/test/test.main.js b/lib/node_modules/@stdlib/assert/is-composite/test/test.main.js
index 3b15bc040403..a9a2636289e2 100644
--- a/lib/node_modules/@stdlib/assert/is-composite/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-composite/test/test.main.js
@@ -36,19 +36,19 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a composite number', function test( t ) {
-	t.equal( isComposite( 4 ), true, 'returns expected value' );
-	t.equal( isComposite( 6 ), true, 'returns expected value' );
-	t.equal( isComposite( 8 ), true, 'returns expected value' );
-	t.equal( isComposite( 9 ), true, 'returns expected value' );
-	t.equal( isComposite( 10 ), true, 'returns expected value' );
-	t.equal( isComposite( 15 ), true, 'returns expected value' );
-
-	t.equal( isComposite( new Number( 4 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 6 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 8 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 9 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 10 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 15 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isComposite( 4 ), true, 'returns expected value' );
+	t.strictEqual( isComposite( 6 ), true, 'returns expected value' );
+	t.strictEqual( isComposite( 8 ), true, 'returns expected value' );
+	t.strictEqual( isComposite( 9 ), true, 'returns expected value' );
+	t.strictEqual( isComposite( 10 ), true, 'returns expected value' );
+	t.strictEqual( isComposite( 15 ), true, 'returns expected value' );
+
+	t.strictEqual( isComposite( new Number( 4 ) ), true, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 6 ) ), true, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 8 ) ), true, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 9 ) ), true, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 10 ) ), true, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 15 ) ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -59,22 +59,22 @@ tape( 'the function returns `false` if provided a prime number', function test(
 	var i;
 	var j;
 
-	t.equal( isComposite( 2 ), false, 'returns expected value' );
-	t.equal( isComposite( 3 ), false, 'returns expected value' );
-	t.equal( isComposite( 5 ), false, 'returns expected value' );
-	t.equal( isComposite( 7 ), false, 'returns expected value' );
+	t.strictEqual( isComposite( 2 ), false, 'returns expected value' );
+	t.strictEqual( isComposite( 3 ), false, 'returns expected value' );
+	t.strictEqual( isComposite( 5 ), false, 'returns expected value' );
+	t.strictEqual( isComposite( 7 ), false, 'returns expected value' );
 
-	t.equal( isComposite( new Number( 2 ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 3 ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 5 ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 7 ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isComposite( new Number( 2 ) ), false, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 3 ) ), false, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 5 ) ), false, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 7 ) ), false, 'returns expected value' );
 
 	N = PRIMES.length - 1;
 	for ( i = 0; i < 1e3; i++ ) {
 		j = discreteUniform( 0, N );
 		p = PRIMES[ j ];
-		t.equal( isComposite( p ), false, 'returns expected value for '+p );
-		t.equal( isComposite( new Number( p ) ), false, 'returns expected value for Number('+p+')' ); // eslint-disable-line no-new-wrappers
+		t.strictEqual( isComposite( p ), false, 'returns expected value for '+p );
+		t.strictEqual( isComposite( new Number( p ) ), false, 'returns expected value for Number('+p+')' );
 	}
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'the function returns `false` if not provided a composite number', functio
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComposite( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComposite( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-composite/test/test.object.js b/lib/node_modules/@stdlib/assert/is-composite/test/test.object.js
index c37f9a15f9ff..d5557cea1067 100644
--- a/lib/node_modules/@stdlib/assert/is-composite/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-composite/test/test.object.js
@@ -36,12 +36,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object whose value is a composite number', function test( t ) {
-	t.equal( isComposite( new Number( 4 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 6 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 8 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 9 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 10 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 15 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isComposite( new Number( 4 ) ), true, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 6 ) ), true, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 8 ) ), true, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 9 ) ), true, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 10 ) ), true, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 15 ) ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -52,24 +52,24 @@ tape( 'the function returns `false` if provided a number object whose value is a
 	var i;
 	var j;
 
-	t.equal( isComposite( new Number( 2 ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 3 ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 5 ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 7 ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isComposite( new Number( 2 ) ), false, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 3 ) ), false, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 5 ) ), false, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 7 ) ), false, 'returns expected value' );
 
 	N = PRIMES.length - 1;
 	for ( i = 0; i < 1e3; i++ ) {
 		j = discreteUniform( 0, N );
 		p = PRIMES[ j ];
-		t.equal( isComposite( new Number( p ) ), false, 'returns expected value for Number('+p+')' ); // eslint-disable-line no-new-wrappers
+		t.strictEqual( isComposite( new Number( p ) ), false, 'returns expected value for Number('+p+')' );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive composite number', function test( t ) {
-	t.equal( isComposite( 6.0 ), false, 'returns false' );
-	t.equal( isComposite( 10.0 ), false, 'returns false' );
-	t.equal( isComposite( 49.0 ), false, 'returns false' );
+	t.strictEqual( isComposite( 6.0 ), false, 'returns false' );
+	t.strictEqual( isComposite( 10.0 ), false, 'returns false' );
+	t.strictEqual( isComposite( 49.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -79,9 +79,9 @@ tape( 'the function returns `false` if not provided a composite number', functio
 
 	values = [
 		'5',
-		new Number( 2.0 ), // eslint-disable-line no-new-wrappers
-		new Number( 3.0 ), // eslint-disable-line no-new-wrappers
-		new Number( 5.0 ), // eslint-disable-line no-new-wrappers
+		new Number( 2.0 ),
+		new Number( 3.0 ),
+		new Number( 5.0 ),
 		null,
 		true,
 		NaN,
@@ -95,7 +95,7 @@ tape( 'the function returns `false` if not provided a composite number', functio
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComposite( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComposite( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-composite/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-composite/test/test.primitive.js
index fd6341a0f392..b79a1435393c 100644
--- a/lib/node_modules/@stdlib/assert/is-composite/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-composite/test/test.primitive.js
@@ -36,12 +36,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive composite number', function test( t ) {
-	t.equal( isComposite( 4 ), true, 'returns expected value' );
-	t.equal( isComposite( 6 ), true, 'returns expected value' );
-	t.equal( isComposite( 8 ), true, 'returns expected value' );
-	t.equal( isComposite( 9 ), true, 'returns expected value' );
-	t.equal( isComposite( 10 ), true, 'returns expected value' );
-	t.equal( isComposite( 15 ), true, 'returns expected value' );
+	t.strictEqual( isComposite( 4 ), true, 'returns expected value' );
+	t.strictEqual( isComposite( 6 ), true, 'returns expected value' );
+	t.strictEqual( isComposite( 8 ), true, 'returns expected value' );
+	t.strictEqual( isComposite( 9 ), true, 'returns expected value' );
+	t.strictEqual( isComposite( 10 ), true, 'returns expected value' );
+	t.strictEqual( isComposite( 15 ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,24 +51,24 @@ tape( 'the function returns `false` if provided a primitive prime number', funct
 	var i;
 	var j;
 
-	t.equal( isComposite( 2 ), false, 'returns expected value' );
-	t.equal( isComposite( 3 ), false, 'returns expected value' );
-	t.equal( isComposite( 5 ), false, 'returns expected value' );
-	t.equal( isComposite( 7 ), false, 'returns expected value' );
+	t.strictEqual( isComposite( 2 ), false, 'returns expected value' );
+	t.strictEqual( isComposite( 3 ), false, 'returns expected value' );
+	t.strictEqual( isComposite( 5 ), false, 'returns expected value' );
+	t.strictEqual( isComposite( 7 ), false, 'returns expected value' );
 
 	N = PRIMES.length - 1;
 	for ( i = 0; i < 1e3; i++ ) {
 		j = discreteUniform( 0, N );
 		p = PRIMES[ j ];
-		t.equal( isComposite( p ), false, 'returns expected value for '+p );
+		t.strictEqual( isComposite( p ), false, 'returns expected value for '+p );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object whose value is a composite number', function test( t ) {
-	t.equal( isComposite( new Number( 6.0 ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 8.0 ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isComposite( new Number( 10.0 ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isComposite( new Number( 6.0 ) ), false, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 8.0 ) ), false, 'returns expected value' );
+	t.strictEqual( isComposite( new Number( 10.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -90,7 +90,7 @@ tape( 'the function returns `false` if not provided a composite number', functio
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isComposite( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isComposite( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-configurable-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-configurable-property-in/test/test.js
index 3600f30c9ebc..2ee19fd3d877 100644
--- a/lib/node_modules/@stdlib/assert/is-configurable-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-configurable-property-in/test/test.js
@@ -46,16 +46,16 @@ tape( 'the function returns `true` if an object property is configurable', funct
 		'a': 'b'
 	};
 	bool = isConfigurablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isConfigurablePropertyIn( [ 1, 2, 3 ], '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isConfigurablePropertyIn( [ 1, 2, 3 ], 1 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isConfigurablePropertyIn( new Foo(), 'bar' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -66,7 +66,7 @@ tape( 'the function returns `true` if an object property is configurable', funct
 	});
 
 	bool = isConfigurablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -75,13 +75,13 @@ tape( 'the function returns `true` if provided a configurable inherited property
 	var bool;
 
 	bool = isConfigurablePropertyIn( {}, 'hasOwnProperty' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isConfigurablePropertyIn( {}, 'toString' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isConfigurablePropertyIn( {}, 'constructor' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -90,10 +90,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isConfigurablePropertyIn( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isConfigurablePropertyIn( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -114,13 +114,13 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isConfigurablePropertyIn( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isConfigurablePropertyIn( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isConfigurablePropertyIn( [ 'a' ], 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function returns `false` if provided a non-configurable inherited pro
 	obj = new Foo();
 
 	bool = isConfigurablePropertyIn( obj, 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -152,10 +152,10 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isConfigurablePropertyIn( 'beep', 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isConfigurablePropertyIn( 'beep', 'toString' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-configurable-property/test/test.js b/lib/node_modules/@stdlib/assert/is-configurable-property/test/test.js
index eb9f158ef8b5..9d60e1dc91bd 100644
--- a/lib/node_modules/@stdlib/assert/is-configurable-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-configurable-property/test/test.js
@@ -46,16 +46,16 @@ tape( 'the function returns `true` if an object property is configurable', funct
 		'a': 'b'
 	};
 	bool = isConfigurableProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isConfigurableProperty( [ 1, 2, 3 ], '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isConfigurableProperty( [ 1, 2, 3 ], 1 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isConfigurableProperty( new Foo(), 'bar' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -66,7 +66,7 @@ tape( 'the function returns `true` if an object property is configurable', funct
 	});
 
 	bool = isConfigurableProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -75,10 +75,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isConfigurableProperty( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isConfigurableProperty( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -99,13 +99,13 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isConfigurableProperty( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isConfigurableProperty( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isConfigurableProperty( [ 'a' ], 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -114,13 +114,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isConfigurableProperty( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isConfigurableProperty( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isConfigurableProperty( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isConfigurableProperty( 'beep', 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.js b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.js
index dc9dbb63482b..f702c557f16b 100644
--- a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test primitives', function test( t ) {
-	t.equal( typeof isCubeNumber.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isCubeNumber.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test objects', function test( t ) {
-	t.equal( typeof isCubeNumber.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isCubeNumber.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.main.js
index 4cc7257729ca..feb8533ec6b5 100644
--- a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a cube number', function test( t ) {
-	t.equal( isCubeNumber( 8.0 ), true, 'returns true' );
-	t.equal( isCubeNumber( new Number( 8.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isCubeNumber( 8.0 ), true, 'returns true' );
+	t.strictEqual( isCubeNumber( new Number( 8.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a cube number', function tes
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCubeNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isCubeNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.object.js
index 7a93164df100..ec03dfbbd595 100644
--- a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a cube number', function test( t ) {
-	t.equal( isCubeNumber( new Number( 8.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isCubeNumber( new Number( 8.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive cube number', function test( t ) {
-	t.equal( isCubeNumber( 8.0 ), false, 'returns false' );
+	t.strictEqual( isCubeNumber( 8.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -49,7 +49,7 @@ tape( 'the function returns `false` if not provided a cube number', function tes
 
 	values = [
 		'5',
-		new Number( 5.0 ), // eslint-disable-line no-new-wrappers
+		new Number( 5.0 ),
 		null,
 		true,
 		NaN,
@@ -63,7 +63,7 @@ tape( 'the function returns `false` if not provided a cube number', function tes
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCubeNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isCubeNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.primitive.js
index a9c509a271c9..154b87a65b44 100644
--- a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive cube number', function test( t ) {
-	t.equal( isCubeNumber( 8.0 ), true, 'returns true' );
+	t.strictEqual( isCubeNumber( 8.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object', function test( t ) {
-	t.equal( isCubeNumber( new Number( 8.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isCubeNumber( new Number( 8.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'the function returns `false` if not provided a cube number', function tes
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCubeNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isCubeNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-current-year/test/test.js b/lib/node_modules/@stdlib/assert/is-current-year/test/test.js
index 5e960de20404..4c98f002d0d2 100644
--- a/lib/node_modules/@stdlib/assert/is-current-year/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-current-year/test/test.js
@@ -35,10 +35,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided the current year', function test( t ) {
 	var bool = isCurrentYear( currentYear() );
-	t.equal( bool, true, 'returns expected value' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isCurrentYear( new Date() );
-	t.equal( bool, true, 'returns expected value' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -64,7 +64,7 @@ tape( 'the function returns `false` if provided a value which is not the current
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isCurrentYear( values[i] ), false, 'returns expected value when provided '+values[i] );
+		t.strictEqual( isCurrentYear( values[i] ), false, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-darwin/test/test.js b/lib/node_modules/@stdlib/assert/is-darwin/test/test.js
index 56ec55c110b2..5f4f51ef5525 100644
--- a/lib/node_modules/@stdlib/assert/is-darwin/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-darwin/test/test.js
@@ -39,7 +39,7 @@ tape( 'the main export is `true` if the current process is running on Darwin', f
 	IS_DARWIN = proxyquire( './../lib', {
 		'@stdlib/os/platform': 'darwin'
 	});
-	t.equal( IS_DARWIN, true, 'is true' );
+	t.strictEqual( IS_DARWIN, true, 'is true' );
 	t.end();
 });
 
@@ -49,6 +49,6 @@ tape( 'the main export is `false` if the current process is not running on Darwi
 	IS_DARWIN = proxyquire( './../lib', {
 		'@stdlib/os/platform': 'linux'
 	});
-	t.equal( IS_DARWIN, false, 'is false' );
+	t.strictEqual( IS_DARWIN, false, 'is false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-data-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-data-property-in/test/test.js
index 4bc77622e597..98e3e635adb9 100644
--- a/lib/node_modules/@stdlib/assert/is-data-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-data-property-in/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property has a data descriptor',
 		'a': 'b'
 	};
 	bool = isDataPropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDataPropertyIn( [ 1, 2, 3 ], '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDataPropertyIn( [ 1, 2, 3 ], 1 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDataPropertyIn( new Foo(), 'bar' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDataPropertyIn( [ 'a' ], 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property has a data descriptor',
 	});
 
 	bool = isDataPropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -78,10 +78,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isDataPropertyIn( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isDataPropertyIn( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isDataPropertyIn( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -106,7 +106,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isDataPropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -123,13 +123,13 @@ tape( 'the function returns `true` if provided an inherited property having a da
 	var bool;
 
 	bool = isDataPropertyIn( {}, 'hasOwnProperty' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDataPropertyIn( {}, 'toString' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDataPropertyIn( {}, 'constructor' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function returns `false` if provided an inherited property not having
 	obj = new Foo();
 
 	bool = isDataPropertyIn( obj, 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -169,7 +169,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isDataPropertyIn( 'beep', 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-data-property/test/test.js b/lib/node_modules/@stdlib/assert/is-data-property/test/test.js
index d998f6dc0218..acb62aefb0a2 100644
--- a/lib/node_modules/@stdlib/assert/is-data-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-data-property/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property has a data descriptor',
 		'a': 'b'
 	};
 	bool = isDataProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDataProperty( [ 1, 2, 3 ], '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDataProperty( [ 1, 2, 3 ], 1 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDataProperty( new Foo(), 'bar' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDataProperty( [ 'a' ], 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property has a data descriptor',
 	});
 
 	bool = isDataProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -78,10 +78,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isDataProperty( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isDataProperty( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isDataProperty( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -106,7 +106,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isDataProperty( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -123,13 +123,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isDataProperty( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isDataProperty( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isDataProperty( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isDataProperty( 'beep', 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-docker/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-docker/test/test.browser.js
index e0959b222814..32c68b3931a2 100644
--- a/lib/node_modules/@stdlib/assert/is-docker/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-docker/test/test.browser.js
@@ -33,6 +33,6 @@ tape( 'main export is a boolean', function test( t ) {
 });
 
 tape( 'the exported value is always `false`', function test( t ) {
-	t.equal( IS_DOCKER, false, 'returns false' );
+	t.strictEqual( IS_DOCKER, false, 'returns false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-domain-name/test/test.js b/lib/node_modules/@stdlib/assert/is-domain-name/test/test.js
index 1b61aaad61d4..50563791e3ee 100644
--- a/lib/node_modules/@stdlib/assert/is-domain-name/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-domain-name/test/test.js
@@ -37,22 +37,22 @@ tape( 'the function returns `true` if provided a valid domain name', function te
 	var bool;
 
 	bool = isDomainName( 'example.com' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDomainName( 'foo.example.com' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDomainName( 'foo.bar.example.com' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDomainName( 'foo.bar.baz.example.com' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDomainName( 'foo.bar.baz.qux.example.com' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isDomainName( 'foo.bar.baz.qux.quux.example.com' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -96,7 +96,7 @@ tape( 'the function returns `false` if provided an invalid domain name', functio
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isDomainName( values[i] );
-		t.equal( bool, false, 'returns false when provided '+values[i] );
+		t.strictEqual( bool, false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isDomainName( values[i] );
-		t.equal( bool, false, 'returns false when provided '+values[i] );
+		t.strictEqual( bool, false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-duration-string/test/test.js b/lib/node_modules/@stdlib/assert/is-duration-string/test/test.js
index 9a978334ef1d..381a4381b3c8 100644
--- a/lib/node_modules/@stdlib/assert/is-duration-string/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-duration-string/test/test.js
@@ -51,7 +51,7 @@ tape( 'the function returns `true` if provided a duration string', function test
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isDurationString( values[i] ), true, 'returns true when provided '+values[i] );
+		t.strictEqual( isDurationString( values[i] ), true, 'returns true when provided '+values[i] );
 	}
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns `false` if provided a non-duration string', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isDurationString( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isDurationString( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
@@ -96,7 +96,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isDurationString( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isDurationString( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-electron-main/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-electron-main/test/test.browser.js
index 6472ea435983..058b06f03a7b 100644
--- a/lib/node_modules/@stdlib/assert/is-electron-main/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-electron-main/test/test.browser.js
@@ -33,6 +33,6 @@ tape( 'main export is a boolean', function test( t ) {
 });
 
 tape( 'the exported value is always `false`', function test( t ) {
-	t.equal( IS_ELECTRON_MAIN, false, 'returns false' );
+	t.strictEqual( IS_ELECTRON_MAIN, false, 'returns false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-electron-renderer/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-electron-renderer/test/test.browser.js
index 77bec250cfeb..ce8d643a3266 100644
--- a/lib/node_modules/@stdlib/assert/is-electron-renderer/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-electron-renderer/test/test.browser.js
@@ -33,6 +33,6 @@ tape( 'main export is a boolean', function test( t ) {
 });
 
 tape( 'the exported value is always `false`', function test( t ) {
-	t.equal( IS_ELECTRON_RENDERER, false, 'returns false' );
+	t.strictEqual( IS_ELECTRON_RENDERER, false, 'returns false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-electron/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-electron/test/test.browser.js
index bb3bd9474799..4155bdd96611 100644
--- a/lib/node_modules/@stdlib/assert/is-electron/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-electron/test/test.browser.js
@@ -33,6 +33,6 @@ tape( 'main export is a boolean', function test( t ) {
 });
 
 tape( 'the exported value is always `false`', function test( t ) {
-	t.equal( IS_ELECTRON, false, 'returns false' );
+	t.strictEqual( IS_ELECTRON, false, 'returns false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-email-address/test/test.js b/lib/node_modules/@stdlib/assert/is-email-address/test/test.js
index 3abb5c309f93..ba174dca5cd0 100644
--- a/lib/node_modules/@stdlib/assert/is-email-address/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-email-address/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` when provided an email address (equals a string including the `@` character)', function test( t ) {
-	t.equal( isEmail( 'beep@boop.com' ), true, 'returns true' );
+	t.strictEqual( isEmail( 'beep@boop.com' ), true, 'returns true' );
 	t.end();
 });
 
@@ -56,7 +56,7 @@ tape( 'the function returns `false` when not provided an email address', functio
 		function noop() {}
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isEmail( values[ i ] ), false, 'returns false' );
+		t.strictEqual( isEmail( values[ i ] ), false, 'returns false' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-enumerable-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-enumerable-property-in/test/test.js
index d21d0e42d684..dfa256514066 100644
--- a/lib/node_modules/@stdlib/assert/is-enumerable-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-enumerable-property-in/test/test.js
@@ -46,16 +46,16 @@ tape( 'the function returns `true` if an object property is enumerable', functio
 		'a': 'b'
 	};
 	bool = isEnumerablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isEnumerablePropertyIn( [ 1, 2, 3 ], '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isEnumerablePropertyIn( [ 1, 2, 3 ], 1 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isEnumerablePropertyIn( new Foo(), 'bar' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -66,7 +66,7 @@ tape( 'the function returns `true` if an object property is enumerable', functio
 	});
 
 	bool = isEnumerablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns `true` if provided an enumerable inherited property'
 	obj = new Foo();
 
 	bool = isEnumerablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -98,10 +98,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isEnumerablePropertyIn( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isEnumerablePropertyIn( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -122,13 +122,13 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isEnumerablePropertyIn( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isEnumerablePropertyIn( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isEnumerablePropertyIn( [ 'a' ], 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -151,16 +151,16 @@ tape( 'the function returns `false` if provided a non-enumerable inherited prope
 	obj = new Foo();
 
 	bool = isEnumerablePropertyIn( obj, 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isEnumerablePropertyIn( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isEnumerablePropertyIn( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isEnumerablePropertyIn( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -169,10 +169,10 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isEnumerablePropertyIn( 'beep', 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isEnumerablePropertyIn( 'beep', 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-enumerable-property/test/test.js b/lib/node_modules/@stdlib/assert/is-enumerable-property/test/test.js
index e08a22341edf..057e7932ffef 100644
--- a/lib/node_modules/@stdlib/assert/is-enumerable-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-enumerable-property/test/test.js
@@ -37,10 +37,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isEnumerableProperty( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isEnumerableProperty( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -53,19 +53,19 @@ tape( 'the function returns `true` if an object property is enumerable', functio
 		return this;
 	}
 
-	bool = isEnumerableProperty( {
+	bool = isEnumerableProperty({
 		'a': 'b'
 	}, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isEnumerableProperty( [ 1, 2, 3 ], '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isEnumerableProperty( [ 1, 2, 3 ], 1 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isEnumerableProperty( new Foo(), 'bar' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -79,10 +79,10 @@ tape( 'the function returns `false` if an object property is not enumerable', fu
 	};
 
 	bool = isEnumerableProperty( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isEnumerableProperty( [ 'a' ], 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -91,13 +91,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isEnumerableProperty( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isEnumerableProperty( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isEnumerableProperty( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isEnumerableProperty( 'beep', '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -120,19 +120,19 @@ tape( 'addresses `propertyIsEnumerable` bug in Node v0.10 when provided a `strin
 	});
 
 	bool = isEnumerableProperty( 'beep', '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isEnumerableProperty( 'beep', 1 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isEnumerableProperty( 'beep', 'boop' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isEnumerableProperty( 'beep', '10' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isEnumerableProperty( 'beep', 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -145,13 +145,13 @@ tape( 'property values are coerced to strings', function test( t ) {
 		'null': false
 	};
 	bool = isEnumerableProperty( obj, null );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {
 		'[object Object]': false
 	};
 	bool = isEnumerableProperty( obj, {} );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-even/test/test.js b/lib/node_modules/@stdlib/assert/is-even/test/test.js
index e41a8feacd07..5c5c4de0536e 100644
--- a/lib/node_modules/@stdlib/assert/is-even/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-even/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive even number', function test( t ) {
-	t.equal( typeof isEven.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isEven.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having an even value', function test( t ) {
-	t.equal( typeof isEven.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isEven.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-even/test/test.main.js b/lib/node_modules/@stdlib/assert/is-even/test/test.main.js
index f3812f46ac8e..3ceba1cefdfb 100644
--- a/lib/node_modules/@stdlib/assert/is-even/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-even/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an even number', function test( t ) {
-	t.equal( isEven( 4 ), true, 'returns true' );
-	t.equal( isEven( new Number( 4 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isEven( 4 ), true, 'returns true' );
+	t.strictEqual( isEven( new Number( 4 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if not provided an even number', function te
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isEven( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isEven( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-even/test/test.object.js b/lib/node_modules/@stdlib/assert/is-even/test/test.object.js
index 8e746c8c9c46..486868bd657c 100644
--- a/lib/node_modules/@stdlib/assert/is-even/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-even/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an even number object', function test( t ) {
-	t.equal( isEven( new Number( 4 ) ), true, 'returns true' );
+	t.strictEqual( isEven( new Number( 4 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is even', function test( t ) {
-	t.equal( isEven( 4 ), false, 'returns false' );
+	t.strictEqual( isEven( 4 ), false, 'returns false' );
 	t.end();
 });
 
@@ -62,7 +62,7 @@ tape( 'the function returns `false` if not provided an even number', function te
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isEven( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isEven( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-even/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-even/test/test.primitive.js
index c921a8e564f0..b527a31d20d7 100644
--- a/lib/node_modules/@stdlib/assert/is-even/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-even/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive even number', function test( t ) {
-	t.equal( isEven( -4.0 ), true, 'returns true' );
+	t.strictEqual( isEven( -4.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number is even', function test( t ) {
-	t.equal( isEven( new Number( 4.0 ) ), false, 'returns false' );
+	t.strictEqual( isEven( new Number( 4.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -62,7 +62,7 @@ tape( 'the function returns `false` if not provided an even number', function te
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isEven( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isEven( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-float32matrix-like/test/test.js b/lib/node_modules/@stdlib/assert/is-float32matrix-like/test/test.js
index 3b1a5ad6b02f..20c191de3004 100644
--- a/lib/node_modules/@stdlib/assert/is-float32matrix-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float32matrix-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 2-dimensional ndarray containing single-precision floating-point numbers', function test( t ) {
 	var arr = ndarray( 'float32', new Float32Array( [ 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.equal( isFloat32MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat32MatrixLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isFloat32MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat32MatrixLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -87,7 +87,7 @@ tape( 'the function returns `false` if not provided a 2-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isFloat32MatrixLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isFloat32MatrixLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-float32ndarray-like/test/test.js b/lib/node_modules/@stdlib/assert/is-float32ndarray-like/test/test.js
index ea3c360fc4d6..2c2374a5b9de 100644
--- a/lib/node_modules/@stdlib/assert/is-float32ndarray-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float32ndarray-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided an ndarray containing single-precision floating-point numbers', function test( t ) {
 	var arr = ndarray( 'float32', new Float32Array( [ 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.equal( isFloat32ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat32ndarrayLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided an ndarray-like object containing
 		'set': noop
 	};
 
-	t.equal( isFloat32ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat32ndarrayLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns `false` if not provided an ndarray-like object conta
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isFloat32ndarrayLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isFloat32ndarrayLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-float32vector-like/test/test.js b/lib/node_modules/@stdlib/assert/is-float32vector-like/test/test.js
index 63be6f28e89e..53d0701c1761 100644
--- a/lib/node_modules/@stdlib/assert/is-float32vector-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float32vector-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 1-dimensional ndarray containing single-precision floating-point numbers', function test( t ) {
 	var arr = ndarray( 'float32', new Float32Array( [ 0, 0, 0, 0 ] ), [ 4 ], [ 1 ], 0, 'row-major' );
 
-	t.equal( isFloat32VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat32VectorLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 1-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isFloat32VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat32VectorLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -87,7 +87,7 @@ tape( 'the function returns `false` if not provided a 1-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isFloat32VectorLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isFloat32VectorLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-float64matrix-like/test/test.js b/lib/node_modules/@stdlib/assert/is-float64matrix-like/test/test.js
index 3dc8f68ee42a..57249128186e 100644
--- a/lib/node_modules/@stdlib/assert/is-float64matrix-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float64matrix-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 2-dimensional ndarray containing double-precision floating-point numbers', function test( t ) {
 	var arr = ndarray( 'float64', new Float64Array( [ 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.equal( isFloat64MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat64MatrixLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isFloat64MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat64MatrixLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -87,7 +87,7 @@ tape( 'the function returns `false` if not provided a 2-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isFloat64MatrixLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isFloat64MatrixLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-float64ndarray-like/test/test.js b/lib/node_modules/@stdlib/assert/is-float64ndarray-like/test/test.js
index e49668b76a92..47c8ad216a4a 100644
--- a/lib/node_modules/@stdlib/assert/is-float64ndarray-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float64ndarray-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided an ndarray containing double-precision floating-point numbers', function test( t ) {
 	var arr = ndarray( 'float64', new Float64Array( [ 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.equal( isFloat64ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat64ndarrayLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided an ndarray-like object containing
 		'set': noop
 	};
 
-	t.equal( isFloat64ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat64ndarrayLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns `false` if not provided an ndarray-like object conta
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isFloat64ndarrayLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isFloat64ndarrayLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-float64vector-like/test/test.js b/lib/node_modules/@stdlib/assert/is-float64vector-like/test/test.js
index 271c2022435a..41ac98d5a8a8 100644
--- a/lib/node_modules/@stdlib/assert/is-float64vector-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float64vector-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 1-dimensional ndarray containing double-precision floating-point numbers', function test( t ) {
 	var arr = ndarray( 'float64', new Float64Array( [ 0, 0, 0, 0 ] ), [ 4 ], [ 1 ], 0, 'row-major' );
 
-	t.equal( isFloat64VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat64VectorLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 1-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isFloat64VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat64VectorLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -87,7 +87,7 @@ tape( 'the function returns `false` if not provided a 1-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isFloat64VectorLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isFloat64VectorLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-generator-object-like/test/es2015-generator/index.js b/lib/node_modules/@stdlib/assert/is-generator-object-like/test/es2015-generator/index.js
index a856869a9bad..743e42fedfb0 100644
--- a/lib/node_modules/@stdlib/assert/is-generator-object-like/test/es2015-generator/index.js
+++ b/lib/node_modules/@stdlib/assert/is-generator-object-like/test/es2015-generator/index.js
@@ -46,9 +46,9 @@ function* generateID() {
 
 tape( 'the function returns `true` if provided a generator object', function test( t ) {
 	var gen = generateID();
-	t.equal( isGeneratorObject( gen ), true, 'returns true' );
+	t.strictEqual( isGeneratorObject( gen ), true, 'returns true' );
 
 	gen = new GeneratorFunction( 'idx', 'yield idx' )();
-	t.equal( isGeneratorObject( gen ), true, 'returns true' );
+	t.strictEqual( isGeneratorObject( gen ), true, 'returns true' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-generator-object-like/test/test.js b/lib/node_modules/@stdlib/assert/is-generator-object-like/test/test.js
index f0889f0b3c6b..264fad06dba9 100644
--- a/lib/node_modules/@stdlib/assert/is-generator-object-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-generator-object-like/test/test.js
@@ -55,7 +55,7 @@ tape( 'the function returns `false` if not provided a generator object-like valu
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isGeneratorObject( values[i] ), false, 'returns false' );
+		t.strictEqual( isGeneratorObject( values[i] ), false, 'returns false' );
 	}
 	t.end();
 });
@@ -66,7 +66,7 @@ tape( 'the function returns `true` if provided a generator object-like value', f
 		'return': noop,
 		'throw': noop
 	};
-	t.equal( isGeneratorObject( gen ), true, 'returns true' );
+	t.strictEqual( isGeneratorObject( gen ), true, 'returns true' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-generator-object/test/es2015-generator/index.js b/lib/node_modules/@stdlib/assert/is-generator-object/test/es2015-generator/index.js
index a856869a9bad..743e42fedfb0 100644
--- a/lib/node_modules/@stdlib/assert/is-generator-object/test/es2015-generator/index.js
+++ b/lib/node_modules/@stdlib/assert/is-generator-object/test/es2015-generator/index.js
@@ -46,9 +46,9 @@ function* generateID() {
 
 tape( 'the function returns `true` if provided a generator object', function test( t ) {
 	var gen = generateID();
-	t.equal( isGeneratorObject( gen ), true, 'returns true' );
+	t.strictEqual( isGeneratorObject( gen ), true, 'returns true' );
 
 	gen = new GeneratorFunction( 'idx', 'yield idx' )();
-	t.equal( isGeneratorObject( gen ), true, 'returns true' );
+	t.strictEqual( isGeneratorObject( gen ), true, 'returns true' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-generator-object/test/test.js b/lib/node_modules/@stdlib/assert/is-generator-object/test/test.js
index 25d8801d44df..41708047e531 100644
--- a/lib/node_modules/@stdlib/assert/is-generator-object/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-generator-object/test/test.js
@@ -54,7 +54,7 @@ tape( 'the function returns `false` if not provided a generator object', functio
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isGeneratorObject( values[i] ), false, 'returns false' );
+		t.strictEqual( isGeneratorObject( values[i] ), false, 'returns false' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-integer-array/test/test.js b/lib/node_modules/@stdlib/assert/is-integer-array/test/test.js
index 1ab167a0d84c..d387d92dd876 100644
--- a/lib/node_modules/@stdlib/assert/is-integer-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-integer-array/test/test.js
@@ -37,20 +37,20 @@ tape( 'the function tests for an array-like object containing only integer value
 	var arr;
 
 	arr = [ 5, new Number( 5 ), -3 ];
-	t.equal( isIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isIntegerArray( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': 2,
 		'1': 1
 	};
-	t.equal( isIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isIntegerArray( arr ), true, 'returns true' );
 
 	arr = [ 5.0, 2.3, 11.1 ];
-	t.equal( isIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isIntegerArray( arr ), false, 'returns false' );
 
 	arr = [ 5.0, '3', null ];
-	t.equal( isIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isIntegerArray( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -59,17 +59,17 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ 5, -0, 0 ];
-	t.equal( isIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isIntegerArray.primitives( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': 1,
 		'1': -3
 	};
-	t.equal( isIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isIntegerArray.primitives( arr ), true, 'returns true' );
 
 	arr = [ new Number( 5 ), 1, 1 ];
-	t.equal( isIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isIntegerArray.primitives( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -78,20 +78,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( 5 ), new Number( -0 ), new Number( 0 ) ];
-	t.equal( isIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isIntegerArray.objects( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 2 ),
 		'1': new Number( -3 )
 	};
-	t.equal( isIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isIntegerArray.objects( arr ), true, 'returns true' );
 
 	arr = [ new Number( 5 ), 1, 1 ];
-	t.equal( isIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isIntegerArray.objects( arr ), false, 'returns false' );
 
 	arr = [ -5, 1, 1 ];
-	t.equal( isIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isIntegerArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-integer/test/test.js b/lib/node_modules/@stdlib/assert/is-integer/test/test.js
index 1bd86419ce87..7d1fe8c77b33 100644
--- a/lib/node_modules/@stdlib/assert/is-integer/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-integer/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive number having an integer value', function test( t ) {
-	t.equal( typeof isInteger.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isInteger.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having an integer value', function test( t ) {
-	t.equal( typeof isInteger.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isInteger.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-integer/test/test.main.js b/lib/node_modules/@stdlib/assert/is-integer/test/test.main.js
index 287aef03857f..c274106f580e 100644
--- a/lib/node_modules/@stdlib/assert/is-integer/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-integer/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having an integer value', function test( t ) {
-	t.equal( isInteger( 5 ), true, 'returns true' );
-	t.equal( isInteger( new Number( 5 ) ), true, 'returns true' );
+	t.strictEqual( isInteger( 5 ), true, 'returns true' );
+	t.strictEqual( isInteger( new Number( 5 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -55,7 +55,7 @@ tape( 'the function returns `false` if not provided a number having an integer v
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-integer/test/test.object.js b/lib/node_modules/@stdlib/assert/is-integer/test/test.object.js
index 2b59d4c94ec1..f5281844f50c 100644
--- a/lib/node_modules/@stdlib/assert/is-integer/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-integer/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having an integer value', function test( t ) {
-	t.equal( isInteger( new Number( 5 ) ), true, 'returns true' );
+	t.strictEqual( isInteger( new Number( 5 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is an integer value', function test( t ) {
-	t.equal( isInteger( 3.0 ), false, 'returns false' );
+	t.strictEqual( isInteger( 3.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-integer/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-integer/test/test.primitive.js
index ade278aa262b..91e381a8755d 100644
--- a/lib/node_modules/@stdlib/assert/is-integer/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-integer/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having an integer value', function test( t ) {
-	t.equal( isInteger( -3.0 ), true, 'returns true' );
+	t.strictEqual( isInteger( -3.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has an integer value', function test( t ) {
-	t.equal( isInteger( new Number( 5.0 ) ), false, 'returns false' );
+	t.strictEqual( isInteger( new Number( 5.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-iterable-like/test/test.js b/lib/node_modules/@stdlib/assert/is-iterable-like/test/test.js
index 8ea8afd10033..7fd58d98e298 100644
--- a/lib/node_modules/@stdlib/assert/is-iterable-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-iterable-like/test/test.js
@@ -50,14 +50,14 @@ tape( 'the function returns `false` if not provided an iterable-like value', fun
 		function noop() {}
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isIterableLike( values[i] ), false, 'returns expected value when provided '+values[i] );
+		t.strictEqual( isIterableLike( values[i] ), false, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an iterable-like value (ES2015+/ES6+)', function test( t ) {
 	if ( hasIteratorSymbolSupport() ) {
-		t.equal( isIterableLike( [] ), true, 'returns expected value' );
+		t.strictEqual( isIterableLike( [] ), true, 'returns expected value' );
 	} else {
 		t.ok( true, 'environment lacks iterator symbol support' );
 	}
@@ -86,7 +86,7 @@ tape( 'in non-ES2015+/ES6+ environments, the function always returns `false`', f
 		function noop() {}
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isIterableLike( values[i] ), false, 'returns expected value when provided '+values[i] );
+		t.strictEqual( isIterableLike( values[i] ), false, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/assert/is-iterator-like/test/test.js b/lib/node_modules/@stdlib/assert/is-iterator-like/test/test.js
index 8704917a3bbc..5f1ce628802b 100644
--- a/lib/node_modules/@stdlib/assert/is-iterator-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-iterator-like/test/test.js
@@ -50,7 +50,7 @@ tape( 'the function returns `false` if not provided an iterator-like value', fun
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isIteratorLike( values[i] ), false, 'returns expected value when provided '+values[i] );
+		t.strictEqual( isIteratorLike( values[i] ), false, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
@@ -61,11 +61,11 @@ tape( 'the function returns `true` if provided an iterator-like value', function
 	it = {
 		'next': noop
 	};
-	t.equal( isIteratorLike( it ), true, 'returns expected value' );
+	t.strictEqual( isIteratorLike( it ), true, 'returns expected value' );
 
 	it = mock;
 	it.next = noop;
-	t.equal( isIteratorLike( it ), true, 'returns expected value' );
+	t.strictEqual( isIteratorLike( it ), true, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/assert/is-json/test/test.js b/lib/node_modules/@stdlib/assert/is-json/test/test.js
index ba4247426b2b..cbf7153a9f12 100644
--- a/lib/node_modules/@stdlib/assert/is-json/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-json/test/test.js
@@ -76,7 +76,7 @@ tape( 'the function returns `false` if not provided a parseable JSON string', fu
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isJSON( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isJSON( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-kebabcase/test/test.js b/lib/node_modules/@stdlib/assert/is-kebabcase/test/test.js
index 97f81e66bfab..9c91bd33c79a 100644
--- a/lib/node_modules/@stdlib/assert/is-kebabcase/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-kebabcase/test/test.js
@@ -43,13 +43,13 @@ tape( 'the function returns `true` if provided a string in kebab case', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isKebabcase( values[i] ), true, 'returns true when provided '+values[i] );
+		t.strictEqual( isKebabcase( values[i] ), true, 'returns true when provided '+values[i] );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an empty string', function test( t ) {
-	t.equal( isKebabcase( '' ), true, 'returns true' );
+	t.strictEqual( isKebabcase( '' ), true, 'returns true' );
 	t.end();
 });
 
@@ -66,7 +66,7 @@ tape( 'the function returns `false` if provided a string that is not in kebab ca
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isKebabcase( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isKebabcase( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isKebabcase( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isKebabcase( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-little-endian/test/test.js b/lib/node_modules/@stdlib/assert/is-little-endian/test/test.js
index 39be17d08818..a0d2e0048bde 100644
--- a/lib/node_modules/@stdlib/assert/is-little-endian/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-little-endian/test/test.js
@@ -41,7 +41,7 @@ tape( 'the boolean is `true` if an environment is little endian', function test(
 		}
 	});
 
-	t.equal( IS_LITTLE_ENDIAN, true, 'is little endian' );
+	t.strictEqual( IS_LITTLE_ENDIAN, true, 'is little endian' );
 
 	t.end();
 
@@ -58,7 +58,7 @@ tape( 'the boolean is `false` if an environment is not little endian (e.g., big
 		}
 	});
 
-	t.equal( IS_LITTLE_ENDIAN, false, 'is not little endian' );
+	t.strictEqual( IS_LITTLE_ENDIAN, false, 'is not little endian' );
 	t.end();
 
 	// Mock big endian byte order, where most significant bits are first...
diff --git a/lib/node_modules/@stdlib/assert/is-matrix-like/test/test.js b/lib/node_modules/@stdlib/assert/is-matrix-like/test/test.js
index 3324e2b7ba6a..80f8c3435504 100644
--- a/lib/node_modules/@stdlib/assert/is-matrix-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-matrix-like/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided a 2-dimensional ndarray', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isMatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isMatrixLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isMatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isMatrixLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'the function returns `false` if not provided a 2-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isMatrixLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isMatrixLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-mobile/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-mobile/test/test.browser.js
index 188b03513362..f977b4c05304 100644
--- a/lib/node_modules/@stdlib/assert/is-mobile/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-mobile/test/test.browser.js
@@ -48,7 +48,7 @@ tape( 'the function returns `true` if the current environment is a mobile device
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.equal( isMobile(), true, 'returns true' );
+	t.strictEqual( isMobile(), true, 'returns true' );
 	t.end();
 
 	function getGlobal() {
@@ -71,7 +71,7 @@ tape( 'the function returns `false` if the current environment is not a mobile d
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.equal( isMobile(), false, 'returns false' );
+	t.strictEqual( isMobile(), false, 'returns false' );
 	t.end();
 
 	function getGlobal() {
@@ -84,6 +84,6 @@ tape( 'the function returns `false` if the current environment is not a browser'
 		'@stdlib/assert/is-browser': false
 	});
 
-	t.equal( isMobile(), false, 'returns false' );
+	t.strictEqual( isMobile(), false, 'returns false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-multi-slice/test/test.js b/lib/node_modules/@stdlib/assert/is-multi-slice/test/test.js
index 8d2f3e5d8274..6508b63f5b76 100644
--- a/lib/node_modules/@stdlib/assert/is-multi-slice/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-multi-slice/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a MultiSlice instance', function test( t ) {
-	t.equal( isMultiSlice( new MultiSlice( new Slice( 0, 10, 1 ), null, 1 ) ), true, 'returns true' );
+	t.strictEqual( isMultiSlice( new MultiSlice( new Slice( 0, 10, 1 ), null, 1 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a MultiSlice instance', func
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isMultiSlice( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isMultiSlice( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-named-typed-tuple-like/test/test.js b/lib/node_modules/@stdlib/assert/is-named-typed-tuple-like/test/test.js
index 64c33359ba6f..5f918692eb0c 100644
--- a/lib/node_modules/@stdlib/assert/is-named-typed-tuple-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-named-typed-tuple-like/test/test.js
@@ -42,7 +42,7 @@ tape( 'the function returns `true` if provided a named typed tuple', function te
 	Point = namedtypedtuple( [ 'x', 'y' ] );
 	p = new Point();
 
-	t.equal( isNamedTypedTuple( p ), true, 'returns expected value' );
+	t.strictEqual( isNamedTypedTuple( p ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,7 +59,7 @@ tape( 'the function returns `true` if provided a named typed tuple-like object',
 	tuple.fields = [ 'x', 'y' ];
 	tuple.orderedFields = [ 'x', 'y' ];
 
-	t.equal( isNamedTypedTuple( tuple ), true, 'returns expected value' );
+	t.strictEqual( isNamedTypedTuple( tuple ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -81,7 +81,7 @@ tape( 'the function returns `false` if not provided a named typed tuple-like obj
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNamedTypedTuple( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNamedTypedTuple( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nan-array/test/test.js b/lib/node_modules/@stdlib/assert/is-nan-array/test/test.js
index 8134c2772c13..c51b6d07c58b 100644
--- a/lib/node_modules/@stdlib/assert/is-nan-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nan-array/test/test.js
@@ -38,23 +38,23 @@ tape( 'the function tests for an array-like object containing only `NaN` values'
 	var arr;
 
 	arr = [ NaN, new Number( NaN ), NaN ];
-	t.equal( isNaNArray( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray( arr ), true, 'returns true' );
 
 	arr = new Float64Array( [ NaN, NaN ] );
-	t.equal( isNaNArray( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': NaN,
 		'1': NaN
 	};
-	t.equal( isNaNArray( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray( arr ), true, 'returns true' );
 
 	arr = [ NaN, 3, NaN ];
-	t.equal( isNaNArray( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray( arr ), false, 'returns false' );
 
 	arr = [ NaN, null, NaN ];
-	t.equal( isNaNArray( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -63,23 +63,23 @@ tape( 'attached to the main export is a method to test for an array-like object
 	var arr;
 
 	arr = [ NaN, NaN, NaN ];
-	t.equal( isNaNArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray.primitives( arr ), true, 'returns true' );
 
 	arr = new Float64Array( [ NaN, NaN ] );
-	t.equal( isNaNArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray.primitives( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': NaN,
 		'1': NaN
 	};
-	t.equal( isNaNArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray.primitives( arr ), true, 'returns true' );
 
 	arr = [ new Number( NaN ), NaN, NaN ];
-	t.equal( isNaNArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray.primitives( arr ), false, 'returns false' );
 
 	arr = new Float64Array( [ 2.3, NaN ] );
-	t.equal( isNaNArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray.primitives( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -88,23 +88,23 @@ tape( 'attached to the main export is a method to test for an array-like object
 	var arr;
 
 	arr = [ NaN, NaN, NaN ];
-	t.equal( isNaNArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray.objects( arr ), false, 'returns false' );
 
 	arr = [ new Number( NaN ), NaN, NaN ];
-	t.equal( isNaNArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray.objects( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( NaN ),
 		'1': new Number( NaN )
 	};
-	t.equal( isNaNArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray.objects( arr ), true, 'returns true' );
 
 	arr = [ new Number( NaN ), new Number( NaN ), new Number( NaN ) ];
-	t.equal( isNaNArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray.objects( arr ), true, 'returns true' );
 
 	arr = new Float64Array( [ NaN, NaN, NaN ] );
-	t.equal( isNaNArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nan/test/test.js b/lib/node_modules/@stdlib/assert/is-nan/test/test.js
index bcf6db15353d..21196eba0289 100644
--- a/lib/node_modules/@stdlib/assert/is-nan/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nan/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a `NaN` primitive number', function test( t ) {
-	t.equal( typeof isnan.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isnan.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a value of `NaN`', function test( t ) {
-	t.equal( typeof isnan.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isnan.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nan/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nan/test/test.main.js
index c0e82fa229fb..530d155cb56a 100644
--- a/lib/node_modules/@stdlib/assert/is-nan/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nan/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `NaN`', function test( t ) {
-	t.equal( isnan( NaN ), true, 'returns true' );
-	t.equal( isnan( new Number( NaN ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isnan( NaN ), true, 'returns true' );
+	t.strictEqual( isnan( new Number( NaN ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `false` if not provided `NaN`', function test( t ) {
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isnan( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isnan( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nan/test/test.object.js b/lib/node_modules/@stdlib/assert/is-nan/test/test.object.js
index cab82719d008..f2a7ec958851 100644
--- a/lib/node_modules/@stdlib/assert/is-nan/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-nan/test/test.object.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a value of `NaN`', function test( t ) {
-	t.equal( isnan( new Number( NaN ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isnan( new Number( NaN ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number', function test( t ) {
-	t.equal( isnan( 3.14 ), false, 'returns false' );
-	t.equal( isnan( NaN ), false, 'returns false' );
+	t.strictEqual( isnan( 3.14 ), false, 'returns false' );
+	t.strictEqual( isnan( NaN ), false, 'returns false' );
 	t.end();
 });
 
@@ -71,13 +71,13 @@ tape( 'the function returns `false` if not provided `NaN`', function test( t ) {
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isnan( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isnan( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` when provided a symbol (symbols are unique)', opts, function test( t ) {
 	var s = Symbol( 'foo' );
-	t.equal( isnan( s ), false, 'returns false' );
+	t.strictEqual( isnan( s ), false, 'returns false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nan/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-nan/test/test.primitive.js
index 273b24781c0d..4d82ae46541c 100644
--- a/lib/node_modules/@stdlib/assert/is-nan/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-nan/test/test.primitive.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a `NaN` primitive number', function test( t ) {
-	t.equal( isnan( NaN ), true, 'returns true' );
+	t.strictEqual( isnan( NaN ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the value of the object is `NaN`', function test( t ) {
-	t.equal( isnan( new Number( 5 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
-	t.equal( isnan( new Number( NaN ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isnan( new Number( 5 ) ), false, 'returns false' );
+	t.strictEqual( isnan( new Number( NaN ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -71,13 +71,13 @@ tape( 'the function returns `false` if not provided `NaN`', function test( t ) {
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isnan( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isnan( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` when provided a symbol (symbols are unique)', opts, function test( t ) {
 	var s = Symbol( 'foo' );
-	t.equal( isnan( s ), false, 'returns false' );
+	t.strictEqual( isnan( s ), false, 'returns false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-ndarray-like-with-data-type/test/test.js b/lib/node_modules/@stdlib/assert/is-ndarray-like-with-data-type/test/test.js
index bc151a39cdb6..5524bf43af0e 100644
--- a/lib/node_modules/@stdlib/assert/is-ndarray-like-with-data-type/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-ndarray-like-with-data-type/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided an ndarray having a specified data type', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isndarrayLikeWithDataType( arr, 'generic' ), true, 'returns expected value' );
+	t.strictEqual( isndarrayLikeWithDataType( arr, 'generic' ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided an ndarray-like object having a s
 		'set': noop
 	};
 
-	t.equal( isndarrayLikeWithDataType( arr, 'generic' ), true, 'returns expected value' );
+	t.strictEqual( isndarrayLikeWithDataType( arr, 'generic' ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -78,7 +78,7 @@ tape( 'the function returns `false` if provided an ndarray-like object not havin
 		'set': noop
 	};
 
-	t.equal( isndarrayLikeWithDataType( arr, 'foobar' ), false, 'returns expected value' );
+	t.strictEqual( isndarrayLikeWithDataType( arr, 'foobar' ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -100,7 +100,7 @@ tape( 'the function returns `false` if not provided an ndarray-like object', fun
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isndarrayLikeWithDataType( values[i] ), false, 'returns expected value when provided '+values[i] );
+		t.strictEqual( isndarrayLikeWithDataType( values[i] ), false, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-ndarray-like/test/test.js b/lib/node_modules/@stdlib/assert/is-ndarray-like/test/test.js
index 2a49951db138..b8680bfb4bea 100644
--- a/lib/node_modules/@stdlib/assert/is-ndarray-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-ndarray-like/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided an ndarray', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isndarrayLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided an ndarray-like object', function
 		'set': noop
 	};
 
-	t.equal( isndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isndarrayLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -79,7 +79,7 @@ tape( 'the function returns `false` if not provided an ndarray-like object', fun
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isndarrayLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isndarrayLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.js b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.js
index 60bfcbf659f6..b332b579020d 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive number having a finite negative value', function test( t ) {
-	t.equal( typeof isNegativeFinite.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isNegativeFinite.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a finite negative value', function test( t ) {
-	t.equal( typeof isNegativeFinite.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isNegativeFinite.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.main.js b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.main.js
index a128aced5816..aaa2807d6cfd 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a finite negative number value', function test( t ) {
-	t.equal( isNegativeFinite( -5.0 ), true, 'returns true' );
-	t.equal( isNegativeFinite( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNegativeFinite( -5.0 ), true, 'returns true' );
+	t.strictEqual( isNegativeFinite( new Number( -5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a number having a finite neg
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNegativeFinite( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNegativeFinite( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.object.js b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.object.js
index 420404cc3ecc..1043d22503ac 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a finite negative value', function test( t ) {
-	t.equal( isNegativeFinite( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNegativeFinite( new Number( -5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a finite negative value', function test( t ) {
-	t.equal( isNegativeFinite( -3.0 ), false, 'returns false' );
+	t.strictEqual( isNegativeFinite( -3.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -66,7 +66,7 @@ tape( 'the function returns `false` if not provided a finite negative number', f
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNegativeFinite( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNegativeFinite( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.primitive.js
index 8a7ec3a42bef..160214c11169 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a finite negative value', function test( t ) {
-	t.equal( isNegativeFinite( -3.0 ), true, 'returns true' );
+	t.strictEqual( isNegativeFinite( -3.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a finite negative value', function test( t ) {
-	t.equal( isNegativeFinite( new Number( -5.0 ) ), false, 'returns false' );
+	t.strictEqual( isNegativeFinite( new Number( -5.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -62,7 +62,7 @@ tape( 'the function returns `false` if not provided a finite negative number', f
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNegativeFinite( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNegativeFinite( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-integer-array/test/test.js b/lib/node_modules/@stdlib/assert/is-negative-integer-array/test/test.js
index 19720f06081e..955048606746 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-integer-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-integer-array/test/test.js
@@ -38,20 +38,20 @@ tape( 'the function tests for an array-like object containing only negative inte
 	var arr;
 
 	arr = [ -5.0, new Number( -5 ), -1.0 ];
-	t.equal( isNegativeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray( arr ), true, 'returns true' );
 
 	arr = new Int32Array( [ -2, -9, -4 ] );
-	t.equal( isNegativeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -5 ),
 		'1': new Number( -2 )
 	};
-	t.equal( isNegativeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray( arr ), true, 'returns true' );
 
 	arr = [ -5.0, '3', null ];
-	t.equal( isNegativeIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeIntegerArray( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -60,20 +60,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ -5.0, -1.0 ];
-	t.equal( isNegativeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray.primitives( arr ), true, 'returns true' );
 
 	arr = new Int32Array( [ -2, -9, -4 ] );
-	t.equal( isNegativeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray.primitives( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -5 ),
 		'1': new Number( -2 )
 	};
-	t.equal( isNegativeIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeIntegerArray.primitives( arr ), false, 'returns false' );
 
 	arr = [ new Number( -5 ), -1.0, -1.0 ];
-	t.equal( isNegativeIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeIntegerArray.primitives( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -82,20 +82,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( -5 ), new Number( -5 ) ];
-	t.equal( isNegativeIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray.objects( arr ), true, 'returns true' );
 
 	arr = [ -5, -3 ];
-	t.equal( isNegativeIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeIntegerArray.objects( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -5 ),
 		'1': new Number( -2 )
 	};
-	t.equal( isNegativeIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray.objects( arr ), true, 'returns true' );
 
 	arr = new Int32Array( [ -2, -9, -4 ] );
-	t.equal( isNegativeIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeIntegerArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.js b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.js
index 458c73f0c3aa..228386f6c70b 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive number having a negative integer value', function test( t ) {
-	t.equal( typeof isNegativeInteger.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isNegativeInteger.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a negative integer value', function test( t ) {
-	t.equal( typeof isNegativeInteger.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isNegativeInteger.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.main.js b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.main.js
index ec0678f36eaf..5c23361ddf22 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a negative integer value', function test( t ) {
-	t.equal( isNegativeInteger( -5.0 ), true, 'returns true' );
-	t.equal( isNegativeInteger( new Number( -5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNegativeInteger( -5.0 ), true, 'returns true' );
+	t.strictEqual( isNegativeInteger( new Number( -5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -48,7 +48,7 @@ tape( 'the function returns `false` if not provided a number having a negative i
 		3.14,
 		1.0,
 		0.0,
-		new Number( 3.0 ), // eslint-disable-line no-new-wrappers
+		new Number( 3.0 ),
 		null,
 		true,
 		void 0,
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a number having a negative i
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNegativeInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNegativeInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.object.js b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.object.js
index 919abfcc91ed..7ea1d42dfdc4 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a negative integer value', function test( t ) {
-	t.equal( isNegativeInteger( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNegativeInteger( new Number( -5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a negative integer value', function test( t ) {
-	t.equal( isNegativeInteger( -3.0 ), false, 'returns false' );
+	t.strictEqual( isNegativeInteger( -3.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -63,7 +63,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNegativeInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNegativeInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.primitive.js
index 09be94f05cdf..dba56a9b0a1b 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a negative integer value', function test( t ) {
-	t.equal( isNegativeInteger( -3.0 ), true, 'returns true' );
+	t.strictEqual( isNegativeInteger( -3.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a negative integer value', function test( t ) {
-	t.equal( isNegativeInteger( new Number( -5.0 ) ), false, 'returns false' );
+	t.strictEqual( isNegativeInteger( new Number( -5.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -59,7 +59,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNegativeInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNegativeInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-number-array/test/test.js b/lib/node_modules/@stdlib/assert/is-negative-number-array/test/test.js
index 342c5e35560d..24cc5bba6374 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-number-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-number-array/test/test.js
@@ -38,20 +38,20 @@ tape( 'the function tests for an array-like object containing only negative numb
 	var arr;
 
 	arr = [ -5.0, new Number( -5 ), -1.0 ];
-	t.equal( isNegativeNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray( arr ), true, 'returns true' );
 
 	arr = [ -5.0, '-3', null ];
-	t.equal( isNegativeNumberArray( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeNumberArray( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': -3.14,
 		'1': -2.0
 	};
-	t.equal( isNegativeNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray( arr ), true, 'returns true' );
 
 	arr = new Float32Array( [ -5.0, -1.5 ] );
-	t.equal( isNegativeNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray( arr ), true, 'returns true' );
 
 	t.end();
 });
@@ -60,20 +60,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ -5.0, -2.0 ];
-	t.equal( isNegativeNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray.primitives( arr ), true, 'returns true' );
 
 	arr = [ new Number( -5 ), -1.0, -1.0 ];
-	t.equal( isNegativeNumberArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeNumberArray.primitives( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': -3.14,
 		'1': -1.0
 	};
-	t.equal( isNegativeNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray.primitives( arr ), true, 'returns true' );
 
 	arr = new Float32Array( [ -5.0, -1.5 ] );
-	t.equal( isNegativeNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray.primitives( arr ), true, 'returns true' );
 
 	t.end();
 });
@@ -82,20 +82,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ new Number( -5 ), new Number( -5 ) ];
-	t.equal( isNegativeNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray.objects( arr ), true, 'returns true' );
 
 	arr = [ -5.0, -1.0 ];
-	t.equal( isNegativeNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeNumberArray.objects( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -3.14 ),
 		'1': new Number( -2.0 )
 	};
-	t.equal( isNegativeNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray.objects( arr ), true, 'returns true' );
 
 	arr = new Float32Array( [ -5.0, -1.5 ] );
-	t.equal( isNegativeNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeNumberArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.js b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.js
index 1cffcaa6b6e6..040d12d9dcfd 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive number having a negative value', function test( t ) {
-	t.equal( typeof isNegativeNumber.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isNegativeNumber.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a negative value', function test( t ) {
-	t.equal( typeof isNegativeNumber.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isNegativeNumber.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.main.js
index 40d2e5563c20..c51882e494cb 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a negative number value', function test( t ) {
-	t.equal( isNegativeNumber( -5.0 ), true, 'returns true' );
-	t.equal( isNegativeNumber( new Number( -5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNegativeNumber( -5.0 ), true, 'returns true' );
+	t.strictEqual( isNegativeNumber( new Number( -5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `false` if not provided a number having a negative n
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNegativeNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNegativeNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.object.js
index d6c434b44d7c..2d303051327e 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a negative value', function test( t ) {
-	t.equal( isNegativeNumber( new Number( -5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNegativeNumber( new Number( -5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a negative value', function test( t ) {
-	t.equal( isNegativeNumber( -3.0 ), false, 'returns false' );
+	t.strictEqual( isNegativeNumber( -3.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -49,8 +49,8 @@ tape( 'the function returns `false` if not provided a negative number', function
 
 	values = [
 		'5',
-		new Number( 0.0 ), // eslint-disable-line no-new-wrappers
-		new Number( 2.0 ), // eslint-disable-line no-new-wrappers
+		new Number( 0.0 ),
+		new Number( 2.0 ),
 		3.14,
 		null,
 		true,
@@ -64,7 +64,7 @@ tape( 'the function returns `false` if not provided a negative number', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNegativeNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNegativeNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.primitive.js
index 184ab5d1e3c9..8886697156e1 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a negative value', function test( t ) {
-	t.equal( isNegativeNumber( -3.0 ), true, 'returns true' );
+	t.strictEqual( isNegativeNumber( -3.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a negative value', function test( t ) {
-	t.equal( isNegativeNumber( new Number( -5.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNegativeNumber( new Number( -5.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -50,7 +50,7 @@ tape( 'the function returns `false` if not provided a negative number', function
 	values = [
 		'5',
 		0.0,
-		new Number( 2.0 ), // eslint-disable-line no-new-wrappers
+		new Number( 2.0 ),
 		3.14,
 		null,
 		true,
@@ -61,7 +61,7 @@ tape( 'the function returns `false` if not provided a negative number', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNegativeNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNegativeNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-node/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-node/test/test.browser.js
index 8285e0988130..69232abe69ee 100644
--- a/lib/node_modules/@stdlib/assert/is-node/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-node/test/test.browser.js
@@ -33,6 +33,6 @@ tape( 'main export is a boolean', function test( t ) {
 });
 
 tape( 'the exported value is always `false`', function test( t ) {
-	t.equal( IS_NODE, false, 'returns false' );
+	t.strictEqual( IS_NODE, false, 'returns false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-node/test/test.main.js b/lib/node_modules/@stdlib/assert/is-node/test/test.main.js
index 2869fc42761b..a82633280a89 100644
--- a/lib/node_modules/@stdlib/assert/is-node/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-node/test/test.main.js
@@ -16,6 +16,8 @@
 * limitations under the License.
 */
 
+/* eslint-disable node/no-unsupported-features/node-builtins */
+
 'use strict';
 
 // MODULES //
@@ -59,7 +61,7 @@ tape( 'the function returns `true` if runtime is Node.js (Node.js < v7)', functi
 		'./global_scope.js': true
 	});
 
-	t.equal( isNode(), true, 'returns true' );
+	t.strictEqual( isNode(), true, 'returns true' );
 	t.end();
 });
 
@@ -88,7 +90,7 @@ tape( 'the function returns `true` if runtime is Node.js (Node.js >= v7)', funct
 		'./global_scope.js': true
 	});
 
-	t.equal( isNode(), true, 'returns true' );
+	t.strictEqual( isNode(), true, 'returns true' );
 	t.end();
 });
 
@@ -121,7 +123,7 @@ tape( 'the function returns `false` if runtime is not Node.js (`global` variable
 		'@stdlib/assert/is-string': isString,
 		'./global_scope.js': true
 	});
-	t.equal( isNode(), false, 'returns false' );
+	t.strictEqual( isNode(), false, 'returns false' );
 	t.end();
 });
 
@@ -145,7 +147,7 @@ tape( 'the function returns `false` if runtime is not Node.js (`global` variable
 		'@stdlib/assert/is-string': isString,
 		'./global_scope.js': true
 	});
-	t.equal( isNode(), false, 'returns false' );
+	t.strictEqual( isNode(), false, 'returns false' );
 	t.end();
 });
 
@@ -173,7 +175,7 @@ tape( 'the function returns `false` if runtime is not Node.js (`global` variable
 		'@stdlib/assert/is-string': isString,
 		'./global_scope.js': false
 	});
-	t.equal( isNode(), false, 'returns false' );
+	t.strictEqual( isNode(), false, 'returns false' );
 	t.end();
 });
 
@@ -206,7 +208,7 @@ tape( 'the function returns `false` if runtime is not Node.js (`process` variabl
 		'./global_scope.js': true,
 		'./to_string.js': toStr
 	});
-	t.equal( isNode(), false, 'returns false' );
+	t.strictEqual( isNode(), false, 'returns false' );
 	t.end();
 });
 
@@ -241,7 +243,7 @@ tape( 'the function returns `false` if runtime is not Node.js (`process.versions
 		'@stdlib/assert/is-string': isString,
 		'./global_scope.js': true
 	});
-	t.equal( isNode(), false, 'returns false' );
+	t.strictEqual( isNode(), false, 'returns false' );
 	t.end();
 });
 
@@ -276,7 +278,7 @@ tape( 'the function returns `false` if runtime is not Node.js (`process.versions
 		'@stdlib/assert/is-string': isString,
 		'./global_scope.js': true
 	});
-	t.equal( isNode(), false, 'returns false' );
+	t.strictEqual( isNode(), false, 'returns false' );
 	t.end();
 });
 
@@ -314,9 +316,9 @@ tape( 'the function returns `false` if runtime is not Node.js (`process.release`
 
 	// `process.release` was added in Node v3.0.0
 	if ( proc.release ) {
-		t.equal( isNode(), false, 'returns false' );
+		t.strictEqual( isNode(), false, 'returns false' );
 	} else {
-		t.equal( isNode(), true, 'returns true' );
+		t.strictEqual( isNode(), true, 'returns true' );
 	}
 	t.end();
 });
@@ -355,9 +357,9 @@ tape( 'the function returns `false` if runtime is not Node.js (`process.release.
 
 	// `process.release` was added in Node v3.0.0
 	if ( proc.release ) {
-		t.equal( isNode(), false, 'returns false' );
+		t.strictEqual( isNode(), false, 'returns false' );
 	} else {
-		t.equal( isNode(), true, 'returns true' );
+		t.strictEqual( isNode(), true, 'returns true' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonconfigurable-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-nonconfigurable-property-in/test/test.js
index b075e8d449de..9dcc78642265 100644
--- a/lib/node_modules/@stdlib/assert/is-nonconfigurable-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonconfigurable-property-in/test/test.js
@@ -47,10 +47,10 @@ tape( 'the function returns `true` if provided a non-configurable property', fun
 	});
 
 	bool = isNonConfigurablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isNonConfigurablePropertyIn( [ 'a' ], 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'the function returns `true` if provided a non-configurable inherited prop
 	obj = new Foo();
 
 	bool = isNonConfigurablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -91,16 +91,16 @@ tape( 'the function returns `false` if an object property is configurable', func
 		'a': 'b'
 	};
 	bool = isNonConfigurablePropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonConfigurablePropertyIn( [ 1, 2, 3 ], '1' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonConfigurablePropertyIn( [ 1, 2, 3 ], 1 );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonConfigurablePropertyIn( new Foo(), 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -111,7 +111,7 @@ tape( 'the function returns `false` if an object property is configurable', func
 	});
 
 	bool = isNonConfigurablePropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -134,16 +134,16 @@ tape( 'the function returns `false` if provided a configurable inherited propert
 	obj = new Foo();
 
 	bool = isNonConfigurablePropertyIn( obj, 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonConfigurablePropertyIn( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonConfigurablePropertyIn( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonConfigurablePropertyIn( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -152,10 +152,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isNonConfigurablePropertyIn( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isNonConfigurablePropertyIn( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -176,10 +176,10 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isNonConfigurablePropertyIn( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonConfigurablePropertyIn( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -188,10 +188,10 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isNonConfigurablePropertyIn( 'beep', 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isNonConfigurablePropertyIn( 'beep', 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonconfigurable-property/test/test.js b/lib/node_modules/@stdlib/assert/is-nonconfigurable-property/test/test.js
index 966b1dfc77b3..b7e203e2b1bf 100644
--- a/lib/node_modules/@stdlib/assert/is-nonconfigurable-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonconfigurable-property/test/test.js
@@ -37,10 +37,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isNonConfigurableProperty( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isNonConfigurableProperty( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -58,16 +58,16 @@ tape( 'the function returns `false` if an object property is configurable', func
 		'a': 'b'
 	};
 	bool = isNonConfigurableProperty( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonConfigurableProperty( [ 1, 2, 3 ], '1' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonConfigurableProperty( [ 1, 2, 3 ], 1 );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonConfigurableProperty( new Foo(), 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isNonConfigurableProperty( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -99,10 +99,10 @@ tape( 'the function returns `true` if an object property is non-configurable', f
 	});
 
 	bool = isNonConfigurableProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isNonConfigurableProperty( [ 'a' ], 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -111,13 +111,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isNonConfigurableProperty( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonConfigurableProperty( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonConfigurableProperty( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -126,7 +126,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isNonConfigurableProperty( 'beep', 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonenumerable-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-nonenumerable-property-in/test/test.js
index c1e29f95232f..8d9b11cf0b94 100644
--- a/lib/node_modules/@stdlib/assert/is-nonenumerable-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonenumerable-property-in/test/test.js
@@ -47,10 +47,10 @@ tape( 'the function returns `true` if provided a non-enumerable property', funct
 	});
 
 	bool = isNonEnumerablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isNonEnumerablePropertyIn( [ 'a' ], 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -73,16 +73,16 @@ tape( 'the function returns `true` if provided a non-enumerable inherited proper
 	obj = new Foo();
 
 	bool = isNonEnumerablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isNonEnumerablePropertyIn( {}, 'hasOwnProperty' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isNonEnumerablePropertyIn( {}, 'toString' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isNonEnumerablePropertyIn( {}, 'constructor' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -100,16 +100,16 @@ tape( 'the function returns `false` if an object property is enumerable', functi
 		'a': 'b'
 	};
 	bool = isNonEnumerablePropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonEnumerablePropertyIn( [ 1, 2, 3 ], '1' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonEnumerablePropertyIn( [ 1, 2, 3 ], 1 );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonEnumerablePropertyIn( new Foo(), 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -120,7 +120,7 @@ tape( 'the function returns `false` if an object property is enumerable', functi
 	});
 
 	bool = isNonEnumerablePropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function returns `false` if provided an enumerable inherited property
 	obj = new Foo();
 
 	bool = isNonEnumerablePropertyIn( obj, 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -152,10 +152,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isNonEnumerablePropertyIn( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isNonEnumerablePropertyIn( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -176,10 +176,10 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isNonEnumerablePropertyIn( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonEnumerablePropertyIn( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -188,10 +188,10 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isNonEnumerablePropertyIn( 'beep', 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isNonEnumerablePropertyIn( 'beep', 'toString' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonenumerable-property/test/test.js b/lib/node_modules/@stdlib/assert/is-nonenumerable-property/test/test.js
index 78ebb670833e..1ae4792f773b 100644
--- a/lib/node_modules/@stdlib/assert/is-nonenumerable-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonenumerable-property/test/test.js
@@ -37,10 +37,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isNonEnumerableProperty( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isNonEnumerableProperty( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -58,16 +58,16 @@ tape( 'the function returns `false` if an object property is enumerable', functi
 		'a': 'b'
 	};
 	bool = isNonEnumerableProperty( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonEnumerableProperty( [ 1, 2, 3 ], '1' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonEnumerableProperty( [ 1, 2, 3 ], 1 );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonEnumerableProperty( new Foo(), 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isNonEnumerableProperty( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -99,10 +99,10 @@ tape( 'the function returns `true` if an object property is non-enumerable', fun
 	});
 
 	bool = isNonEnumerableProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isNonEnumerableProperty( [ 'a' ], 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -111,13 +111,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isNonEnumerableProperty( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonEnumerableProperty( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isNonEnumerableProperty( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -126,7 +126,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isNonEnumerableProperty( 'beep', 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.js b/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.js
index a705a3bdb0f0..93b26e83f3a6 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive number having a nonnegative finite number value', function test( t ) {
-	t.equal( typeof isNonNegativeFinite.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isNonNegativeFinite.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a nonnegative finite number value', function test( t ) {
-	t.equal( typeof isNonNegativeFinite.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isNonNegativeFinite.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.main.js
index c21a7292c5d6..332c78c5a240 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a nonnegative finite value', function test( t ) {
-	t.equal( isNonNegativeFinite( 5.0 ), true, 'returns expected value' );
-	t.equal( isNonNegativeFinite( new Number( 5.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeFinite( 5.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeFinite( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a number having a nonnegativ
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonNegativeFinite( values[i] ), false, 'returns expected value when provided '+values[i] );
+		t.strictEqual( isNonNegativeFinite( values[i] ), false, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.object.js b/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.object.js
index 4e629c33242d..e9db9d714cf5 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.object.js
@@ -34,17 +34,17 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a nonnegative finite value', function test( t ) {
-	t.equal( isNonNegativeFinite( new Number( 5.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeFinite( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided positive infinity (primitive)', function test( t ) {
-	t.equal( isNonNegativeFinite( 1.0/0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNonNegativeFinite( 1.0/0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided positive infinity (object)', function test( t ) {
-	t.equal( isNonNegativeFinite( new Number( 1.0/0.0 ) ), false, 'returns expected value' );
+	t.strictEqual( isNonNegativeFinite( new Number( 1.0/0.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -68,7 +68,7 @@ tape( 'the function returns `false` if not provided a nonnegative number', funct
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonNegativeFinite( values[i] ), false, 'returns expected value when provided '+values[i] );
+		t.strictEqual( isNonNegativeFinite( values[i] ), false, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.primitive.js
index 033d352c1444..8dcd6c776caf 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-finite/test/test.primitive.js
@@ -34,22 +34,22 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a nonnegative finite value', function test( t ) {
-	t.equal( isNonNegativeFinite( 3.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeFinite( 3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a nonnegative finite value', function test( t ) {
-	t.equal( isNonNegativeFinite( new Number( 5.0 ) ), false, 'returns expected value' );
+	t.strictEqual( isNonNegativeFinite( new Number( 5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided positive infinity (primitive)', function test( t ) {
-	t.equal( isNonNegativeFinite( 1.0/0.0 ), false, 'returns expected value' );
+	t.strictEqual( isNonNegativeFinite( 1.0/0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided positive infinity (object)', function test( t ) {
-	t.equal( isNonNegativeFinite( new Number( 1.0/0.0 ) ), false, 'returns expected value' );
+	t.strictEqual( isNonNegativeFinite( new Number( 1.0/0.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -70,7 +70,7 @@ tape( 'the function returns `false` if not provided a nonnegative finite number'
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonNegativeFinite( values[i] ), false, 'returns expected value when provided '+values[i] );
+		t.strictEqual( isNonNegativeFinite( values[i] ), false, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-integer-array/test/test.js b/lib/node_modules/@stdlib/assert/is-nonnegative-integer-array/test/test.js
index 866d020b8a68..d9298452b0ef 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-integer-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-integer-array/test/test.js
@@ -40,20 +40,20 @@ tape( 'the function tests for an array-like object containing only nonnegative i
 	var arr;
 
 	arr = [ 5.0, new Number( 5 ), 0 ];
-	t.equal( isNonNegativeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray( arr ), true, 'returns true' );
 
 	arr = [ 5.0, '3', null ];
-	t.equal( isNonNegativeIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeIntegerArray( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': 5,
 		'1': 0
 	};
-	t.equal( isNonNegativeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray( arr ), true, 'returns true' );
 
 	arr = new Int32Array( [ 5, 0 ] );
-	t.equal( isNonNegativeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray( arr ), true, 'returns true' );
 
 	t.end();
 });
@@ -62,20 +62,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ 5.0, 0.0 ];
-	t.equal( isNonNegativeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray.primitives( arr ), true, 'returns true' );
 
 	arr = [ new Number( 5 ), 1.0, 1.0 ];
-	t.equal( isNonNegativeIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeIntegerArray.primitives( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': 5,
 		'1': 0
 	};
-	t.equal( isNonNegativeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray.primitives( arr ), true, 'returns true' );
 
 	arr = new Int16Array( [ 5, 0 ] );
-	t.equal( isNonNegativeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray.primitives( arr ), true, 'returns true' );
 
 	t.end();
 });
@@ -84,20 +84,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( 5 ), new Number( 5 ) ];
-	t.equal( isNonNegativeIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray.objects( arr ), true, 'returns true' );
 
 	arr = [ 5.0, 0.0 ];
-	t.equal( isNonNegativeIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeIntegerArray.objects( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 5 ),
 		'1': new Number( 0 )
 	};
-	t.equal( isNonNegativeIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray.objects( arr ), true, 'returns true' );
 
 	arr = new Uint32Array( [ 5, 0 ] );
-	t.equal( isNonNegativeIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeIntegerArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.js b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.js
index aee599e645d1..9b7fa511c8d0 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive number having a nonnegative integer value', function test( t ) {
-	t.equal( typeof isNonNegativeInteger.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isNonNegativeInteger.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a nonnegative integer value', function test( t ) {
-	t.equal( typeof isNonNegativeInteger.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isNonNegativeInteger.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.main.js
index b0b45e2757c4..184e1d376445 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a nonnegative integer value', function test( t ) {
-	t.equal( isNonNegativeInteger( 5.0 ), true, 'returns true' );
-	t.equal( isNonNegativeInteger( new Number( 5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNonNegativeInteger( 5.0 ), true, 'returns true' );
+	t.strictEqual( isNonNegativeInteger( new Number( 5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if not provided a number having a nonnegativ
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonNegativeInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonNegativeInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.object.js b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.object.js
index 01fcea6adf8f..7765efad5af7 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a nonnegative integer value', function test( t ) {
-	t.equal( isNonNegativeInteger( new Number( 5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNonNegativeInteger( new Number( 5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a nonnegative integer value', function test( t ) {
-	t.equal( isNonNegativeInteger( 3.0 ), false, 'returns false' );
+	t.strictEqual( isNonNegativeInteger( 3.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonNegativeInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonNegativeInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.primitive.js
index 12df7aba4275..b0387f876b37 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a nonnegative integer value', function test( t ) {
-	t.equal( isNonNegativeInteger( 3.0 ), true, 'returns true' );
+	t.strictEqual( isNonNegativeInteger( 3.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a nonnegative integer value', function test( t ) {
-	t.equal( isNonNegativeInteger( new Number( 5.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNonNegativeInteger( new Number( 5.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonNegativeInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonNegativeInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-number-array/test/test.js b/lib/node_modules/@stdlib/assert/is-nonnegative-number-array/test/test.js
index f87a53634898..cf59d14ab274 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-number-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-number-array/test/test.js
@@ -38,20 +38,20 @@ tape( 'the function tests for an array-like object containing only nonnegative n
 	var arr;
 
 	arr = [ 5.0, new Number( 5 ), 0 ];
-	t.equal( isNonNegativeNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray( arr ), true, 'returns true' );
 
 	arr = [ 5.0, '3', null ];
-	t.equal( isNonNegativeNumberArray( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeNumberArray( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': 3.14,
 		'1': 0.0
 	};
-	t.equal( isNonNegativeNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray( arr ), true, 'returns true' );
 
 	arr = new Float32Array( [ 5.0, 1.5 ] );
-	t.equal( isNonNegativeNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray( arr ), true, 'returns true' );
 
 	t.end();
 });
@@ -60,20 +60,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ 5.0, 0.0 ];
-	t.equal( isNonNegativeNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray.primitives( arr ), true, 'returns true' );
 
 	arr = [ new Number( 5 ), 1.0, 1.0 ];
-	t.equal( isNonNegativeNumberArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeNumberArray.primitives( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': 3.14,
 		'1': 0.0
 	};
-	t.equal( isNonNegativeNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray.primitives( arr ), true, 'returns true' );
 
 	arr = new Float32Array( [ 5.0, 1.5 ] );
-	t.equal( isNonNegativeNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray.primitives( arr ), true, 'returns true' );
 
 	t.end();
 });
@@ -82,20 +82,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ new Number( 5 ), new Number( 5 ) ];
-	t.equal( isNonNegativeNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray.objects( arr ), true, 'returns true' );
 
 	arr = [ 5.0, 0.0 ];
-	t.equal( isNonNegativeNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeNumberArray.objects( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 3.14 ),
 		'1': new Number( 0.0 )
 	};
-	t.equal( isNonNegativeNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray.objects( arr ), true, 'returns true' );
 
 	arr = new Float32Array( [ 5.0, 1.5 ] );
-	t.equal( isNonNegativeNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeNumberArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.js b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.js
index cde610ce8ebc..596ba334af96 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive number having a nonnegative number value', function test( t ) {
-	t.equal( typeof isNonNegativeNumber.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isNonNegativeNumber.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a nonnegative number value', function test( t ) {
-	t.equal( typeof isNonNegativeNumber.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isNonNegativeNumber.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.main.js
index ee45147b896e..66c57c383e53 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a nonnegative number value', function test( t ) {
-	t.equal( isNonNegativeNumber( 5.0 ), true, 'returns true' );
-	t.equal( isNonNegativeNumber( new Number( 5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNonNegativeNumber( 5.0 ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumber( new Number( 5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if not provided a number having a nonnegativ
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonNegativeNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonNegativeNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.object.js
index 579b30e5796d..c0e07c1c9667 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a nonnegative number value', function test( t ) {
-	t.equal( isNonNegativeNumber( new Number( 5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNonNegativeNumber( new Number( 5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a nonnegative number value', function test( t ) {
-	t.equal( isNonNegativeNumber( 3.0 ), false, 'returns false' );
+	t.strictEqual( isNonNegativeNumber( 3.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -49,7 +49,7 @@ tape( 'the function returns `false` if not provided a nonnegative number', funct
 
 	values = [
 		'5',
-		new Number( -2.0 ), // eslint-disable-line no-new-wrappers
+		new Number( -2.0 ),
 		-3.14,
 		null,
 		true,
@@ -63,7 +63,7 @@ tape( 'the function returns `false` if not provided a nonnegative number', funct
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonNegativeNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonNegativeNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.primitive.js
index 172682179e5b..039239b94a77 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a nonnegative number value', function test( t ) {
-	t.equal( isNonNegativeNumber( 3.0 ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumber( 3.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a nonnegative number value', function test( t ) {
-	t.equal( isNonNegativeNumber( new Number( 5.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNonNegativeNumber( new Number( 5.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -49,7 +49,7 @@ tape( 'the function returns `false` if not provided a nonnegative number', funct
 
 	values = [
 		'5',
-		new Number( -1.0 ), // eslint-disable-line no-new-wrappers
+		new Number( -1.0 ),
 		-3.14,
 		null,
 		true,
@@ -60,7 +60,7 @@ tape( 'the function returns `false` if not provided a nonnegative number', funct
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonNegativeNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonNegativeNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.js b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.js
index 504034e3e7a9..67f6c4c2fdf3 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive number having a nonpositive finite number value', function test( t ) {
-	t.equal( typeof isNonPositiveFinite.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isNonPositiveFinite.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a nonpositive finite number value', function test( t ) {
-	t.equal( typeof isNonPositiveFinite.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isNonPositiveFinite.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.main.js
index 523410e2de33..0d7cdb588d02 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.main.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a nonpositive finite number value', function test( t ) {
-	t.equal( isNonPositiveFinite( -5.0 ), true, 'returns true' );
-	t.equal( isNonPositiveFinite( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNonPositiveFinite( -5.0 ), true, 'returns true' );
+	t.strictEqual( isNonPositiveFinite( new Number( -5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a number having a nonpositiv
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonPositiveFinite( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonPositiveFinite( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.object.js b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.object.js
index d74803bbbaad..de946ea133a7 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a nonpositive finite number value', function test( t ) {
-	t.equal( isNonPositiveFinite( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNonPositiveFinite( new Number( -5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a nonpositive finite number value', function test( t ) {
-	t.equal( isNonPositiveFinite( -3.0 ), false, 'returns false' );
+	t.strictEqual( isNonPositiveFinite( -3.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonPositiveFinite( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonPositiveFinite( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.primitive.js
index 24af87b95bc6..3c2dc8dd2a59 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a nonpositive finite number value', function test( t ) {
-	t.equal( isNonPositiveFinite( -3.0 ), true, 'returns true' );
+	t.strictEqual( isNonPositiveFinite( -3.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a nonpositive finite number value', function test( t ) {
-	t.equal( isNonPositiveFinite( new Number( -5.0 ) ), false, 'returns false' );
+	t.strictEqual( isNonPositiveFinite( new Number( -5.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonPositiveFinite( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonPositiveFinite( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-integer-array/test/test.js b/lib/node_modules/@stdlib/assert/is-nonpositive-integer-array/test/test.js
index a336d0e2ea36..f86ea934d6d4 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-integer-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-integer-array/test/test.js
@@ -38,20 +38,20 @@ tape( 'the function tests for an array-like object containing only nonpositive i
 	var arr;
 
 	arr = [ -5.0, new Number( -5 ), -1.0 ];
-	t.equal( isNonPositiveIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray( arr ), true, 'returns true' );
 
 	arr = new Int32Array( [ -2, -9, -4, 0 ] );
-	t.equal( isNonPositiveIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -5 ),
 		'1': new Number( -2 )
 	};
-	t.equal( isNonPositiveIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray( arr ), true, 'returns true' );
 
 	arr = [ -5.0, '3', null ];
-	t.equal( isNonPositiveIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveIntegerArray( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -60,20 +60,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ -5.0, -1.0, 0 ];
-	t.equal( isNonPositiveIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray.primitives( arr ), true, 'returns true' );
 
 	arr = new Int32Array( [ -2, -9, -4 ] );
-	t.equal( isNonPositiveIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray.primitives( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -5 ),
 		'1': new Number( -2 )
 	};
-	t.equal( isNonPositiveIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveIntegerArray.primitives( arr ), false, 'returns false' );
 
 	arr = [ new Number( -5 ), -1.0, -1.0 ];
-	t.equal( isNonPositiveIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveIntegerArray.primitives( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -82,20 +82,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( -5 ), new Number( -5 ) ];
-	t.equal( isNonPositiveIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray.objects( arr ), true, 'returns true' );
 
 	arr = [ -5, -3, 0 ];
-	t.equal( isNonPositiveIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveIntegerArray.objects( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -5 ),
 		'1': new Number( -2 )
 	};
-	t.equal( isNonPositiveIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray.objects( arr ), true, 'returns true' );
 
 	arr = new Int32Array( [ -2, -9, -4 ] );
-	t.equal( isNonPositiveIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveIntegerArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.js b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.js
index 63ecf37ffa23..3ce140df8430 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive number having a nonpositive integer value', function test( t ) {
-	t.equal( typeof isNonPositiveInteger.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isNonPositiveInteger.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a nonpositive integer value', function test( t ) {
-	t.equal( typeof isNonPositiveInteger.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isNonPositiveInteger.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.main.js
index 47a8eb8fbd84..6a21a11d3bb5 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a nonpositive integer value', function test( t ) {
-	t.equal( isNonPositiveInteger( -5.0 ), true, 'returns true' );
-	t.equal( isNonPositiveInteger( new Number( -5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNonPositiveInteger( -5.0 ), true, 'returns true' );
+	t.strictEqual( isNonPositiveInteger( new Number( -5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if not provided a number having a nonpositiv
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonPositiveInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonPositiveInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.object.js b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.object.js
index 3ae97378579b..cc0142f5e3dd 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a nonpositive integer value', function test( t ) {
-	t.equal( isNonPositiveInteger( new Number( -5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNonPositiveInteger( new Number( -5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a nonpositive integer value', function test( t ) {
-	t.equal( isNonPositiveInteger( -3.0 ), false, 'returns false' );
+	t.strictEqual( isNonPositiveInteger( -3.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonPositiveInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonPositiveInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.primitive.js
index 456ba48e4b82..6a794c404596 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a nonpositive integer value', function test( t ) {
-	t.equal( isNonPositiveInteger( -3.0 ), true, 'returns true' );
+	t.strictEqual( isNonPositiveInteger( -3.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a nonpositive integer value', function test( t ) {
-	t.equal( isNonPositiveInteger( new Number( -5.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNonPositiveInteger( new Number( -5.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonPositiveInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonPositiveInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-number-array/test/test.js b/lib/node_modules/@stdlib/assert/is-nonpositive-number-array/test/test.js
index 82c8a764d7f9..660410a441cd 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-number-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-number-array/test/test.js
@@ -38,20 +38,20 @@ tape( 'the function tests for an array-like object containing only nonpositive n
 	var arr;
 
 	arr = [ -5.0, new Number( -5 ), 0 ];
-	t.equal( isNonPositiveNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray( arr ), true, 'returns true' );
 
 	arr = [ -5.0, '-3', null ];
-	t.equal( isNonPositiveNumberArray( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveNumberArray( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': -3.14,
 		'1': 0.0
 	};
-	t.equal( isNonPositiveNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray( arr ), true, 'returns true' );
 
 	arr = new Float32Array( [-5.0, -1.5] );
-	t.equal( isNonPositiveNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray( arr ), true, 'returns true' );
 
 	t.end();
 });
@@ -60,20 +60,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ -5.0, 0.0 ];
-	t.equal( isNonPositiveNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray.primitives( arr ), true, 'returns true' );
 
 	arr = [ new Number( -5 ), -1.0, -1.0 ];
-	t.equal( isNonPositiveNumberArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveNumberArray.primitives( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': -3.14,
 		'1': 0.0
 	};
-	t.equal( isNonPositiveNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray.primitives( arr ), true, 'returns true' );
 
 	arr = new Float32Array( [-5.0, -1.5] );
-	t.equal( isNonPositiveNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray.primitives( arr ), true, 'returns true' );
 
 	t.end();
 });
@@ -82,20 +82,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ new Number( -5 ), new Number( -5 ) ];
-	t.equal( isNonPositiveNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray.objects( arr ), true, 'returns true' );
 
 	arr = [ -5.0, 0.0 ];
-	t.equal( isNonPositiveNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveNumberArray.objects( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -3.14 ),
 		'1': new Number( 0.0 )
 	};
-	t.equal( isNonPositiveNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray.objects( arr ), true, 'returns true' );
 
 	arr = new Float32Array( [-5.0, -1.5] );
-	t.equal( isNonPositiveNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveNumberArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.js b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.js
index cabbe2f58e94..64e86fc02d18 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive number having a nonpositive number value', function test( t ) {
-	t.equal( typeof isNonPositiveNumber.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isNonPositiveNumber.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a nonpositive number value', function test( t ) {
-	t.equal( typeof isNonPositiveNumber.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isNonPositiveNumber.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.main.js
index 365c3a40b119..5d035c6846d4 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a nonpositive number value', function test( t ) {
-	t.equal( isNonPositiveNumber( -5.0 ), true, 'returns true' );
-	t.equal( isNonPositiveNumber( new Number( -5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNonPositiveNumber( -5.0 ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumber( new Number( -5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if not provided a number having a nonpositiv
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonPositiveNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonPositiveNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.object.js
index e6556370b487..e3d543d4464f 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a nonpositive number value', function test( t ) {
-	t.equal( isNonPositiveNumber( new Number( -5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNonPositiveNumber( new Number( -5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a nonpositive number value', function test( t ) {
-	t.equal( isNonPositiveNumber( -3.0 ), false, 'returns false' );
+	t.strictEqual( isNonPositiveNumber( -3.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonPositiveNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonPositiveNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.primitive.js
index 3c4c48fbc620..520bae6d7c9e 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a nonpositive number value', function test( t ) {
-	t.equal( isNonPositiveNumber( -3.0 ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumber( -3.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a nonpositive number value', function test( t ) {
-	t.equal( isNonPositiveNumber( new Number( -5.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isNonPositiveNumber( new Number( -5.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonPositiveNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonPositiveNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonsymmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-nonsymmetric-matrix/test/test.js
index 866eb0e471ac..18c9eb1fe7e5 100644
--- a/lib/node_modules/@stdlib/assert/is-nonsymmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonsymmetric-matrix/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided a non-symmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 3, 4 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isNonSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isNonSymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isNonSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isNonSymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 
 	function get( i, j ) {
@@ -67,13 +67,13 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 
 tape( 'the function returns `true` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isNonSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isNonSymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a non-symmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 2, 3 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isNonSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isNonSymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -92,7 +92,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isNonSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isNonSymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.equal( isNonSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isNonSymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 
 	function get( i, j ) {
@@ -141,7 +141,7 @@ tape( 'the function returns `false` if not provided a 2-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNonSymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNonSymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-null-array/test/test.js b/lib/node_modules/@stdlib/assert/is-null-array/test/test.js
index 333fc9c59a10..a422aa8a40be 100644
--- a/lib/node_modules/@stdlib/assert/is-null-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-null-array/test/test.js
@@ -36,20 +36,20 @@ tape( 'the function tests for an array-like object having only `null` values', f
 	var arr;
 
 	arr = [ null, null ];
-	t.equal( isNullArray( arr ), true, 'returns true' );
+	t.strictEqual( isNullArray( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': null,
 		'1': null
 	};
-	t.equal( isNullArray( arr ), true, 'returns true' );
+	t.strictEqual( isNullArray( arr ), true, 'returns true' );
 
 	arr = [ null, 3, null ];
-	t.equal( isNullArray( arr ), false, 'returns false' );
+	t.strictEqual( isNullArray( arr ), false, 'returns false' );
 
 	arr = [ null, void 0, false, null ];
-	t.equal( isNullArray( arr ), false, 'returns false' );
+	t.strictEqual( isNullArray( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-null/test/test.js b/lib/node_modules/@stdlib/assert/is-null/test/test.js
index c8eecb614caa..24b711cd03ab 100644
--- a/lib/node_modules/@stdlib/assert/is-null/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-null/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `null`', function test( t ) {
-	t.equal( isNull( null ), true, 'returns true' );
+	t.strictEqual( isNull( null ), true, 'returns true' );
 	t.end();
 });
 
@@ -53,7 +53,7 @@ tape( 'the function returns `false` if not provided `null`', function test( t )
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNull( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNull( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-numeric-array/test/test.js b/lib/node_modules/@stdlib/assert/is-numeric-array/test/test.js
index 559175ca6521..ca9ba786ab02 100644
--- a/lib/node_modules/@stdlib/assert/is-numeric-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-numeric-array/test/test.js
@@ -60,7 +60,7 @@ tape( 'the function returns `true` if provided a numeric array', function test(
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNumericArray( values[i] ), true, 'returns true when provided '+values[i] );
+		t.strictEqual( isNumericArray( values[i] ), true, 'returns true when provided '+values[i] );
 	}
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function returns `false` if not provided a numeric array', function t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isNumericArray( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isNumericArray( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-object-array/test/test.js b/lib/node_modules/@stdlib/assert/is-object-array/test/test.js
index 5b40e2579d34..1c13e0a5ea07 100644
--- a/lib/node_modules/@stdlib/assert/is-object-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-object-array/test/test.js
@@ -40,20 +40,20 @@ tape( 'the function tests for an array-like object containing only objects', fun
 		'type': 'object'
 	};
 	arr = [ obj, /.*/, {} ];
-	t.equal( isObjectArray( arr ), true, 'returns true' );
+	t.strictEqual( isObjectArray( arr ), true, 'returns true' );
 
 	arr = [ 5.0, {}, new Date() ];
-	t.equal( isObjectArray( arr ), false, 'returns false' );
+	t.strictEqual( isObjectArray( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': {},
 		'1': new Date()
 	};
-	t.equal( isObjectArray( arr ), true, 'returns true' );
+	t.strictEqual( isObjectArray( arr ), true, 'returns true' );
 
 	arr = [];
-	t.equal( isObjectArray( arr ), false, 'returns false when provided an empty array' );
+	t.strictEqual( isObjectArray( arr ), false, 'returns false when provided an empty array' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-object-like/test/test.array.js b/lib/node_modules/@stdlib/assert/is-object-like/test/test.array.js
index cdfd5218543b..d78fc4d06e43 100644
--- a/lib/node_modules/@stdlib/assert/is-object-like/test/test.array.js
+++ b/lib/node_modules/@stdlib/assert/is-object-like/test/test.array.js
@@ -41,13 +41,13 @@ tape( 'the function provides a method to test for an array of object-like elemen
 	};
 
 	arr = [ obj, [], {} ];
-	t.equal( isObjectLike.isObjectLikeArray( arr ), true, 'returns true' );
+	t.strictEqual( isObjectLike.isObjectLikeArray( arr ), true, 'returns true' );
 
 	arr = [ 2, {}, [] ];
-	t.equal( isObjectLike.isObjectLikeArray( arr ), false, 'returns false' );
+	t.strictEqual( isObjectLike.isObjectLikeArray( arr ), false, 'returns false' );
 
 	arr = [];
-	t.equal( isObjectLike.isObjectLikeArray( arr ), false, 'returns false when provided an empty array' );
+	t.strictEqual( isObjectLike.isObjectLikeArray( arr ), false, 'returns false when provided an empty array' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-object-like/test/test.js b/lib/node_modules/@stdlib/assert/is-object-like/test/test.js
index c1fa1e1cc224..2799dcbb6461 100644
--- a/lib/node_modules/@stdlib/assert/is-object-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-object-like/test/test.js
@@ -56,7 +56,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a function to test if a value is an array of object-like elements', function test( t ) {
-	t.equal( typeof isObjectLike.isObjectLikeArray, 'function', 'has method' );
+	t.strictEqual( typeof isObjectLike.isObjectLikeArray, 'function', 'has method' );
 	t.end();
 });
 
@@ -68,14 +68,14 @@ tape( 'the function returns a boolean indicating if a value is object-like', fun
 
 	values = [
 		'a',
-		new String( 'a' ), // eslint-disable-line no-new-wrappers
+		new String( 'a' ),
 		5,
-		new Number( 5 ), // eslint-disable-line no-new-wrappers
+		new Number( 5 ),
 		NaN,
 		true,
-		new Boolean( true ), // eslint-disable-line no-new-wrappers
+		new Boolean( true ),
 		false,
-		new Boolean( false ), // eslint-disable-line no-new-wrappers
+		new Boolean( false ),
 		void 0,
 		null,
 		[],
@@ -144,7 +144,7 @@ tape( 'the function returns a boolean indicating if a value is object-like', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isObjectLike( values[i] );
-		t.equal( bool, expected[i], 'returns '+expected[i]+' when provided '+values[i] );
+		t.strictEqual( bool, expected[i], 'returns '+expected[i]+' when provided '+values[i] );
 	}
 	t.end();
 });
@@ -154,7 +154,7 @@ opts = {
 };
 tape( 'the function supports Map objects', opts, function test( t ) {
 	var bool = isObjectLike( new Map() );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.end();
 });
 
@@ -163,7 +163,7 @@ opts = {
 };
 tape( 'the function supports WeakMap objects', opts, function test( t ) {
 	var bool = isObjectLike( new WeakMap() );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.end();
 });
 
@@ -172,7 +172,7 @@ opts = {
 };
 tape( 'the function supports Set objects', opts, function test( t ) {
 	var bool = isObjectLike( new Set() );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.end();
 });
 
@@ -181,7 +181,7 @@ opts = {
 };
 tape( 'the function supports WeakSet objects', opts, function test( t ) {
 	var bool = isObjectLike( new WeakSet() );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.end();
 });
 
@@ -190,7 +190,7 @@ opts = {
 };
 tape( 'the function supports Symbol objects', opts, function test( t ) {
 	var bool = isObjectLike( Symbol( 'beep' ) );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 	t.end();
 });
 
@@ -198,7 +198,7 @@ tape( 'the function supports custom objects', function test( t ) {
 	var bool;
 	function Person() {}
 	bool = isObjectLike( new Person() );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-object/test/test.js b/lib/node_modules/@stdlib/assert/is-object/test/test.js
index 288bc5b7477c..99ea1cdaa606 100644
--- a/lib/node_modules/@stdlib/assert/is-object/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-object/test/test.js
@@ -33,14 +33,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an object', function test( t ) {
-	t.equal( isObject( {} ), true, 'returns true' );
-	t.equal( isObject( Object.create( null ) ), true, 'returns true' );
+	t.strictEqual( isObject( {} ), true, 'returns true' );
+	t.strictEqual( isObject( Object.create( null ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `true` when provided object instances', function test( t ) {
-	t.equal( isObject( new Date() ), true, 'returns true when provided a Date object' );
-	t.equal( isObject( /.*/ ), true, 'returns true when provided a regular expression' );
+	t.strictEqual( isObject( new Date() ), true, 'returns true when provided a Date object' );
+	t.strictEqual( isObject( /.*/ ), true, 'returns true when provided a regular expression' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'the function returns `false` if not provided an object', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isObject( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isObject( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-odd/test/test.js b/lib/node_modules/@stdlib/assert/is-odd/test/test.js
index 39ac190e4234..583ebe07f2db 100644
--- a/lib/node_modules/@stdlib/assert/is-odd/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-odd/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive odd number', function test( t ) {
-	t.equal( typeof isOdd.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isOdd.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a value which is an odd number', function test( t ) {
-	t.equal( typeof isOdd.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isOdd.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-odd/test/test.main.js b/lib/node_modules/@stdlib/assert/is-odd/test/test.main.js
index 091aa3e51548..7f9a91204169 100644
--- a/lib/node_modules/@stdlib/assert/is-odd/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-odd/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an odd number', function test( t ) {
-	t.equal( isOdd( 5.0 ), true, 'returns true' );
-	t.equal( isOdd( new Number( 5 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isOdd( 5.0 ), true, 'returns true' );
+	t.strictEqual( isOdd( new Number( 5 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -59,7 +59,7 @@ tape( 'the function returns `false` if not provided an odd number', function tes
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isOdd( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isOdd( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-odd/test/test.object.js b/lib/node_modules/@stdlib/assert/is-odd/test/test.object.js
index a2efe9c86880..8250e540b712 100644
--- a/lib/node_modules/@stdlib/assert/is-odd/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-odd/test/test.object.js
@@ -34,14 +34,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an odd number object', function test( t ) {
-	t.equal( isOdd( new Number( 5 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
-	t.equal( isOdd( new Number( -3 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isOdd( new Number( 5 ) ), true, 'returns true' );
+	t.strictEqual( isOdd( new Number( -3 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is odd', function test( t ) {
-	t.equal( isOdd( 5.0 ), false, 'returns false' );
-	t.equal( isOdd( -1.0 ), false, 'returns false' );
+	t.strictEqual( isOdd( 5.0 ), false, 'returns false' );
+	t.strictEqual( isOdd( -1.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -64,7 +64,7 @@ tape( 'the function returns `false` if not provided an odd number', function tes
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isOdd( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isOdd( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-odd/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-odd/test/test.primitive.js
index 3fc9beedad56..01f0e1099183 100644
--- a/lib/node_modules/@stdlib/assert/is-odd/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-odd/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive odd number', function test( t ) {
-	t.equal( isOdd( -5.0 ), true, 'returns true' );
+	t.strictEqual( isOdd( -5.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number is odd', function test( t ) {
-	t.equal( isOdd( new Number( 5.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isOdd( new Number( 5.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -62,7 +62,7 @@ tape( 'the function returns `false` if not provided an odd number', function tes
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isOdd( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isOdd( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-pascalcase/test/test.js b/lib/node_modules/@stdlib/assert/is-pascalcase/test/test.js
index 3715054a1540..bdcaeedabd04 100644
--- a/lib/node_modules/@stdlib/assert/is-pascalcase/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-pascalcase/test/test.js
@@ -43,7 +43,7 @@ tape( 'the function returns `true` if provided a string in Pascal case', functio
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPascalcase( values[i] ), true, 'returns true' );
+		t.strictEqual( isPascalcase( values[i] ), true, 'returns true' );
 	}
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'the function returns `false` if not provided a string in Pascal case', fu
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPascalcase( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPascalcase( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
@@ -91,7 +91,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPascalcase( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPascalcase( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-persymmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-persymmetric-matrix/test/test.js
index dc53ae2d4566..c7308b982541 100644
--- a/lib/node_modules/@stdlib/assert/is-persymmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-persymmetric-matrix/test/test.js
@@ -48,7 +48,7 @@ tape( 'the function returns `true` if provided a persymmetric matrix', function
 	];
 	arr = ndarray( 'generic', buffer, [ 4, 4 ], [ 4, 1 ], 0, 'row-major' );
 
-	t.equal( isPersymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isPersymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isPersymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isPersymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 
 	function get( i, j ) {
@@ -77,13 +77,13 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 
 tape( 'the function returns `false` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isPersymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a persymmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 2, 3 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isPersymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -102,7 +102,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.equal( isPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isPersymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -121,7 +121,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.equal( isPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isPersymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 
 	function get( i, j ) {
@@ -151,7 +151,7 @@ tape( 'the function returns `false` if not provided a 2-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPersymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPersymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-plain-object/test/test.js b/lib/node_modules/@stdlib/assert/is-plain-object/test/test.js
index 60f92efb5f04..47679b42abe0 100644
--- a/lib/node_modules/@stdlib/assert/is-plain-object/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-plain-object/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a plain object', function test( t ) {
-	t.equal( isPlainObject( {} ), true, 'returns true' );
+	t.strictEqual( isPlainObject( {} ), true, 'returns true' );
 	t.end();
 });
 
@@ -45,7 +45,7 @@ tape( 'the function returns `true` if provided an object with no prototype', fun
 	var bool;
 
 	bool = isPlainObject( Object.create( null ) );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 	t.end();
 });
 
@@ -64,7 +64,7 @@ tape( 'the function returns `false` if not provided an object', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPlainObject( values[i] ), false, 'returns false' );
+		t.strictEqual( isPlainObject( values[i] ), false, 'returns false' );
 	}
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns `false` if provided a value having an own `construct
 		'constructor': Object
 	};
 
-	t.equal( isPlainObject( obj ), false, 'returns false' );
+	t.strictEqual( isPlainObject( obj ), false, 'returns false' );
 	t.end();
 });
 
@@ -86,7 +86,7 @@ tape( 'the function returns `false` if provided a value whose prototype lacks a
 	Foo.prototype.constructor = Foo;
 	delete Foo.prototype.isPrototypeOf;
 
-	t.equal( isPlainObject( new Foo() ), false, 'returns false' );
+	t.strictEqual( isPlainObject( new Foo() ), false, 'returns false' );
 	t.end();
 });
 
@@ -98,7 +98,7 @@ tape( 'the function returns `false` if provided a value whose prototype has a `i
 	Foo.prototype.constructor = Foo;
 	Foo.prototype.isPrototypeOf = 'beep';
 
-	t.equal( isPlainObject( new Foo() ), false, 'returns false' );
+	t.strictEqual( isPlainObject( new Foo() ), false, 'returns false' );
 	t.end();
 });
 
@@ -108,7 +108,7 @@ tape( 'the function returns `false` if provided a value whose prototype lacks a
 	}
 	Foo.prototype = {};
 
-	t.equal( isPlainObject( new Foo() ), false, 'returns false' );
+	t.strictEqual( isPlainObject( new Foo() ), false, 'returns false' );
 	t.end();
 });
 
@@ -119,7 +119,7 @@ tape( 'the function returns `false` if provided a value whose prototype has a co
 	Foo.prototype = Object.create( {} );
 	Foo.prototype.constructor = 'beep';
 
-	t.equal( isPlainObject( new Foo() ), false, 'returns false' );
+	t.strictEqual( isPlainObject( new Foo() ), false, 'returns false' );
 	t.end();
 });
 
@@ -135,7 +135,7 @@ tape( 'the function returns `false` if provided a value whose prototype has a co
 	isPlainObject = proxyquire( './../lib/main.js', {
 		'@stdlib/utils/native-class': nativeClass
 	});
-	t.equal( isPlainObject( new Foo() ), false, 'returns false' );
+	t.strictEqual( isPlainObject( new Foo() ), false, 'returns false' );
 	t.end();
 
 	function nativeClass() {
@@ -150,7 +150,7 @@ tape( 'the function returns `true` if provided a value whose prototype equals th
 	Foo.prototype = Object.prototype;
 	Foo.prototype.constructor = Foo;
 
-	t.equal( isPlainObject( new Foo() ), true, 'returns true' );
+	t.strictEqual( isPlainObject( new Foo() ), true, 'returns true' );
 	t.end();
 });
 
@@ -166,7 +166,7 @@ tape( 'the function returns `false` if provided a value whose prototype does not
 	Foo.prototype.isPrototypeOf = function beep() {};
 	Foo.prototype.boop = 'boop';
 
-	t.equal( isPlainObject( new Foo() ), false, 'returns false' );
+	t.strictEqual( isPlainObject( new Foo() ), false, 'returns false' );
 	t.end();
 });
 
@@ -190,6 +190,6 @@ tape( 'the function returns `true` if provided a value whose prototype does not
 		'value': function foo() {}
 	});
 
-	t.equal( isPlainObject( new Foo() ), true, 'returns true' );
+	t.strictEqual( isPlainObject( new Foo() ), true, 'returns true' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.js b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.js
index 6207a66a79e2..5891680baadb 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive number having a finite positive value', function test( t ) {
-	t.equal( typeof isPositiveFinite.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isPositiveFinite.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a finite positive value', function test( t ) {
-	t.equal( typeof isPositiveFinite.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isPositiveFinite.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.main.js b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.main.js
index 50e2fd269a7a..82c6d6417010 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a positive finite number value', function test( t ) {
-	t.equal( isPositiveFinite( 5.0 ), true, 'returns true' );
-	t.equal( isPositiveFinite( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isPositiveFinite( 5.0 ), true, 'returns true' );
+	t.strictEqual( isPositiveFinite( new Number( 5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -59,7 +59,7 @@ tape( 'the function returns `false` if not provided a number having a positive f
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPositiveFinite( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPositiveFinite( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.object.js b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.object.js
index b7680b5305ab..73b74baf9c11 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.object.js
@@ -34,17 +34,17 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a finite positive value', function test( t ) {
-	t.equal( isPositiveFinite( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isPositiveFinite( new Number( 5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a finite positive value', function test( t ) {
-	t.equal( isPositiveFinite( 3.0 ), false, 'returns false' );
+	t.strictEqual( isPositiveFinite( 3.0 ), false, 'returns false' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided positive infinity', function test( t ) {
-	t.equal( isPositiveFinite( new Number( 5.0/0.0 ) ), false, 'returns false' );
+	t.strictEqual( isPositiveFinite( new Number( 5.0/0.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -68,7 +68,7 @@ tape( 'the function returns `false` if not provided a positive finite number', f
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPositiveFinite( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPositiveFinite( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.primitive.js
index 6a24e7457461..727de3a64bf1 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.primitive.js
@@ -34,17 +34,17 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a finite positive value', function test( t ) {
-	t.equal( isPositiveFinite( 3.0 ), true, 'returns true' );
+	t.strictEqual( isPositiveFinite( 3.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided positive infinity', function test( t ) {
-	t.equal( isPositiveFinite( 1.0/0.0 ), false, 'returns false' );
+	t.strictEqual( isPositiveFinite( 1.0/0.0 ), false, 'returns false' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a finite positive value', function test( t ) {
-	t.equal( isPositiveFinite( new Number( 5.0 ) ), false, 'returns false' );
+	t.strictEqual( isPositiveFinite( new Number( 5.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -66,7 +66,7 @@ tape( 'the function returns `false` if not provided a positive finite number', f
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPositiveFinite( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPositiveFinite( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-integer-array/test/test.js b/lib/node_modules/@stdlib/assert/is-positive-integer-array/test/test.js
index aa2f726b15d9..1ac9592d49ab 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-integer-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-integer-array/test/test.js
@@ -40,20 +40,20 @@ tape( 'the function tests for a generic number array having only positive intege
 	var arr;
 
 	arr = [ 5.0, new Number( 5 ), 1.0 ];
-	t.equal( isPositiveIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray( arr ), true, 'returns true' );
 
 	arr = [ 5.0, '3', null ];
-	t.equal( isPositiveIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveIntegerArray( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': 5,
 		'1': 1
 	};
-	t.equal( isPositiveIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray( arr ), true, 'returns true' );
 
 	arr = new Int32Array( [ 5, 2, 0 ] );
-	t.equal( isPositiveIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveIntegerArray( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -62,20 +62,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ 5.0, 1.0 ];
-	t.equal( isPositiveIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray.primitives( arr ), true, 'returns true' );
 
 	arr = [ new Number( 5 ), 1.0, 1.0 ];
-	t.equal( isPositiveIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveIntegerArray.primitives( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': 5,
 		'1': 1
 	};
-	t.equal( isPositiveIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray.primitives( arr ), true, 'returns true' );
 
 	arr = new Int16Array( [ 5, 2, 1 ] );
-	t.equal( isPositiveIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray.primitives( arr ), true, 'returns true' );
 
 	t.end();
 });
@@ -84,20 +84,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( 5 ), new Number( 2 ) ];
-	t.equal( isPositiveIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray.objects( arr ), true, 'returns true' );
 
 	arr = [ 5.0, 1.0, 1.0 ];
-	t.equal( isPositiveIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveIntegerArray.objects( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 5 ),
 		'1': new Number( 1 )
 	};
-	t.equal( isPositiveIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray.objects( arr ), true, 'returns true' );
 
 	arr = new Uint32Array( [ 5, 1 ] );
-	t.equal( isPositiveIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveIntegerArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.js b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.js
index f2206a3b5199..bb76b34bdd96 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive number having a positive integer value', function test( t ) {
-	t.equal( typeof isPositiveInteger.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isPositiveInteger.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a positive integer value', function test( t ) {
-	t.equal( typeof isPositiveInteger.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isPositiveInteger.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.main.js b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.main.js
index 198e396111fe..43af9d38ecb5 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a positive integer value', function test( t ) {
-	t.equal( isPositiveInteger( 5.0 ), true, 'returns true' );
-	t.equal( isPositiveInteger( new Number( 5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isPositiveInteger( 5.0 ), true, 'returns true' );
+	t.strictEqual( isPositiveInteger( new Number( 5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `false` if not provided a number having a positive i
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPositiveInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPositiveInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.object.js b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.object.js
index 9389a7c1c895..58dd32a0454d 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a positive integer value', function test( t ) {
-	t.equal( isPositiveInteger( new Number( 5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isPositiveInteger( new Number( 5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a positive integer value', function test( t ) {
-	t.equal( isPositiveInteger( 3.0 ), false, 'returns false' );
+	t.strictEqual( isPositiveInteger( 3.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPositiveInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPositiveInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.primitive.js
index 18bc0a64c44a..63d1997d752e 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a positive integer value', function test( t ) {
-	t.equal( isPositiveInteger( 3.0 ), true, 'returns true' );
+	t.strictEqual( isPositiveInteger( 3.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a positive integer value', function test( t ) {
-	t.equal( isPositiveInteger( new Number( 5.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isPositiveInteger( new Number( 5.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPositiveInteger( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPositiveInteger( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-number-array/test/test.js b/lib/node_modules/@stdlib/assert/is-positive-number-array/test/test.js
index a922194d4a46..630abe7d66b2 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-number-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-number-array/test/test.js
@@ -38,20 +38,20 @@ tape( 'the function tests for an array-like object containing only positive numb
 	var arr;
 
 	arr = [ 5.0, new Number( 5 ), 1.0 ];
-	t.equal( isPositiveNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray( arr ), true, 'returns true' );
 
 	arr = [ 5.0, '3', null ];
-	t.equal( isPositiveNumberArray( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveNumberArray( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': 3.14,
 		'1': 2.0
 	};
-	t.equal( isPositiveNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray( arr ), true, 'returns true' );
 
 	arr = new Float32Array( [ 5.0, 1.5 ] );
-	t.equal( isPositiveNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray( arr ), true, 'returns true' );
 
 	t.end();
 });
@@ -60,20 +60,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ 5.0, 2.0 ];
-	t.equal( isPositiveNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray.primitives( arr ), true, 'returns true' );
 
 	arr = [ new Number( 5 ), 1.0, 1.0 ];
-	t.equal( isPositiveNumberArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveNumberArray.primitives( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': 3.14,
 		'1': 1.0
 	};
-	t.equal( isPositiveNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray.primitives( arr ), true, 'returns true' );
 
 	arr = new Float32Array( [ 5.0, 1.5 ] );
-	t.equal( isPositiveNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray.primitives( arr ), true, 'returns true' );
 
 	t.end();
 });
@@ -82,20 +82,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ new Number( 5 ), new Number( 5 ) ];
-	t.equal( isPositiveNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray.objects( arr ), true, 'returns true' );
 
 	arr = [ 5.0, 1.0 ];
-	t.equal( isPositiveNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveNumberArray.objects( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 3.14 ),
 		'1': new Number( 2.0 )
 	};
-	t.equal( isPositiveNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray.objects( arr ), true, 'returns true' );
 
 	arr = new Float32Array( [ 5.0, 1.5 ] );
-	t.equal( isPositiveNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveNumberArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.js b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.js
index 8e36e00fcd78..08be9e0638c5 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive number having a positive value', function test( t ) {
-	t.equal( typeof isPositiveNumber.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isPositiveNumber.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a positive value', function test( t ) {
-	t.equal( typeof isPositiveNumber.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isPositiveNumber.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.main.js
index 8e35340d4398..8a60ce976470 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a positive number value', function test( t ) {
-	t.equal( isPositiveNumber( 5.0 ), true, 'returns true' );
-	t.equal( isPositiveNumber( new Number( 5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isPositiveNumber( 5.0 ), true, 'returns true' );
+	t.strictEqual( isPositiveNumber( new Number( 5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `false` if not provided a number having a positive n
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPositiveNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPositiveNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.object.js
index ab1f0c2a140a..9845d6e244ad 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a positive value', function test( t ) {
-	t.equal( isPositiveNumber( new Number( 5.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isPositiveNumber( new Number( 5.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a positive value', function test( t ) {
-	t.equal( isPositiveNumber( 3.0 ), false, 'returns false' );
+	t.strictEqual( isPositiveNumber( 3.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPositiveNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPositiveNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.primitive.js
index 2b06c674104a..233a383162fc 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a positive value', function test( t ) {
-	t.equal( isPositiveNumber( 3.0 ), true, 'returns true' );
+	t.strictEqual( isPositiveNumber( 3.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a positive value', function test( t ) {
-	t.equal( isPositiveNumber( new Number( 5.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isPositiveNumber( new Number( 5.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPositiveNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPositiveNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-prime/test/test.js b/lib/node_modules/@stdlib/assert/is-prime/test/test.js
index 37d9a49ba39f..6ccd9aedddf2 100644
--- a/lib/node_modules/@stdlib/assert/is-prime/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-prime/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test primitives', function test( t ) {
-	t.equal( typeof isPrime.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isPrime.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test objects', function test( t ) {
-	t.equal( typeof isPrime.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isPrime.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-prime/test/test.main.js b/lib/node_modules/@stdlib/assert/is-prime/test/test.main.js
index 0fc9e28c9626..9813872a479e 100644
--- a/lib/node_modules/@stdlib/assert/is-prime/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-prime/test/test.main.js
@@ -41,22 +41,22 @@ tape( 'the function returns `true` if provided a prime number', function test( t
 	var i;
 	var j;
 
-	t.equal( isPrime( 2 ), true, 'returns expected value' );
-	t.equal( isPrime( 3 ), true, 'returns expected value' );
-	t.equal( isPrime( 5 ), true, 'returns expected value' );
-	t.equal( isPrime( 7 ), true, 'returns expected value' );
+	t.strictEqual( isPrime( 2 ), true, 'returns expected value' );
+	t.strictEqual( isPrime( 3 ), true, 'returns expected value' );
+	t.strictEqual( isPrime( 5 ), true, 'returns expected value' );
+	t.strictEqual( isPrime( 7 ), true, 'returns expected value' );
 
-	t.equal( isPrime( new Number( 2 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isPrime( new Number( 3 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isPrime( new Number( 5 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isPrime( new Number( 7 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isPrime( new Number( 2 ) ), true, 'returns expected value' );
+	t.strictEqual( isPrime( new Number( 3 ) ), true, 'returns expected value' );
+	t.strictEqual( isPrime( new Number( 5 ) ), true, 'returns expected value' );
+	t.strictEqual( isPrime( new Number( 7 ) ), true, 'returns expected value' );
 
 	N = PRIMES.length - 1;
 	for ( i = 0; i < 1e3; i++ ) {
 		j = discreteUniform( 0, N );
 		p = PRIMES[ j ];
-		t.equal( isPrime( p ), true, 'returns expected value for '+p );
-		t.equal( isPrime( new Number( p ) ), true, 'returns expected value for Number('+p+')' ); // eslint-disable-line no-new-wrappers
+		t.strictEqual( isPrime( p ), true, 'returns expected value for '+p );
+		t.strictEqual( isPrime( new Number( p ) ), true, 'returns expected value for Number('+p+')' );
 	}
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function returns `false` if not provided a prime number', function te
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPrime( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPrime( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-prime/test/test.object.js b/lib/node_modules/@stdlib/assert/is-prime/test/test.object.js
index 9411bacc938d..986ab02dae92 100644
--- a/lib/node_modules/@stdlib/assert/is-prime/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-prime/test/test.object.js
@@ -41,24 +41,24 @@ tape( 'the function returns `true` if provided a number object having a prime nu
 	var i;
 	var j;
 
-	t.equal( isPrime( new Number( 2 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isPrime( new Number( 3 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isPrime( new Number( 5 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
-	t.equal( isPrime( new Number( 7 ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isPrime( new Number( 2 ) ), true, 'returns expected value' );
+	t.strictEqual( isPrime( new Number( 3 ) ), true, 'returns expected value' );
+	t.strictEqual( isPrime( new Number( 5 ) ), true, 'returns expected value' );
+	t.strictEqual( isPrime( new Number( 7 ) ), true, 'returns expected value' );
 
 	N = PRIMES.length - 1;
 	for ( i = 0; i < 1e3; i++ ) {
 		j = discreteUniform( 0, N );
 		p = PRIMES[ j ];
-		t.equal( isPrime( new Number( p ) ), true, 'returns expected value for Number('+p+')' ); // eslint-disable-line no-new-wrappers
+		t.strictEqual( isPrime( new Number( p ) ), true, 'returns expected value for Number('+p+')' );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive prime number', function test( t ) {
-	t.equal( isPrime( 5.0 ), false, 'returns false' );
-	t.equal( isPrime( 7.0 ), false, 'returns false' );
-	t.equal( isPrime( 11.0 ), false, 'returns false' );
+	t.strictEqual( isPrime( 5.0 ), false, 'returns false' );
+	t.strictEqual( isPrime( 7.0 ), false, 'returns false' );
+	t.strictEqual( isPrime( 11.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -68,9 +68,9 @@ tape( 'the function returns `false` if not provided a prime number', function te
 
 	values = [
 		'5',
-		new Number( 4.0 ), // eslint-disable-line no-new-wrappers
-		new Number( 8.0 ), // eslint-disable-line no-new-wrappers
-		new Number( 21.0 ), // eslint-disable-line no-new-wrappers
+		new Number( 4.0 ),
+		new Number( 8.0 ),
+		new Number( 21.0 ),
 		null,
 		true,
 		NaN,
@@ -84,7 +84,7 @@ tape( 'the function returns `false` if not provided a prime number', function te
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPrime( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPrime( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-prime/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-prime/test/test.primitive.js
index 4a41a85ec282..966c7c21de49 100644
--- a/lib/node_modules/@stdlib/assert/is-prime/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-prime/test/test.primitive.js
@@ -41,24 +41,24 @@ tape( 'the function returns `true` if provided a primitive prime number', functi
 	var i;
 	var j;
 
-	t.equal( isPrime( 2 ), true, 'returns expected value' );
-	t.equal( isPrime( 3 ), true, 'returns expected value' );
-	t.equal( isPrime( 5 ), true, 'returns expected value' );
-	t.equal( isPrime( 7 ), true, 'returns expected value' );
+	t.strictEqual( isPrime( 2 ), true, 'returns expected value' );
+	t.strictEqual( isPrime( 3 ), true, 'returns expected value' );
+	t.strictEqual( isPrime( 5 ), true, 'returns expected value' );
+	t.strictEqual( isPrime( 7 ), true, 'returns expected value' );
 
 	N = PRIMES.length - 1;
 	for ( i = 0; i < 1e3; i++ ) {
 		j = discreteUniform( 0, N );
 		p = PRIMES[ j ];
-		t.equal( isPrime( p ), true, 'returns expected value for '+p );
+		t.strictEqual( isPrime( p ), true, 'returns expected value for '+p );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object', function test( t ) {
-	t.equal( isPrime( new Number( 5.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
-	t.equal( isPrime( new Number( 7.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
-	t.equal( isPrime( new Number( 11.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isPrime( new Number( 5.0 ) ), false, 'returns false' );
+	t.strictEqual( isPrime( new Number( 7.0 ) ), false, 'returns false' );
+	t.strictEqual( isPrime( new Number( 11.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -84,7 +84,7 @@ tape( 'the function returns `false` if not provided a prime number', function te
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPrime( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPrime( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-primitive-array/test/test.js b/lib/node_modules/@stdlib/assert/is-primitive-array/test/test.js
index 6ad618b43e6f..e694520c13e7 100644
--- a/lib/node_modules/@stdlib/assert/is-primitive-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-primitive-array/test/test.js
@@ -38,10 +38,10 @@ tape( 'the function tests for an array-like object containing only primitives',
 	var arr;
 
 	arr = [ 'abc', 123, null, NaN, undefined ];
-	t.equal( isPrimitiveArray( arr ), true, 'returns true' );
+	t.strictEqual( isPrimitiveArray( arr ), true, 'returns true' );
 
 	arr = [ 5.0, '5.0', new Number( 2 ) ];
-	t.equal( isPrimitiveArray( arr ), false, 'returns false' );
+	t.strictEqual( isPrimitiveArray( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 3,
@@ -49,13 +49,13 @@ tape( 'the function tests for an array-like object containing only primitives',
 		'1': '5.0',
 		'2': false
 	};
-	t.equal( isPrimitiveArray( arr ), true, 'returns true' );
+	t.strictEqual( isPrimitiveArray( arr ), true, 'returns true' );
 
 	arr = new Uint8Array( [ 1, 2, 3, 4, 5 ] );
-	t.equal( isPrimitiveArray( arr ), true, 'returns true' );
+	t.strictEqual( isPrimitiveArray( arr ), true, 'returns true' );
 
 	arr = [ {}, new String( 'abc' ) ];
-	t.equal( isPrimitiveArray( arr ), false, 'returns false' );
+	t.strictEqual( isPrimitiveArray( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-primitive/test/test.js b/lib/node_modules/@stdlib/assert/is-primitive/test/test.js
index 4bdf9e1aae99..ecc02bc5afbd 100644
--- a/lib/node_modules/@stdlib/assert/is-primitive/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-primitive/test/test.js
@@ -59,7 +59,7 @@ tape( 'the function returns `true` if provided a primitive (ES5)', function test
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPrimitive( values[i] ), true, 'returns true' );
+		t.strictEqual( isPrimitive( values[i] ), true, 'returns true' );
 	}
 	t.end();
 });
@@ -68,7 +68,7 @@ opts = {
 	'skip': !hasSymbols
 };
 tape( 'the function returns `true` if provided a `Symbol` (ES6/ES2015)', opts, function test( t ) {
-	t.equal( isPrimitive( Symbol( 'symbol' ) ), true, 'returns true' );
+	t.strictEqual( isPrimitive( Symbol( 'symbol' ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -76,7 +76,7 @@ opts = {
 	'skip': !hasBigInts
 };
 tape( 'the function returns `true` if provided a `BigInt` (ES2020)', opts, function test( t ) {
-	t.equal( isPrimitive( BigInt( '1' ) ), true, 'returns true' );
+	t.strictEqual( isPrimitive( BigInt( '1' ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -85,18 +85,18 @@ tape( 'the function returns `false` if not provided a primitive', function test(
 	var i;
 
 	values = [
-		new Boolean(), // eslint-disable-line no-new-wrappers
-		new String(), // eslint-disable-line no-new-wrappers
-		new Array(), // eslint-disable-line no-array-constructor
+		new Boolean(),
+		new String(),
+		new Array(), // eslint-disable-line stdlib/no-new-array, no-array-constructor
 		new Object(),
-		new Number(), // eslint-disable-line no-new-wrappers
+		new Number(),
 		function noop() {},
 		[],
 		{}
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPrimitive( values[i] ), false, 'returns false for value: '+values[i] );
+		t.strictEqual( isPrimitive( values[i] ), false, 'returns false for value: '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-prng-like/test/test.js b/lib/node_modules/@stdlib/assert/is-prng-like/test/test.js
index c4eafed5d465..6eec263b8c5d 100644
--- a/lib/node_modules/@stdlib/assert/is-prng-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-prng-like/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a PRNG', function test( t ) {
-	t.equal( isPRNGLike( randu ), true, 'returns expected value' );
+	t.strictEqual( isPRNGLike( randu ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -47,7 +47,7 @@ tape( 'the function returns `true` if provided a PRNG-like function', function t
 	rand.state = null;
 	rand.seed = null;
 
-	t.equal( isPRNGLike( rand ), true, 'returns expected value' );
+	t.strictEqual( isPRNGLike( rand ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -69,7 +69,7 @@ tape( 'the function returns `false` if not provided a PRNG-like value', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isPRNGLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isPRNGLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-probability-array/test/test.js b/lib/node_modules/@stdlib/assert/is-probability-array/test/test.js
index 8f8f31bd8bce..a3b0127e9692 100644
--- a/lib/node_modules/@stdlib/assert/is-probability-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-probability-array/test/test.js
@@ -37,24 +37,24 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function tests for an array-like object containing only probabilities', function test( t ) {
 	var arr;
 
-	arr = [ 0.9, new Number( 0.8 ), 0.0 ]; // eslint-disable-line no-new-wrappers
-	t.equal( isProbabilityArray( arr ), true, 'returns true' );
+	arr = [ 0.9, new Number( 0.8 ), 0.0 ];
+	t.strictEqual( isProbabilityArray( arr ), true, 'returns true' );
 
 	arr = new Float64Array( [ 0.9, 0.5, 0.3 ] );
-	t.equal( isProbabilityArray( arr ), true, 'returns true' );
+	t.strictEqual( isProbabilityArray( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': 0.3,
 		'1': 0.8
 	};
-	t.equal( isProbabilityArray( arr ), true, 'returns true' );
+	t.strictEqual( isProbabilityArray( arr ), true, 'returns true' );
 
 	arr = [ 0.9, '3', null ];
-	t.equal( isProbabilityArray( arr ), false, 'returns false' );
+	t.strictEqual( isProbabilityArray( arr ), false, 'returns false' );
 
 	arr = new Float64Array( [ 0.9, NaN, 0.3 ] );
-	t.equal( isProbabilityArray( arr ), false, 'returns false' );
+	t.strictEqual( isProbabilityArray( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -63,13 +63,13 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ 1.0, 0.0 ];
-	t.equal( isProbabilityArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isProbabilityArray.primitives( arr ), true, 'returns true' );
 
 	arr = new Float64Array( [ 0.9, 0.5, 0.3 ] );
-	t.equal( isProbabilityArray( arr ), true, 'returns true' );
+	t.strictEqual( isProbabilityArray( arr ), true, 'returns true' );
 
-	arr = [ new Number( 5 ), 1.0, 1.0 ]; // eslint-disable-line no-new-wrappers
-	t.equal( isProbabilityArray.primitives( arr ), false, 'returns false' );
+	arr = [ new Number( 5 ), 1.0, 1.0 ];
+	t.strictEqual( isProbabilityArray.primitives( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -77,18 +77,18 @@ tape( 'the function provides a method to test for an array-like object containin
 tape( 'the function provides a method to test for an array-like object containing only containing only Number objects whose values are probabilities', function test( t ) {
 	var arr;
 
-	arr = [ new Number( 0.5 ), new Number( 0.5 ) ]; // eslint-disable-line no-new-wrappers
-	t.equal( isProbabilityArray.objects( arr ), true, 'returns true' );
+	arr = [ new Number( 0.5 ), new Number( 0.5 ) ];
+	t.strictEqual( isProbabilityArray.objects( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
-		'0': new Number( 0.3 ), // eslint-disable-line no-new-wrappers
-		'1': new Number( 0.8 )  // eslint-disable-line no-new-wrappers
+		'0': new Number( 0.3 ),
+		'1': new Number( 0.8 )
 	};
-	t.equal( isProbabilityArray( arr ), true, 'returns true' );
+	t.strictEqual( isProbabilityArray( arr ), true, 'returns true' );
 
 	arr = [ 0.5, 0.0 ];
-	t.equal( isProbabilityArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isProbabilityArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-probability/test/test.js b/lib/node_modules/@stdlib/assert/is-probability/test/test.js
index 0c4d48188d3e..8ba0fd8ff8ca 100644
--- a/lib/node_modules/@stdlib/assert/is-probability/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-probability/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive probability', function test( t ) {
-	t.equal( typeof isProbability.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isProbability.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a number object having a probability value', function test( t ) {
-	t.equal( typeof isProbability.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isProbability.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-probability/test/test.main.js b/lib/node_modules/@stdlib/assert/is-probability/test/test.main.js
index 369db33028f6..69029d9a6883 100644
--- a/lib/node_modules/@stdlib/assert/is-probability/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-probability/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a probability', function test( t ) {
-	t.equal( isProbability( 0.5 ), true, 'returns true' );
-	t.equal( isProbability( new Number( 0.5 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isProbability( 0.5 ), true, 'returns true' );
+	t.strictEqual( isProbability( new Number( 0.5 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `false` if not provided a probability', function tes
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isProbability( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isProbability( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-probability/test/test.object.js b/lib/node_modules/@stdlib/assert/is-probability/test/test.object.js
index 42c4ee7f5f40..d8009080d335 100644
--- a/lib/node_modules/@stdlib/assert/is-probability/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-probability/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a probability value', function test( t ) {
-	t.equal( isProbability( new Number( 0.33 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isProbability( new Number( 0.33 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive probability', function test( t ) {
-	t.equal( isProbability( 0.33 ), false, 'returns false' );
+	t.strictEqual( isProbability( 0.33 ), false, 'returns false' );
 	t.end();
 });
 
@@ -62,7 +62,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isProbability( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isProbability( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-probability/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-probability/test/test.primitive.js
index 66a47d03b242..da0194ea520a 100644
--- a/lib/node_modules/@stdlib/assert/is-probability/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-probability/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive probability', function test( t ) {
-	t.equal( isProbability( 0.11 ), true, 'returns true' );
+	t.strictEqual( isProbability( 0.11 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object', function test( t ) {
-	t.equal( isProbability( new Number( 0.11 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isProbability( new Number( 0.11 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -59,7 +59,7 @@ tape( 'the function returns `false` if not provided a number', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isProbability( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isProbability( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-read-only-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-read-only-property-in/test/test.js
index b32c572b1386..707cc669cebb 100644
--- a/lib/node_modules/@stdlib/assert/is-read-only-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-read-only-property-in/test/test.js
@@ -66,16 +66,16 @@ tape( 'the function returns `true` if an object property is read-only', function
 	});
 
 	bool = isReadOnlyPropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadOnlyPropertyIn( obj, 'b' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadOnlyPropertyIn( obj, 'c' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadOnlyPropertyIn( obj, 'd' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -108,10 +108,10 @@ tape( 'the function returns `true` if provided an inherited property which is re
 	obj = new Foo();
 
 	bool = isReadOnlyPropertyIn( obj, 'bar' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadOnlyPropertyIn( obj, 'beep' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -133,19 +133,19 @@ tape( 'the function returns `false` if an object property is not read-only', fun
 		'a': 'b'
 	};
 	bool = isReadOnlyPropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyPropertyIn( [ 1, 2, 3 ], '1' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyPropertyIn( [ 1, 2, 3 ], 1 );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyPropertyIn( new Foo(), 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyPropertyIn( [ 'a' ], 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -156,7 +156,7 @@ tape( 'the function returns `false` if an object property is not read-only', fun
 	});
 
 	bool = isReadOnlyPropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 
@@ -174,10 +174,10 @@ tape( 'the function returns `false` if an object property is not read-only', fun
 	});
 
 	bool = isReadOnlyPropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyPropertyIn( obj, 'b' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -194,10 +194,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isReadOnlyPropertyIn( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isReadOnlyPropertyIn( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -231,16 +231,16 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isReadOnlyPropertyIn( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyPropertyIn( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyPropertyIn( obj, 'e' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyPropertyIn( obj, 'f' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -257,13 +257,13 @@ tape( 'the function returns `false` if provided an inherited property which is n
 	var bool;
 
 	bool = isReadOnlyPropertyIn( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyPropertyIn( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyPropertyIn( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -272,7 +272,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isReadOnlyPropertyIn( 'beep', 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-read-only-property/test/test.js b/lib/node_modules/@stdlib/assert/is-read-only-property/test/test.js
index f8f167438321..5fc0976ff9d1 100644
--- a/lib/node_modules/@stdlib/assert/is-read-only-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-read-only-property/test/test.js
@@ -66,16 +66,16 @@ tape( 'the function returns `true` if an object property is read-only', function
 	});
 
 	bool = isReadOnlyProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadOnlyProperty( obj, 'b' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadOnlyProperty( obj, 'c' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadOnlyProperty( obj, 'd' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -97,19 +97,19 @@ tape( 'the function returns `false` if an object property is not read-only', fun
 		'a': 'b'
 	};
 	bool = isReadOnlyProperty( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyProperty( [ 1, 2, 3 ], '1' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyProperty( [ 1, 2, 3 ], 1 );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyProperty( new Foo(), 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyProperty( [ 'a' ], 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -120,7 +120,7 @@ tape( 'the function returns `false` if an object property is not read-only', fun
 	});
 
 	bool = isReadOnlyProperty( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -131,7 +131,7 @@ tape( 'the function returns `false` if an object property is not read-only', fun
 	});
 
 	bool = isReadOnlyProperty( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -148,10 +148,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isReadOnlyProperty( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isReadOnlyProperty( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -185,16 +185,16 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isReadOnlyProperty( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyProperty( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyProperty( obj, 'e' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyProperty( obj, 'f' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -211,13 +211,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isReadOnlyProperty( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyProperty( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadOnlyProperty( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -226,7 +226,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isReadOnlyProperty( 'beep', 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-read-write-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-read-write-property-in/test/test.js
index 8414bebe0668..550c1de39574 100644
--- a/lib/node_modules/@stdlib/assert/is-read-write-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-read-write-property-in/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property is readable and writabl
 		'a': 'b'
 	};
 	bool = isReadWritePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadWritePropertyIn( [ 1, 2, 3 ], '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadWritePropertyIn( [ 1, 2, 3 ], 1 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadWritePropertyIn( new Foo(), 'bar' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadWritePropertyIn( [ 'a' ], 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property is readable and writabl
 	});
 
 	bool = isReadWritePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -80,7 +80,7 @@ tape( 'the function returns `true` if an object property is readable and writabl
 	});
 
 	bool = isReadWritePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -97,13 +97,13 @@ tape( 'the function returns `true` if provided an inherited readable and writabl
 	var bool;
 
 	bool = isReadWritePropertyIn( {}, 'hasOwnProperty' );
-	t.equal( bool, true, 'returns true ' );
+	t.strictEqual( bool, true, 'returns true ' );
 
 	bool = isReadWritePropertyIn( {}, 'toString' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadWritePropertyIn( {}, 'constructor' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -112,10 +112,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isReadWritePropertyIn( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isReadWritePropertyIn( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -148,16 +148,16 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isReadWritePropertyIn( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadWritePropertyIn( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadWritePropertyIn( obj, 'e' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadWritePropertyIn( obj, 'f' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -174,7 +174,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isReadWritePropertyIn( 'beep', 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-read-write-property/test/test.js b/lib/node_modules/@stdlib/assert/is-read-write-property/test/test.js
index f6c375e96f09..b0730327ae67 100644
--- a/lib/node_modules/@stdlib/assert/is-read-write-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-read-write-property/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property is readable and writabl
 		'a': 'b'
 	};
 	bool = isReadWriteProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadWriteProperty( [ 1, 2, 3 ], '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadWriteProperty( [ 1, 2, 3 ], 1 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadWriteProperty( new Foo(), 'bar' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadWriteProperty( [ 'a' ], 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property is readable and writabl
 	});
 
 	bool = isReadWriteProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -80,7 +80,7 @@ tape( 'the function returns `true` if an object property is readable and writabl
 	});
 
 	bool = isReadWriteProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -97,10 +97,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isReadWriteProperty( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isReadWriteProperty( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -133,16 +133,16 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isReadWriteProperty( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadWriteProperty( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadWriteProperty( obj, 'e' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadWriteProperty( obj, 'f' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -159,13 +159,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isReadWriteProperty( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadWriteProperty( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadWriteProperty( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -174,7 +174,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isReadWriteProperty( 'beep', 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-readable-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-readable-property-in/test/test.js
index 41919dde180c..d9a67a7b7c28 100644
--- a/lib/node_modules/@stdlib/assert/is-readable-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-readable-property-in/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property is readable', function
 		'a': 'b'
 	};
 	bool = isReadablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadablePropertyIn( [ 1, 2, 3 ], '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadablePropertyIn( [ 1, 2, 3 ], 1 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadablePropertyIn( new Foo(), 'bar' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadablePropertyIn( [ 'a' ], 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property is readable', function
 	});
 
 	bool = isReadablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -79,7 +79,7 @@ tape( 'the function returns `true` if an object property is readable', function
 	});
 
 	bool = isReadablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -92,13 +92,13 @@ tape( 'the function returns `true` if provided a readable inherited property', f
 	var bool;
 
 	bool = isReadablePropertyIn( {}, 'hasOwnProperty' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadablePropertyIn( {}, 'toString' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadablePropertyIn( {}, 'constructor' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -107,10 +107,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isReadablePropertyIn( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isReadablePropertyIn( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -130,10 +130,10 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isReadablePropertyIn( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadablePropertyIn( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 	t.end();
 
 	function setter() {
@@ -145,7 +145,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isReadablePropertyIn( 'beep', 'toString' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-readable-property/test/test.js b/lib/node_modules/@stdlib/assert/is-readable-property/test/test.js
index 5be5a25cde8b..f0aeda7a4f96 100644
--- a/lib/node_modules/@stdlib/assert/is-readable-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-readable-property/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property is readable', function
 		'a': 'b'
 	};
 	bool = isReadableProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadableProperty( [ 1, 2, 3 ], '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadableProperty( [ 1, 2, 3 ], 1 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadableProperty( new Foo(), 'bar' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isReadableProperty( [ 'a' ], 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property is readable', function
 	});
 
 	bool = isReadableProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -79,7 +79,7 @@ tape( 'the function returns `true` if an object property is readable', function
 	});
 
 	bool = isReadableProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -92,10 +92,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isReadableProperty( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isReadableProperty( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -115,10 +115,10 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isReadableProperty( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadableProperty( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 	t.end();
 
 	function setter() {
@@ -130,13 +130,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isReadableProperty( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadableProperty( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isReadableProperty( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -145,7 +145,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isReadableProperty( 'beep', 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-regexp-string/test/test.js b/lib/node_modules/@stdlib/assert/is-regexp-string/test/test.js
index a934fc9c618c..bb98de729c9e 100644
--- a/lib/node_modules/@stdlib/assert/is-regexp-string/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-regexp-string/test/test.js
@@ -33,8 +33,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a regular expression string', function test( t ) {
-	t.equal( isRegExpString( '/beep/' ), true, 'returns true' );
-	t.equal( isRegExpString( '/beep/gim' ), true, 'returns true' );
+	t.strictEqual( isRegExpString( '/beep/' ), true, 'returns true' );
+	t.strictEqual( isRegExpString( '/beep/gim' ), true, 'returns true' );
 	t.end();
 });
 
@@ -50,7 +50,7 @@ tape( 'the function returns `false` if not provided a regular expression string'
 		'beep/',
 		'beep/gim',
 		/\.+/,
-		new RegExp( 'beep', 'gim' ),
+		new RegExp( 'beep', 'gim' ), // eslint-disable-line prefer-regex-literals
 		function noop() {},
 		null,
 		NaN,
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a regular expression string'
 		void 0
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isRegExpString( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isRegExpString( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-relative-path/test/test.js b/lib/node_modules/@stdlib/assert/is-relative-path/test/test.js
index 2f5f4385a5ca..ef96602293df 100644
--- a/lib/node_modules/@stdlib/assert/is-relative-path/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-relative-path/test/test.js
@@ -37,7 +37,7 @@ tape( 'if platform is POSIX, main export is method to test if a string is a POSI
 	var isRelativePath = proxyquire( './../lib', {
 		'@stdlib/assert/is-windows': false
 	});
-	t.equal( isRelativePath, isRelativePath.posix, 'equals posix method' );
+	t.strictEqual( isRelativePath, isRelativePath.posix, 'equals posix method' );
 	t.end();
 });
 
@@ -45,16 +45,16 @@ tape( 'if platform is Windows, main export is method to test if a string is a Wi
 	var isRelativePath = proxyquire( './../lib', {
 		'@stdlib/assert/is-windows': true
 	});
-	t.equal( isRelativePath, isRelativePath.win32, 'equals win32 method' );
+	t.strictEqual( isRelativePath, isRelativePath.win32, 'equals win32 method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test if a string is a POSIX relative path', function test( t ) {
-	t.equal( typeof isRelativePath.posix, 'function', 'has a posix method' );
+	t.strictEqual( typeof isRelativePath.posix, 'function', 'has a posix method' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test if a string is a Windows relative path', function test( t ) {
-	t.equal( typeof isRelativePath.win32, 'function', 'has a win32 method' );
+	t.strictEqual( typeof isRelativePath.win32, 'function', 'has a win32 method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-relative-path/test/test.posix.js b/lib/node_modules/@stdlib/assert/is-relative-path/test/test.posix.js
index d549d7c2474e..1f94e18144f6 100644
--- a/lib/node_modules/@stdlib/assert/is-relative-path/test/test.posix.js
+++ b/lib/node_modules/@stdlib/assert/is-relative-path/test/test.posix.js
@@ -49,7 +49,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 	];
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isRelativePath( values[ i ] );
-		t.equal( bool, false, 'returns `false` when provided '+values[i] );
+		t.strictEqual( bool, false, 'returns `false` when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-relative-path/test/test.win32.js b/lib/node_modules/@stdlib/assert/is-relative-path/test/test.win32.js
index bbcaead9a84d..d9e6fe16ec18 100644
--- a/lib/node_modules/@stdlib/assert/is-relative-path/test/test.win32.js
+++ b/lib/node_modules/@stdlib/assert/is-relative-path/test/test.win32.js
@@ -49,7 +49,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 	];
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isRelativePath( values[ i ] );
-		t.equal( bool, false, 'returns `false` when provided '+values[i] );
+		t.strictEqual( bool, false, 'returns `false` when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-safe-integer-array/test/test.js b/lib/node_modules/@stdlib/assert/is-safe-integer-array/test/test.js
index 3e3929dde8ab..a39f2d6632a4 100644
--- a/lib/node_modules/@stdlib/assert/is-safe-integer-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-safe-integer-array/test/test.js
@@ -36,24 +36,24 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function tests for an array-like object containing only safe integer values', function test( t ) {
 	var arr;
 
-	arr = [ 5, new Number( 5 ), -3 ]; // eslint-disable-line no-new-wrappers
-	t.equal( isSafeIntegerArray( arr ), true, 'returns true' );
+	arr = [ 5, new Number( 5 ), -3 ];
+	t.strictEqual( isSafeIntegerArray( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
 		'0': 2,
 		'1': 1
 	};
-	t.equal( isSafeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isSafeIntegerArray( arr ), true, 'returns true' );
 
 	arr = [ 1e100, 2e200, 3e300 ];
-	t.equal( isSafeIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isSafeIntegerArray( arr ), false, 'returns false' );
 
 	arr = [ 5.0, 2.3, 11.1 ];
-	t.equal( isSafeIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isSafeIntegerArray( arr ), false, 'returns false' );
 
 	arr = [ 5.0, '3', null ];
-	t.equal( isSafeIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isSafeIntegerArray( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -62,20 +62,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ 5, -0, 0 ];
-	t.equal( isSafeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isSafeIntegerArray.primitives( arr ), true, 'returns true' );
 
 	arr = [ 1e100, 2e200, 3e300 ];
-	t.equal( isSafeIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isSafeIntegerArray.primitives( arr ), false, 'returns false' );
 
 	arr = {
 		'length': 2,
 		'0': 1,
 		'1': -3
 	};
-	t.equal( isSafeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isSafeIntegerArray.primitives( arr ), true, 'returns true' );
 
-	arr = [ new Number( 5 ), 1, 1 ]; // eslint-disable-line no-new-wrappers
-	t.equal( isSafeIntegerArray.primitives( arr ), false, 'returns false' );
+	arr = [ new Number( 5 ), 1, 1 ];
+	t.strictEqual( isSafeIntegerArray.primitives( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -83,24 +83,24 @@ tape( 'the function provides a method to test for an array-like object containin
 tape( 'the function provides a method to test for an array-like object containing only `Number` objects having safe integer values', function test( t ) {
 	var arr;
 
-	arr = [ new Number( 5 ), new Number( -0 ), new Number( 0 ) ]; // eslint-disable-line no-new-wrappers
-	t.equal( isSafeIntegerArray.objects( arr ), true, 'returns true' );
+	arr = [ new Number( 5 ), new Number( -0 ), new Number( 0 ) ];
+	t.strictEqual( isSafeIntegerArray.objects( arr ), true, 'returns true' );
 
 	arr = {
 		'length': 2,
-		'0': new Number( 2 ), // eslint-disable-line no-new-wrappers
-		'1': new Number( -3 ) // eslint-disable-line no-new-wrappers
+		'0': new Number( 2 ),
+		'1': new Number( -3 )
 	};
-	t.equal( isSafeIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isSafeIntegerArray.objects( arr ), true, 'returns true' );
 
-	arr = [ new Number( 1e100 ), new Number( 2e200 ), new Number( 3e300 ) ]; // eslint-disable-line no-new-wrappers
-	t.equal( isSafeIntegerArray.objects( arr ), false, 'returns false' );
+	arr = [ new Number( 1e100 ), new Number( 2e200 ), new Number( 3e300 ) ];
+	t.strictEqual( isSafeIntegerArray.objects( arr ), false, 'returns false' );
 
-	arr = [ new Number( 5 ), 1, 1 ]; // eslint-disable-line no-new-wrappers
-	t.equal( isSafeIntegerArray.objects( arr ), false, 'returns false' );
+	arr = [ new Number( 5 ), 1, 1 ];
+	t.strictEqual( isSafeIntegerArray.objects( arr ), false, 'returns false' );
 
 	arr = [ -5, 1, 1 ];
-	t.equal( isSafeIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isSafeIntegerArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-semver/test/test.js b/lib/node_modules/@stdlib/assert/is-semver/test/test.js
index 147aa4404fe4..b88b6c9542b4 100644
--- a/lib/node_modules/@stdlib/assert/is-semver/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-semver/test/test.js
@@ -33,10 +33,10 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a semantic version string', function test( t ) {
-	t.equal( isSemVer( '1.0.0' ), true, 'returns expected value' );
-	t.equal( isSemVer( '1.0.0-alpha.1' ), true, 'returns expected value' );
-	t.equal( isSemVer( '1.0.0-beta.1.2.3' ), true, 'returns expected value' );
-	t.equal( isSemVer( '1.0.0-alpha.1.2.3+build.foo.bar.baz' ), true, 'returns expected value' );
+	t.strictEqual( isSemVer( '1.0.0' ), true, 'returns expected value' );
+	t.strictEqual( isSemVer( '1.0.0-alpha.1' ), true, 'returns expected value' );
+	t.strictEqual( isSemVer( '1.0.0-beta.1.2.3' ), true, 'returns expected value' );
+	t.strictEqual( isSemVer( '1.0.0-alpha.1.2.3+build.foo.bar.baz' ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,7 +59,7 @@ tape( 'the function returns `false` if not provided a semantic version string',
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSemVer( values[i] ), false, 'returns expected value when provided '+values[i] );
+		t.strictEqual( isSemVer( values[i] ), false, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-skew-centrosymmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-skew-centrosymmetric-matrix/test/test.js
index 51ac4734e343..1b6d1181d01c 100644
--- a/lib/node_modules/@stdlib/assert/is-skew-centrosymmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-skew-centrosymmetric-matrix/test/test.js
@@ -49,7 +49,7 @@ tape( 'the function returns `true` if provided a skew-centrosymmetric matrix (od
 	];
 	arr = ndarray( 'generic', buffer, [ 5, 5 ], [ 5, 1 ], 0, 'row-major' );
 
-	t.equal( isSkewCentrosymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'the function returns `true` if provided a skew-centrosymmetric matrix (ev
 	];
 	arr = ndarray( 'generic', buffer, [ 6, 6 ], [ 6, 1 ], 0, 'row-major' );
 
-	t.equal( isSkewCentrosymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -90,7 +90,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isSkewCentrosymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 
 	function get( i, j ) {
@@ -100,13 +100,13 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 
 tape( 'the function returns `false` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a skew-centrosymmetric matrix (even order)', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 3, 4 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -121,7 +121,7 @@ tape( 'the function returns `false` if not provided a skew-centrosymmetric matri
 	];
 	arr = ndarray( 'generic', buffer, [ 3, 3 ], [ 3, 1 ], 0, 'row-major' );
 
-	t.equal( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -140,7 +140,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.equal( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -159,7 +159,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.equal( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 
 	function get( i, j ) {
@@ -189,7 +189,7 @@ tape( 'the function returns `false` if not provided a 2-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSkewCentrosymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSkewCentrosymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-skew-persymmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-skew-persymmetric-matrix/test/test.js
index 35ce02d5141d..08bc04833509 100644
--- a/lib/node_modules/@stdlib/assert/is-skew-persymmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-skew-persymmetric-matrix/test/test.js
@@ -48,7 +48,7 @@ tape( 'the function returns `true` if provided a skew-persymmetric matrix', func
 	];
 	arr = ndarray( 'generic', buffer, [ 4, 4 ], [ 4, 1 ], 0, 'row-major' );
 
-	t.equal( isSkewPersymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewPersymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isSkewPersymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewPersymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 
 	function get( i, j ) {
@@ -77,13 +77,13 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 
 tape( 'the function returns `false` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isSkewPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewPersymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a skew-persymmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 2, -1 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isSkewPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewPersymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -102,7 +102,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.equal( isSkewPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewPersymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -121,7 +121,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.equal( isSkewPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewPersymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 
 	function get( i, j ) {
@@ -151,7 +151,7 @@ tape( 'the function returns `false` if not provided a 2-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSkewPersymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSkewPersymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-skew-symmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-skew-symmetric-matrix/test/test.js
index 44b529a26f37..73cc87e0c00b 100644
--- a/lib/node_modules/@stdlib/assert/is-skew-symmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-skew-symmetric-matrix/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided a skew-symmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 1, -1, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isSkewSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewSymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -55,7 +55,7 @@ tape( 'the function returns `true` if provided a skew-symmetric 2-dimensional nd
 		'set': noop
 	};
 
-	t.equal( isSkewSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewSymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 
 	function get( i, j ) {
@@ -65,13 +65,13 @@ tape( 'the function returns `true` if provided a skew-symmetric 2-dimensional nd
 
 tape( 'the function returns `false` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isSkewSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewSymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a skew-symmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 1, -1, 1 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isSkewSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewSymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -90,7 +90,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.equal( isSkewSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewSymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -109,7 +109,7 @@ tape( 'the function returns `false` if not provided a skew-symmetric 2-dimension
 		'set': noop
 	};
 
-	t.equal( isSkewSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewSymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 
 	function get( i, j ) {
@@ -139,7 +139,7 @@ tape( 'the function returns `false` if not provided a 2-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSkewSymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSkewSymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-slice/test/test.js b/lib/node_modules/@stdlib/assert/is-slice/test/test.js
index 638136a83b50..0652d1b95f32 100644
--- a/lib/node_modules/@stdlib/assert/is-slice/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-slice/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a Slice instance', function test( t ) {
-	t.equal( isSlice( new Slice( 0, 10, 1 ) ), true, 'returns true' );
+	t.strictEqual( isSlice( new Slice( 0, 10, 1 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if not provided a Slice instance', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSlice( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSlice( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-snakecase/test/test.js b/lib/node_modules/@stdlib/assert/is-snakecase/test/test.js
index c44b12907877..638876a1585b 100644
--- a/lib/node_modules/@stdlib/assert/is-snakecase/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-snakecase/test/test.js
@@ -45,13 +45,13 @@ tape( 'the function returns `true` if a string is in snake case', function test(
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSnakeCase( values[i] ), true, 'returns true when provided '+values[i] );
+		t.strictEqual( isSnakeCase( values[i] ), true, 'returns true when provided '+values[i] );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an empty string', function test( t ) {
-	t.equal( isSnakeCase( '' ), true, 'returns true' );
+	t.strictEqual( isSnakeCase( '' ), true, 'returns true' );
 	t.end();
 });
 
@@ -69,7 +69,7 @@ tape( 'the function returns `false` if a string is not in snake case', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSnakeCase( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSnakeCase( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
@@ -91,7 +91,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSnakeCase( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSnakeCase( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-square-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-square-matrix/test/test.js
index cdfc75b03d97..e447552a3e34 100644
--- a/lib/node_modules/@stdlib/assert/is-square-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-square-matrix/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided a 2-dimensional ndarray having equal dimensions', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isSquareMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSquareMatrix( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -55,13 +55,13 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isSquareMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSquareMatrix( arr ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a 2-dimensional ndarray not having equal dimensions', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isSquareMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSquareMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -80,7 +80,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.equal( isSquareMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSquareMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -106,7 +106,7 @@ tape( 'the function returns `false` if not provided a 2-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSquareMatrix( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSquareMatrix( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-square-number/test/test.js b/lib/node_modules/@stdlib/assert/is-square-number/test/test.js
index 414f881c765c..a9ddacb9a11c 100644
--- a/lib/node_modules/@stdlib/assert/is-square-number/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-square-number/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test primitives', function test( t ) {
-	t.equal( typeof isSquareNumber.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isSquareNumber.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test objects', function test( t ) {
-	t.equal( typeof isSquareNumber.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isSquareNumber.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-square-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-square-number/test/test.main.js
index 6e87fa42603c..bea927f25fef 100644
--- a/lib/node_modules/@stdlib/assert/is-square-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-square-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a square number', function test( t ) {
-	t.equal( isSquareNumber( 4.0 ), true, 'returns true' );
-	t.equal( isSquareNumber( new Number( 4.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isSquareNumber( 4.0 ), true, 'returns true' );
+	t.strictEqual( isSquareNumber( new Number( 4.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a square number', function t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSquareNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSquareNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-square-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-square-number/test/test.object.js
index 44bfd3400cfb..2f9688757e39 100644
--- a/lib/node_modules/@stdlib/assert/is-square-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-square-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a square number', function test( t ) {
-	t.equal( isSquareNumber( new Number( 4.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isSquareNumber( new Number( 4.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive square number', function test( t ) {
-	t.equal( isSquareNumber( 4.0 ), false, 'returns false' );
+	t.strictEqual( isSquareNumber( 4.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -49,7 +49,7 @@ tape( 'the function returns `false` if not provided a square number', function t
 
 	values = [
 		'5',
-		new Number( 5.0 ), // eslint-disable-line no-new-wrappers
+		new Number( 5.0 ),
 		null,
 		true,
 		NaN,
@@ -63,7 +63,7 @@ tape( 'the function returns `false` if not provided a square number', function t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSquareNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSquareNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-square-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-square-number/test/test.primitive.js
index 059862ea3f3c..aaa7765613fa 100644
--- a/lib/node_modules/@stdlib/assert/is-square-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-square-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive square number', function test( t ) {
-	t.equal( isSquareNumber( 4.0 ), true, 'returns true' );
+	t.strictEqual( isSquareNumber( 4.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object', function test( t ) {
-	t.equal( isSquareNumber( new Number( 4.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isSquareNumber( new Number( 4.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'the function returns `false` if not provided a square number', function t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSquareNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSquareNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.js b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.js
index 2625715ee6be..94fb3c990375 100644
--- a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test primitives', function test( t ) {
-	t.equal( typeof isSquareTriangularNumber.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isSquareTriangularNumber.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test objects', function test( t ) {
-	t.equal( typeof isSquareTriangularNumber.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isSquareTriangularNumber.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.main.js
index e8c18118362b..98bca5ac7ac2 100644
--- a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a square triangular number', function test( t ) {
-	t.equal( isSquareTriangularNumber( 36.0 ), true, 'returns true' );
-	t.equal( isSquareTriangularNumber( new Number( 36.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isSquareTriangularNumber( 36.0 ), true, 'returns true' );
+	t.strictEqual( isSquareTriangularNumber( new Number( 36.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'the function returns `false` if not provided a square triangular number',
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSquareTriangularNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSquareTriangularNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.object.js
index 2c5242f97346..f5869d4d0eb9 100644
--- a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a square triangular number', function test( t ) {
-	t.equal( isSquareTriangularNumber( new Number( 36.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isSquareTriangularNumber( new Number( 36.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive square triangular number', function test( t ) {
-	t.equal( isSquareTriangularNumber( 36.0 ), false, 'returns false' );
+	t.strictEqual( isSquareTriangularNumber( 36.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -49,7 +49,7 @@ tape( 'the function returns `false` if not provided a square triangular number',
 
 	values = [
 		'5',
-		new Number( 6.0 ), // eslint-disable-line no-new-wrappers
+		new Number( 6.0 ),
 		null,
 		true,
 		NaN,
@@ -63,7 +63,7 @@ tape( 'the function returns `false` if not provided a square triangular number',
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSquareTriangularNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSquareTriangularNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.primitive.js
index 06a7144b51e7..029cc0d3f4f0 100644
--- a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive square triangular number', function test( t ) {
-	t.equal( isSquareTriangularNumber( 36.0 ), true, 'returns true' );
+	t.strictEqual( isSquareTriangularNumber( 36.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object', function test( t ) {
-	t.equal( isSquareTriangularNumber( new Number( 36.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isSquareTriangularNumber( new Number( 36.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'the function returns `false` if not provided a square triangular number',
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSquareTriangularNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSquareTriangularNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-startcase/test/test.js b/lib/node_modules/@stdlib/assert/is-startcase/test/test.js
index ffd69abde66a..4243a8a58e10 100644
--- a/lib/node_modules/@stdlib/assert/is-startcase/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-startcase/test/test.js
@@ -45,7 +45,7 @@ tape( 'the function returns `true` if provided a startcase string', function tes
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isStartcase( values[ i ] ), true, 'returns true when provided '+values[ i ] );
+		t.strictEqual( isStartcase( values[ i ] ), true, 'returns true when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -64,13 +64,13 @@ tape( 'the function returns `false` if provided a non-startcase string', functio
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isStartcase( values[ i ] ), false, 'returns false when provided '+values[ i ] );
+		t.strictEqual( isStartcase( values[ i ] ), false, 'returns false when provided '+values[ i ] );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an empty string', function test( t ) {
-	t.equal( isStartcase( '' ), true, 'returns true' );
+	t.strictEqual( isStartcase( '' ), true, 'returns true' );
 	t.end();
 });
 
@@ -91,7 +91,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isStartcase( values[ i ] ), false, 'returns false when provided '+values[ i ] );
+		t.strictEqual( isStartcase( values[ i ] ), false, 'returns false when provided '+values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-string-array/test/test.js b/lib/node_modules/@stdlib/assert/is-string-array/test/test.js
index 33703c25bb0b..cb5d9b3e2ead 100644
--- a/lib/node_modules/@stdlib/assert/is-string-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-string-array/test/test.js
@@ -36,10 +36,10 @@ tape( 'the function tests for an array of `string` values', function test( t ) {
 	var arr;
 
 	arr = [ 'a', new String( 'b' ) ]; // eslint-disable-line no-new-wrappers
-	t.equal( isStringArray( arr ), true, 'returns true' );
+	t.strictEqual( isStringArray( arr ), true, 'returns true' );
 
 	arr = [ 'a', 5, null ];
-	t.equal( isStringArray( arr ), false, 'returns false' );
+	t.strictEqual( isStringArray( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -48,10 +48,10 @@ tape( 'the function provides a method to test for an array of `string` primitive
 	var arr;
 
 	arr = [ 'a', 'b' ];
-	t.equal( isStringArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isStringArray.primitives( arr ), true, 'returns true' );
 
 	arr = [ new String( 'a' ), 'b' ]; // eslint-disable-line no-new-wrappers
-	t.equal( isStringArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isStringArray.primitives( arr ), false, 'returns false' );
 
 	t.end();
 });
@@ -60,10 +60,10 @@ tape( 'the function provides a method to test for an array of `String` objects',
 	var arr;
 
 	arr = [ new String( 'a' ), new String( 'b' ) ]; // eslint-disable-line no-new-wrappers
-	t.equal( isStringArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isStringArray.objects( arr ), true, 'returns true' );
 
 	arr = [ 'a', 'b' ];
-	t.equal( isStringArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isStringArray.objects( arr ), false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-string/test/test.js b/lib/node_modules/@stdlib/assert/is-string/test/test.js
index ce8917900ef5..95541ecfe4bb 100644
--- a/lib/node_modules/@stdlib/assert/is-string/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-string/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a primitive string', function test( t ) {
-	t.equal( typeof isString.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isString.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a string object', function test( t ) {
-	t.equal( typeof isString.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isString.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-string/test/test.main.js b/lib/node_modules/@stdlib/assert/is-string/test/test.main.js
index 4b01506adda6..4551e138d2e8 100644
--- a/lib/node_modules/@stdlib/assert/is-string/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-string/test/test.main.js
@@ -33,8 +33,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a string', function test( t ) {
-	t.equal( isString( 'a' ), true, 'returns true' );
-	t.equal( isString( new String( 'a' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isString( 'a' ), true, 'returns true' );
+	t.strictEqual( isString( new String( 'a' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
@@ -54,7 +54,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isString( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isString( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-string/test/test.object.js b/lib/node_modules/@stdlib/assert/is-string/test/test.object.js
index 8017869e522a..1bd13d039a94 100644
--- a/lib/node_modules/@stdlib/assert/is-string/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-string/test/test.object.js
@@ -43,12 +43,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a string object', function test( t ) {
-	t.equal( isString( new String( 'a' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isString( new String( 'a' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive string', function test( t ) {
-	t.equal( isString( 'a' ), false, 'returns false' );
+	t.strictEqual( isString( 'a' ), false, 'returns false' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'if `Symbol.toStringTag` is supported, the function guards against objects
 	if ( hasToStringTag() ) {
 		mock[ Symbol.toStringTag ] = 'String';
 	}
-	t.equal( isString( mock ), false, 'returns false' );
+	t.strictEqual( isString( mock ), false, 'returns false' );
 	t.end();
 
 	function detect() {
@@ -86,8 +86,8 @@ tape( 'if `Symbol.toStringTag` is not supported, the function attempts to determ
 		'@stdlib/assert/has-tostringtag-support': detect
 	});
 
-	t.equal( isString( new String( 'a' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
-	t.equal( isString( {} ), false, 'returns false' );
+	t.strictEqual( isString( new String( 'a' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isString( {} ), false, 'returns false' );
 
 	t.end();
 
@@ -115,7 +115,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isString( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isString( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-string/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-string/test/test.primitive.js
index eab7a1d81f2d..7bdb3726946c 100644
--- a/lib/node_modules/@stdlib/assert/is-string/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-string/test/test.primitive.js
@@ -33,12 +33,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive string', function test( t ) {
-	t.equal( isString( 'a' ), true, 'returns true' );
+	t.strictEqual( isString( 'a' ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a string object', function test( t ) {
-	t.equal( isString( new String( 'a' ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isString( new String( 'a' ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isString( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isString( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-string/test/test.try2valueof.js b/lib/node_modules/@stdlib/assert/is-string/test/test.try2valueof.js
index 7d4ec2a1df40..31f3b3573d46 100644
--- a/lib/node_modules/@stdlib/assert/is-string/test/test.try2valueof.js
+++ b/lib/node_modules/@stdlib/assert/is-string/test/test.try2valueof.js
@@ -33,12 +33,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if able to extract a string value', function test( t ) {
-	t.equal( valueOf( 'a' ), true, 'returns true' );
-	t.equal( valueOf( new String( 'a' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( valueOf( 'a' ), true, 'returns true' );
+	t.strictEqual( valueOf( new String( 'a' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
 tape( 'the function returns `false` if unable to extract a string value', function test( t ) {
-	t.equal( valueOf( {} ), false, 'returns false' );
+	t.strictEqual( valueOf( {} ), false, 'returns false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-struct-constructor-like/test/test.js b/lib/node_modules/@stdlib/assert/is-struct-constructor-like/test/test.js
index 92172c8174cd..50cafd98c5c4 100644
--- a/lib/node_modules/@stdlib/assert/is-struct-constructor-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-struct-constructor-like/test/test.js
@@ -46,7 +46,7 @@ tape( 'the function returns `true` if provided a struct constructor', function t
 	];
 	Struct = structFactory( schema );
 
-	t.equal( isStructConstructorLike( Struct ), true, 'returns expected value' );
+	t.strictEqual( isStructConstructorLike( Struct ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -64,7 +64,7 @@ tape( 'the function returns `true` if provided a struct constructor-like object'
 	Struct.fields = [ 'foo' ];
 	Struct.layout = '';
 
-	t.equal( isStructConstructorLike( Struct ), true, 'returns expected value' );
+	t.strictEqual( isStructConstructorLike( Struct ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -86,7 +86,7 @@ tape( 'the function returns `false` if not provided a struct constructor-like ob
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isStructConstructorLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isStructConstructorLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-struct/test/test.js b/lib/node_modules/@stdlib/assert/is-struct/test/test.js
index 436d7d3da9ad..8853457459d5 100644
--- a/lib/node_modules/@stdlib/assert/is-struct/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-struct/test/test.js
@@ -45,7 +45,7 @@ tape( 'the function returns `true` if provided a struct instance', function test
 	];
 	Struct = structFactory( schema );
 
-	t.equal( isStruct( new Struct() ), true, 'returns expected value' );
+	t.strictEqual( isStruct( new Struct() ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'the function returns `false` if not provided a `struct` instance', functi
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isStruct( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isStruct( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-symmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-symmetric-matrix/test/test.js
index 6e534f24c23d..f93f9df7fc0c 100644
--- a/lib/node_modules/@stdlib/assert/is-symmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-symmetric-matrix/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided a symmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 1, 1, 2 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -55,7 +55,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSymmetricMatrix( arr ), true, 'returns true' );
 	t.end();
 
 	function get( i, j ) {
@@ -65,14 +65,14 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 
 tape( 'the function returns `false` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.equal( isSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a symmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 3, 4 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.equal( isSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -91,7 +91,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.equal( isSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 });
 
@@ -110,7 +110,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.equal( isSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSymmetricMatrix( arr ), false, 'returns false' );
 	t.end();
 
 	function get( i, j ) {
@@ -140,7 +140,7 @@ tape( 'the function returns `false` if not provided a 2-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isSymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isSymmetricMatrix( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-touch-device/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-touch-device/test/test.browser.js
index 9aeaa6517b18..ab881169db99 100644
--- a/lib/node_modules/@stdlib/assert/is-touch-device/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-touch-device/test/test.browser.js
@@ -47,7 +47,7 @@ tape( 'the function returns `true` if the current environment is a touch device
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.equal( isTouchDevice(), true, 'returns true' );
+	t.strictEqual( isTouchDevice(), true, 'returns true' );
 	t.end();
 
 	function getGlobal() {
@@ -66,7 +66,7 @@ tape( 'the function returns `false` if the current environment is a touch device
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.equal( isTouchDevice(), false, 'returns false' );
+	t.strictEqual( isTouchDevice(), false, 'returns false' );
 	t.end();
 
 	function getGlobal() {
@@ -88,7 +88,7 @@ tape( 'the function returns `true` if the current environment is a touch device
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.equal( isTouchDevice(), true, 'returns true' );
+	t.strictEqual( isTouchDevice(), true, 'returns true' );
 	t.end();
 
 	function getGlobal() {
@@ -110,7 +110,7 @@ tape( 'the function returns `false` if the current environment is not a touch de
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.equal( isTouchDevice(), false, 'returns false' );
+	t.strictEqual( isTouchDevice(), false, 'returns false' );
 	t.end();
 
 	function getGlobal() {
@@ -134,7 +134,7 @@ tape( 'the function returns `true` if the current environment is a touch device
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.equal( isTouchDevice(), true, 'returns true' );
+	t.strictEqual( isTouchDevice(), true, 'returns true' );
 	t.end();
 
 	function getGlobal() {
@@ -158,7 +158,7 @@ tape( 'the function returns `false` if the current environment is not a touch de
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.equal( isTouchDevice(), false, 'returns false' );
+	t.strictEqual( isTouchDevice(), false, 'returns false' );
 	t.end();
 
 	function getGlobal() {
@@ -171,6 +171,6 @@ tape( 'the function returns `false` if the current environment is not a browser'
 		'@stdlib/assert/is-browser': false
 	});
 
-	t.equal( isTouchDevice(), false, 'returns false' );
+	t.strictEqual( isTouchDevice(), false, 'returns false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.js b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.js
index 8be7f0e3a2ee..e7fa36f2938b 100644
--- a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test primitives', function test( t ) {
-	t.equal( typeof isTriangularNumber.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isTriangularNumber.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test objects', function test( t ) {
-	t.equal( typeof isTriangularNumber.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isTriangularNumber.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.main.js
index 2ad91b2676a7..5e0a9e94127a 100644
--- a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a triangular number', function test( t ) {
-	t.equal( isTriangularNumber( 36.0 ), true, 'returns true' );
-	t.equal( isTriangularNumber( new Number( 36.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isTriangularNumber( 36.0 ), true, 'returns true' );
+	t.strictEqual( isTriangularNumber( new Number( 36.0 ) ), true, 'returns true' );
 	t.end();
 });
 
@@ -58,7 +58,7 @@ tape( 'the function returns `false` if not provided a triangular number', functi
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isTriangularNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isTriangularNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.object.js
index df8bb46ecd2c..57fe95703092 100644
--- a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a triangular number', function test( t ) {
-	t.equal( isTriangularNumber( new Number( 36.0 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isTriangularNumber( new Number( 36.0 ) ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive triangular number', function test( t ) {
-	t.equal( isTriangularNumber( 36.0 ), false, 'returns false' );
+	t.strictEqual( isTriangularNumber( 36.0 ), false, 'returns false' );
 	t.end();
 });
 
@@ -49,7 +49,7 @@ tape( 'the function returns `false` if not provided a triangular number', functi
 
 	values = [
 		'5',
-		new Number( 5.0 ), // eslint-disable-line no-new-wrappers
+		new Number( 5.0 ),
 		null,
 		true,
 		NaN,
@@ -63,7 +63,7 @@ tape( 'the function returns `false` if not provided a triangular number', functi
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isTriangularNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isTriangularNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.primitive.js
index 311b524b0a08..951c187a8678 100644
--- a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive triangular number', function test( t ) {
-	t.equal( isTriangularNumber( 36.0 ), true, 'returns true' );
+	t.strictEqual( isTriangularNumber( 36.0 ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object', function test( t ) {
-	t.equal( isTriangularNumber( new Number( 36.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isTriangularNumber( new Number( 36.0 ) ), false, 'returns false' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'the function returns `false` if not provided a triangular number', functi
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isTriangularNumber( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isTriangularNumber( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-typed-array-like/test/test.js b/lib/node_modules/@stdlib/assert/is-typed-array-like/test/test.js
index bd100ab7f395..52c0b9c25245 100644
--- a/lib/node_modules/@stdlib/assert/is-typed-array-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-typed-array-like/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function returns `true` if provided a typed-array-like object', funct
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isTypedArrayLike( values[i] ), true, 'returns true when provided '+values[i] );
+		t.strictEqual( isTypedArrayLike( values[i] ), true, 'returns true when provided '+values[i] );
 	}
 
 	t.end();
@@ -132,7 +132,7 @@ tape( 'the function returns `false` if not provided a typed-array-like object',
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isTypedArrayLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isTypedArrayLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-unc-path/test/test.js b/lib/node_modules/@stdlib/assert/is-unc-path/test/test.js
index 1f2123e56d18..eceb8b74fd94 100644
--- a/lib/node_modules/@stdlib/assert/is-unc-path/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-unc-path/test/test.js
@@ -48,7 +48,7 @@ tape( 'the function returns `true` if provided a UNC path', function test( t ) {
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isUNCPath( values[ i ] );
-		t.equal( bool, true, 'returns true when provided '+values[ i ] );
+		t.strictEqual( bool, true, 'returns true when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns `false` if not provided a UNC path', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isUNCPath( values[ i ] );
-		t.equal( bool, false, 'returns false when provided '+values[ i ] );
+		t.strictEqual( bool, false, 'returns false when provided '+values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-undefined-or-null/test/test.js b/lib/node_modules/@stdlib/assert/is-undefined-or-null/test/test.js
index b87cd957ac2f..2c4d37347681 100644
--- a/lib/node_modules/@stdlib/assert/is-undefined-or-null/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-undefined-or-null/test/test.js
@@ -47,7 +47,7 @@ tape( 'the function returns `true` if provided `undefined` or `null`', function
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isUndefinedOrNull( values[ i ] );
-		t.equal( bool, true, 'returns true when provided '+values[ i ] );
+		t.strictEqual( bool, true, 'returns true when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -68,7 +68,7 @@ tape( 'the function returns `false` if not provided `undefined` or `null`', func
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isUndefinedOrNull( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isUndefinedOrNull( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-undefined/test/test.js b/lib/node_modules/@stdlib/assert/is-undefined/test/test.js
index 0293cc799600..8835bb2a811b 100644
--- a/lib/node_modules/@stdlib/assert/is-undefined/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-undefined/test/test.js
@@ -46,7 +46,7 @@ tape( 'the function returns `true` if provided `undefined`', function test( t )
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isUndefined( values[ i ] );
-		t.equal( bool, true, 'returns true when provided '+values[ i ] );
+		t.strictEqual( bool, true, 'returns true when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -68,7 +68,7 @@ tape( 'the function returns `false` if not provided `undefined`', function test(
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isUndefined( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isUndefined( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-uri/test/test.js b/lib/node_modules/@stdlib/assert/is-uri/test/test.js
index d198d335e550..3048c002df93 100644
--- a/lib/node_modules/@stdlib/assert/is-uri/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-uri/test/test.js
@@ -60,7 +60,7 @@ tape( 'the function returns `true` if provided a URI', function test( t ) {
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isURI( values[ i ] ), true, values[ i ] );
+		t.strictEqual( isURI( values[ i ] ), true, values[ i ] );
 	}
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'the function returns `false` if not provided a URI', function test( t ) {
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isURI( values[ i ] ), false, values[ i ] );
+		t.strictEqual( isURI( values[ i ] ), false, values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-vector-like/test/test.js b/lib/node_modules/@stdlib/assert/is-vector-like/test/test.js
index b4a17bd724b6..23553b37481c 100644
--- a/lib/node_modules/@stdlib/assert/is-vector-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-vector-like/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided a 1-dimensional ndarray', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0 ], [ 4 ], [ 1 ], 0, 'row-major' );
-	t.equal( isVectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isVectorLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -55,7 +55,7 @@ tape( 'the function returns `true` if provided a 1-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.equal( isVectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isVectorLike( arr ), true, 'returns true' );
 	t.end();
 });
 
@@ -81,7 +81,7 @@ tape( 'the function returns `false` if not provided a 1-dimensional ndarray-like
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( isVectorLike( values[i] ), false, 'returns false when provided '+values[i] );
+		t.strictEqual( isVectorLike( values[i] ), false, 'returns false when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-web-worker/test/test.main.js b/lib/node_modules/@stdlib/assert/is-web-worker/test/test.main.js
index 7e6e6cabf928..430766cd9e4a 100644
--- a/lib/node_modules/@stdlib/assert/is-web-worker/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-web-worker/test/test.main.js
@@ -164,7 +164,7 @@ tape( 'the function returns `true` if the runtime is a web worker', function tes
 		'./global_scope.js': true
 	});
 
-	t.equal( isWebWorker(), true, 'returns true' );
+	t.strictEqual( isWebWorker(), true, 'returns true' );
 
 	cleanup();
 	t.end();
@@ -212,7 +212,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`WorkerG
 		'./global_scope.js': true
 	});
 
-	t.equal( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns false' );
 
 	cleanup();
 	t.end();
@@ -262,7 +262,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`WorkerN
 		'./global_scope.js': true
 	});
 
-	t.equal( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns false' );
 
 	cleanup();
 	t.end();
@@ -315,7 +315,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`navigat
 		'./global_scope.js': true
 	});
 
-	t.equal( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns false' );
 
 	cleanup();
 	t.end();
@@ -365,7 +365,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`WorkerL
 		'./global_scope.js': true
 	});
 
-	t.equal( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns false' );
 
 	cleanup();
 	t.end();
@@ -418,7 +418,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`locatio
 		'./global_scope.js': true
 	});
 
-	t.equal( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns false' );
 
 	cleanup();
 	t.end();
@@ -468,7 +468,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`self` g
 		'./global_scope.js': true
 	});
 
-	t.equal( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns false' );
 
 	cleanup();
 	t.end();
@@ -518,7 +518,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`self` g
 		'./global_scope.js': false
 	});
 
-	t.equal( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns false' );
 
 	cleanup();
 	t.end();
diff --git a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.js b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.js
index 4c6566bac575..e8ed0ff498d2 100644
--- a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a method to test for a well-formed string primitive', function test( t ) {
-	t.equal( typeof isWellFormedString.isPrimitive, 'function', 'export is a function' );
+	t.strictEqual( typeof isWellFormedString.isPrimitive, 'function', 'export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to test for a well-formed string object', function test( t ) {
-	t.equal( typeof isWellFormedString.isObject, 'function', 'export is a function' );
+	t.strictEqual( typeof isWellFormedString.isObject, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.main.js b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.main.js
index eab84390dd1d..ad2ffdfdf5dd 100644
--- a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.main.js
@@ -33,8 +33,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a well-formed string', function test( t ) {
-	t.equal( isWellFormedString( '' ), true, 'returns true' );
-	t.equal( isWellFormedString( new String( '' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isWellFormedString( '' ), true, 'returns true' );
+	t.strictEqual( isWellFormedString( new String( '' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
@@ -55,7 +55,7 @@ tape( 'the function returns `false` if not provided a well-formed string', funct
 	];
 
 	for ( i = 0; i < strs.length; i++ ) {
-		t.equal( isWellFormedString( strs[i] ), false, 'returns false when provided '+strs[i] );
+		t.strictEqual( isWellFormedString( strs[i] ), false, 'returns false when provided '+strs[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.object.js b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.object.js
index 8914b0d8d1aa..2bf35defb3e1 100644
--- a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.object.js
@@ -33,12 +33,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a well-formed string object', function test( t ) {
-	t.equal( isWellFormedString( new String( '' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isWellFormedString( new String( '' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a string primitive, even if it is well-formed', function test( t ) {
-	t.equal( isWellFormedString( '' ), false, 'returns false' );
+	t.strictEqual( isWellFormedString( '' ), false, 'returns false' );
 	t.end();
 });
 
@@ -63,7 +63,7 @@ tape( 'the function returns `false` if not provided a well-formed string', funct
 	];
 
 	for ( i = 0; i < strs.length; i++ ) {
-		t.equal( isWellFormedString( strs[i] ), false, 'returns false when provided '+strs[i] );
+		t.strictEqual( isWellFormedString( strs[i] ), false, 'returns false when provided '+strs[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.primitive.js
index 1ef40a7b6b61..5656c6b3df1d 100644
--- a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.primitive.js
@@ -33,12 +33,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a well-formed string primitive', function test( t ) {
-	t.equal( isWellFormedString( '' ), true, 'returns true' );
+	t.strictEqual( isWellFormedString( '' ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a string object, even if the string is well-formed', function test( t ) {
-	t.equal( isWellFormedString( new String( '' ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isWellFormedString( new String( '' ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'the function returns `false` if not provided a well-formed string', funct
 	];
 
 	for ( i = 0; i < strs.length; i++ ) {
-		t.equal( isWellFormedString( strs[i] ), false, 'returns false when provided '+strs[i] );
+		t.strictEqual( isWellFormedString( strs[i] ), false, 'returns false when provided '+strs[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-windows/test/test.js b/lib/node_modules/@stdlib/assert/is-windows/test/test.js
index d8c207ea8f46..9aa21c8a0c74 100644
--- a/lib/node_modules/@stdlib/assert/is-windows/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-windows/test/test.js
@@ -39,7 +39,7 @@ tape( 'the main export is `true` if the current process is running on Windows',
 	IS_WINDOWS = proxyquire( './../lib', {
 		'@stdlib/os/platform': 'win32'
 	});
-	t.equal( IS_WINDOWS, true, 'is true' );
+	t.strictEqual( IS_WINDOWS, true, 'is true' );
 	t.end();
 });
 
@@ -49,6 +49,6 @@ tape( 'the main export is `false` if the current process is not running on Windo
 	IS_WINDOWS = proxyquire( './../lib', {
 		'@stdlib/os/platform': 'darwin'
 	});
-	t.equal( IS_WINDOWS, false, 'is false' );
+	t.strictEqual( IS_WINDOWS, false, 'is false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-writable-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-writable-property-in/test/test.js
index b691c224b9d7..c1ef027b81b0 100644
--- a/lib/node_modules/@stdlib/assert/is-writable-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-writable-property-in/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property is writable', function
 		'a': 'b'
 	};
 	bool = isWritablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isWritablePropertyIn( [ 1, 2, 3 ], '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isWritablePropertyIn( [ 1, 2, 3 ], 1 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isWritablePropertyIn( new Foo(), 'bar' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isWritablePropertyIn( [ 'a' ], 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property is writable', function
 	});
 
 	bool = isWritablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -79,7 +79,7 @@ tape( 'the function returns `true` if an object property is writable', function
 	});
 
 	bool = isWritablePropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -92,13 +92,13 @@ tape( 'the function returns `true` if provided a writable inherited property', f
 	var bool;
 
 	bool = isWritablePropertyIn( {}, 'hasOwnProperty' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isWritablePropertyIn( {}, 'constructor' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isWritablePropertyIn( {}, 'toString' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -107,10 +107,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isWritablePropertyIn( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isWritablePropertyIn( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isWritablePropertyIn( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isWritablePropertyIn( 'beep', 'toString' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-writable-property/test/test.js b/lib/node_modules/@stdlib/assert/is-writable-property/test/test.js
index 8fd94a08445a..002433e3385d 100644
--- a/lib/node_modules/@stdlib/assert/is-writable-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-writable-property/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property is writable', function
 		'a': 'b'
 	};
 	bool = isWritableProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isWritableProperty( [ 1, 2, 3 ], '1' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isWritableProperty( [ 1, 2, 3 ], 1 );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isWritableProperty( new Foo(), 'bar' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isWritableProperty( [ 'a' ], 'length' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property is writable', function
 	});
 
 	bool = isWritableProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -79,7 +79,7 @@ tape( 'the function returns `true` if an object property is writable', function
 	});
 
 	bool = isWritableProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -92,10 +92,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isWritableProperty( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isWritableProperty( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isWritableProperty( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -118,13 +118,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isWritableProperty( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWritableProperty( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWritableProperty( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isWritableProperty( 'beep', 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-write-only-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-write-only-property-in/test/test.js
index 1dfd1ff1ef4a..a99bbd1e5937 100644
--- a/lib/node_modules/@stdlib/assert/is-write-only-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-write-only-property-in/test/test.js
@@ -52,10 +52,10 @@ tape( 'the function returns `true` if an object property is write-only', functio
 	});
 
 	bool = isWriteOnlyPropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isWriteOnlyPropertyIn( obj, 'b' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -87,10 +87,10 @@ tape( 'the function returns `true` if an inherited object property is write-only
 	obj = new Foo();
 
 	bool = isWriteOnlyPropertyIn( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isWriteOnlyPropertyIn( obj, 'b' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -112,19 +112,19 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 		'a': 'b'
 	};
 	bool = isWriteOnlyPropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyPropertyIn( [ 1, 2, 3 ], '1' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyPropertyIn( [ 1, 2, 3 ], 1 );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyPropertyIn( new Foo(), 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyPropertyIn( [ 'a' ], 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -135,7 +135,7 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 	});
 
 	bool = isWriteOnlyPropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -146,7 +146,7 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 	});
 
 	bool = isWriteOnlyPropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -156,7 +156,7 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 	});
 
 	bool = isWriteOnlyPropertyIn( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -173,10 +173,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isWriteOnlyPropertyIn( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isWriteOnlyPropertyIn( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -210,16 +210,16 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isWriteOnlyPropertyIn( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyPropertyIn( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyPropertyIn( obj, 'e' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyPropertyIn( obj, 'f' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -236,13 +236,13 @@ tape( 'the function returns `false` if provided an inherited property which is n
 	var bool;
 
 	bool = isWriteOnlyPropertyIn( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyPropertyIn( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyPropertyIn( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -251,7 +251,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isWriteOnlyPropertyIn( 'beep', 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-write-only-property/test/test.js b/lib/node_modules/@stdlib/assert/is-write-only-property/test/test.js
index d0793e775d43..95e90c25f92d 100644
--- a/lib/node_modules/@stdlib/assert/is-write-only-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-write-only-property/test/test.js
@@ -52,10 +52,10 @@ tape( 'the function returns `true` if an object property is write-only', functio
 	});
 
 	bool = isWriteOnlyProperty( obj, 'a' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = isWriteOnlyProperty( obj, 'b' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 
@@ -77,19 +77,19 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 		'a': 'b'
 	};
 	bool = isWriteOnlyProperty( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyProperty( [ 1, 2, 3 ], '1' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyProperty( [ 1, 2, 3 ], 1 );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyProperty( new Foo(), 'bar' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyProperty( [ 'a' ], 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -100,7 +100,7 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 	});
 
 	bool = isWriteOnlyProperty( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -111,7 +111,7 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 	});
 
 	bool = isWriteOnlyProperty( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -121,7 +121,7 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 	});
 
 	bool = isWriteOnlyProperty( obj, 'a' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -138,10 +138,10 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 	var bool;
 
 	bool = isWriteOnlyProperty( null, 'beep' );
-	t.equal( bool, false, 'returns false when provided null' );
+	t.strictEqual( bool, false, 'returns false when provided null' );
 
 	bool = isWriteOnlyProperty( void 0, 'beep' );
-	t.equal( bool, false, 'returns false when provided undefined' );
+	t.strictEqual( bool, false, 'returns false when provided undefined' );
 
 	t.end();
 });
@@ -175,16 +175,16 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isWriteOnlyProperty( obj, 'c' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyProperty( obj, 'd' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyProperty( obj, 'e' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyProperty( obj, 'f' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 
@@ -201,13 +201,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isWriteOnlyProperty( {}, 'hasOwnProperty' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyProperty( {}, 'toString' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = isWriteOnlyProperty( {}, 'constructor' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
@@ -216,7 +216,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isWriteOnlyProperty( 'beep', 'length' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/tools/test/test.js b/lib/node_modules/@stdlib/assert/tools/test/test.js
index f793c467b06d..7e8e15e1cd14 100644
--- a/lib/node_modules/@stdlib/assert/tools/test/test.js
+++ b/lib/node_modules/@stdlib/assert/tools/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains assertion utility tools', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/array/test/test.js b/lib/node_modules/@stdlib/constants/array/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/constants/array/test/test.js
+++ b/lib/node_modules/@stdlib/constants/array/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/complex128/num-bytes/test/test.js b/lib/node_modules/@stdlib/constants/complex128/num-bytes/test/test.js
index eb3e50bb100f..bd4ceabed05b 100644
--- a/lib/node_modules/@stdlib/constants/complex128/num-bytes/test/test.js
+++ b/lib/node_modules/@stdlib/constants/complex128/num-bytes/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 16', function test( t ) {
-	t.equal( NUM_BYTES, 16, 'equals 16' );
+	t.strictEqual( NUM_BYTES, 16, 'equals 16' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/complex128/test/test.js b/lib/node_modules/@stdlib/constants/complex128/test/test.js
index 1b76e1509199..6cf498aee928 100644
--- a/lib/node_modules/@stdlib/constants/complex128/test/test.js
+++ b/lib/node_modules/@stdlib/constants/complex128/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains constants', function test( t ) {
 	var keys = objectKeys( constants );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/complex64/num-bytes/test/test.js b/lib/node_modules/@stdlib/constants/complex64/num-bytes/test/test.js
index f81956004e15..4dd3364c9fee 100644
--- a/lib/node_modules/@stdlib/constants/complex64/num-bytes/test/test.js
+++ b/lib/node_modules/@stdlib/constants/complex64/num-bytes/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 8', function test( t ) {
-	t.equal( NUM_BYTES, 8, 'equals 8' );
+	t.strictEqual( NUM_BYTES, 8, 'equals 8' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/complex64/test/test.js b/lib/node_modules/@stdlib/constants/complex64/test/test.js
index 1b76e1509199..6cf498aee928 100644
--- a/lib/node_modules/@stdlib/constants/complex64/test/test.js
+++ b/lib/node_modules/@stdlib/constants/complex64/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains constants', function test( t ) {
 	var keys = objectKeys( constants );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float16/exponent-bias/test/test.js b/lib/node_modules/@stdlib/constants/float16/exponent-bias/test/test.js
index 51a95062c493..e5178ce5de45 100644
--- a/lib/node_modules/@stdlib/constants/float16/exponent-bias/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float16/exponent-bias/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is `15`', function test( t ) {
-	t.equal( FLOAT16_EXPONENT_BIAS, 15, 'returns expected value' );
+	t.strictEqual( FLOAT16_EXPONENT_BIAS, 15, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float16/max-safe-integer/test/test.js b/lib/node_modules/@stdlib/constants/float16/max-safe-integer/test/test.js
index 68cfe880bcf4..695e960fcdf5 100644
--- a/lib/node_modules/@stdlib/constants/float16/max-safe-integer/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float16/max-safe-integer/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 2**11-1', function test( t ) {
-	t.equal( FLOAT16_MAX_SAFE_INTEGER, pow( 2.0, 11 ) - 1.0, 'returns expected value' );
+	t.strictEqual( FLOAT16_MAX_SAFE_INTEGER, pow( 2.0, 11 ) - 1.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float16/max/test/test.js b/lib/node_modules/@stdlib/constants/float16/max/test/test.js
index 0e9144a7ec38..b3781699b5fd 100644
--- a/lib/node_modules/@stdlib/constants/float16/max/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float16/max/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is equal to the maximum half-precision floating-point number', function test( t ) {
-	t.equal( FLOAT16_MAX, pow(2, 15) * (2-pow(2, -10)), 'returns expected value' );
+	t.strictEqual( FLOAT16_MAX, pow(2, 15) * (2-pow(2, -10)), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float16/min-safe-integer/test/test.js b/lib/node_modules/@stdlib/constants/float16/min-safe-integer/test/test.js
index f839cdea462f..7d782031b9f4 100644
--- a/lib/node_modules/@stdlib/constants/float16/min-safe-integer/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float16/min-safe-integer/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is -2**11+1', function test( t ) {
-	t.equal( FLOAT16_MIN_SAFE_INTEGER, -pow( 2.0, 11 )+1, 'returns expected value' );
+	t.strictEqual( FLOAT16_MIN_SAFE_INTEGER, -pow( 2.0, 11 )+1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float16/ninf/test/test.js b/lib/node_modules/@stdlib/constants/float16/ninf/test/test.js
index 5bc2698829b9..16fed9a9bb5d 100644
--- a/lib/node_modules/@stdlib/constants/float16/ninf/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float16/ninf/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is a number', function test( t ) {
 
 tape( 'export is equal to negative infinity', function test( t ) {
 	// Note: we rely on implicit type promotion. A 16-bit infinity should be promoted to a 64-bit infinity...
-	t.equal( FLOAT16_NINF, Number.NEGATIVE_INFINITY, 'returns expected value' );
+	t.strictEqual( FLOAT16_NINF, Number.NEGATIVE_INFINITY, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float16/num-bytes/test/test.js b/lib/node_modules/@stdlib/constants/float16/num-bytes/test/test.js
index 039e906a7cfe..0c2eb7f8b8c1 100644
--- a/lib/node_modules/@stdlib/constants/float16/num-bytes/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float16/num-bytes/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 2', function test( t ) {
-	t.equal( NUM_BYTES, 2, 'returns expected value' );
+	t.strictEqual( NUM_BYTES, 2, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float16/pinf/test/test.js b/lib/node_modules/@stdlib/constants/float16/pinf/test/test.js
index 39f08b453853..6e10adb78fa6 100644
--- a/lib/node_modules/@stdlib/constants/float16/pinf/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float16/pinf/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is a number', function test( t ) {
 
 tape( 'export is equal to positive infinity', function test( t ) {
 	// Note: we rely on implicit type promotion. A 16-bit infinity should be promoted to a 64-bit infinity...
-	t.equal( FLOAT16_PINF, Number.POSITIVE_INFINITY, 'returns expected value' );
+	t.strictEqual( FLOAT16_PINF, Number.POSITIVE_INFINITY, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float16/precision/test/test.js b/lib/node_modules/@stdlib/constants/float16/precision/test/test.js
index de620a87d451..b660fefd16cd 100644
--- a/lib/node_modules/@stdlib/constants/float16/precision/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float16/precision/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 11 (10 significand bits + 1 implicit bit)', function test( t ) {
-	t.equal( PRECISION, 11, 'returns expected value' );
+	t.strictEqual( PRECISION, 11, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float16/smallest-normal/test/test.js b/lib/node_modules/@stdlib/constants/float16/smallest-normal/test/test.js
index 5be3fd8e6ef8..aea0bcd9c6df 100644
--- a/lib/node_modules/@stdlib/constants/float16/smallest-normal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float16/smallest-normal/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value equals the smallest normal value', function test( t ) {
-	t.equal( FLOAT16_SMALLEST_NORMAL, pow( 2.0, -14 ), 'returns expected value' );
+	t.strictEqual( FLOAT16_SMALLEST_NORMAL, pow( 2.0, -14 ), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float16/smallest-subnormal/test/test.js b/lib/node_modules/@stdlib/constants/float16/smallest-subnormal/test/test.js
index d368af575a6c..f36c33e38ff6 100644
--- a/lib/node_modules/@stdlib/constants/float16/smallest-subnormal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float16/smallest-subnormal/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value equals the smallest half-precision floating-point denormalized value', function test( t ) {
-	t.equal( FLOAT16_SMALLEST_SUBNORMAL, pow( 2.0, -14 )*pow( 2.0, -10 ), 'returns expected value' );
+	t.strictEqual( FLOAT16_SMALLEST_SUBNORMAL, pow( 2.0, -14 )*pow( 2.0, -10 ), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float16/test/test.js b/lib/node_modules/@stdlib/constants/float16/test/test.js
index 1b76e1509199..6cf498aee928 100644
--- a/lib/node_modules/@stdlib/constants/float16/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float16/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains constants', function test( t ) {
 	var keys = objectKeys( constants );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/apery/test/test.js b/lib/node_modules/@stdlib/constants/float32/apery/test/test.js
index 71d0d728fff0..b0e05a2f1f1d 100644
--- a/lib/node_modules/@stdlib/constants/float32/apery/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/apery/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is a single-precision floating-point number equal to 1.202056884765625', function test( t ) {
-	t.equal( FLOAT32_APERY, 1.202056884765625, 'returns expected value' );
+	t.strictEqual( FLOAT32_APERY, 1.202056884765625, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/catalan/test/test.js b/lib/node_modules/@stdlib/constants/float32/catalan/test/test.js
index 3863594d0b09..786b3ff514f7 100644
--- a/lib/node_modules/@stdlib/constants/float32/catalan/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/catalan/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is a single-precision floating-point number equal to 0.9159656167030334', function test( t ) {
-	t.equal( FLOAT32_CATALAN, 0.9159656167030334, 'returns expected value' );
+	t.strictEqual( FLOAT32_CATALAN, 0.9159656167030334, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/e/test/test.js b/lib/node_modules/@stdlib/constants/float32/e/test/test.js
index f6b575be65f2..f34ecc589d50 100644
--- a/lib/node_modules/@stdlib/constants/float32/e/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/e/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to 2.7182817459106445', function test( t ) {
-	t.equal( E, 2.7182817459106445, 'returns expected value' );
+	t.strictEqual( E, 2.7182817459106445, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/eulergamma/test/test.js b/lib/node_modules/@stdlib/constants/float32/eulergamma/test/test.js
index 6dae58bbaf79..c6e79d4ee502 100644
--- a/lib/node_modules/@stdlib/constants/float32/eulergamma/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/eulergamma/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is a single-precision floating-point number equal to 0.5772156715393066', function test( t ) {
-	t.equal( FLOAT32_EULERGAMMA, 0.5772156715393066, 'returns expected value' );
+	t.strictEqual( FLOAT32_EULERGAMMA, 0.5772156715393066, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/exponent-bias/test/test.js b/lib/node_modules/@stdlib/constants/float32/exponent-bias/test/test.js
index 0a889264cf99..e9a28f25b337 100644
--- a/lib/node_modules/@stdlib/constants/float32/exponent-bias/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/exponent-bias/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is `127`', function test( t ) {
-	t.equal( FLOAT32_EXPONENT_BIAS, 127, 'returns expected value' );
+	t.strictEqual( FLOAT32_EXPONENT_BIAS, 127, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/fourth-pi/test/test.js b/lib/node_modules/@stdlib/constants/float32/fourth-pi/test/test.js
index 6d5361253b2f..9b33d60f5c21 100644
--- a/lib/node_modules/@stdlib/constants/float32/fourth-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/fourth-pi/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to 7.853981852531433e-1', function test( t ) {
-	t.equal( FLOAT32_FOURTH_PI, float64ToFloat32( 7.85398163397448309616e-1 ), 'returns expected value' );
+	t.strictEqual( FLOAT32_FOURTH_PI, float64ToFloat32( 7.85398163397448309616e-1 ), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/fourth-root-eps/test/test.js b/lib/node_modules/@stdlib/constants/float32/fourth-root-eps/test/test.js
index d748c374e690..764d5f4697c1 100644
--- a/lib/node_modules/@stdlib/constants/float32/fourth-root-eps/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/fourth-root-eps/test/test.js
@@ -37,6 +37,6 @@ tape( 'main export is a number', function test( t ) {
 
 tape( 'the exported value equals the fourth root of the difference between one and the smallest value greater than one which is representable as a float (2**-23)', function test( t ) {
 	var expected = sqrtf( sqrtf( float64ToFloat32( pow( 2, -23 ) ) ) );
-	t.equal( FLOAT32_FOURTH_ROOT_EPS, expected, 'returns expected value' );
+	t.strictEqual( FLOAT32_FOURTH_ROOT_EPS, expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/half-ln-two/test/test.js b/lib/node_modules/@stdlib/constants/float32/half-ln-two/test/test.js
index c7ef1cf8bea4..8a4e1eebcfda 100644
--- a/lib/node_modules/@stdlib/constants/float32/half-ln-two/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/half-ln-two/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to `0.3465735912322998`', function test( t ) {
-	t.equal( FLOAT32_HALF_LN2, float64ToFloat32( 3.46573590279972654709e-01 ), 'returns expected value' );
+	t.strictEqual( FLOAT32_HALF_LN2, float64ToFloat32( 3.46573590279972654709e-01 ), 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float32/half-pi/test/test.js b/lib/node_modules/@stdlib/constants/float32/half-pi/test/test.js
index f8f16eae933d..eb50a20faed3 100644
--- a/lib/node_modules/@stdlib/constants/float32/half-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/half-pi/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to 1.5707963705062866', function test( t ) {
-	t.equal( FLOAT32_HALF_PI, float64ToFloat32( 1.5707963267948966 ), 'returns expected value' );
+	t.strictEqual( FLOAT32_HALF_PI, float64ToFloat32( 1.5707963267948966 ), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/ln-half/test/test.js b/lib/node_modules/@stdlib/constants/float32/ln-half/test/test.js
index c71d3aa1ca80..00856a1b2bd0 100644
--- a/lib/node_modules/@stdlib/constants/float32/ln-half/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/ln-half/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to `-0.6931471824645996', function test( t ) {
-	t.equal( FLOAT32_LN_HALF, -0.6931471824645996, 'returns expected value' );
+	t.strictEqual( FLOAT32_LN_HALF, -0.6931471824645996, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float32/ln-pi/test/test.js b/lib/node_modules/@stdlib/constants/float32/ln-pi/test/test.js
index 9098fa0986bc..6f930813506b 100644
--- a/lib/node_modules/@stdlib/constants/float32/ln-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/ln-pi/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to 1.1447298526763916', function test( t ) {
-	t.equal( LN_PI, lnf(PI), 'returns expected value' );
+	t.strictEqual( LN_PI, lnf(PI), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/ln-sqrt-two-pi/test/test.js b/lib/node_modules/@stdlib/constants/float32/ln-sqrt-two-pi/test/test.js
index 868f64d47bed..32a0edf53cd8 100644
--- a/lib/node_modules/@stdlib/constants/float32/ln-sqrt-two-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/ln-sqrt-two-pi/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to 0.9189385175704956', function test( t ) {
-	t.equal( FLOAT32_LN_SQRT_TWO_PI, 0.9189385175704956, 'returns expected value' );
+	t.strictEqual( FLOAT32_LN_SQRT_TWO_PI, 0.9189385175704956, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float32/ln-ten/test/test.js b/lib/node_modules/@stdlib/constants/float32/ln-ten/test/test.js
index 8e58a364a170..3b4e37005ab6 100644
--- a/lib/node_modules/@stdlib/constants/float32/ln-ten/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/ln-ten/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to `2.3025851249694824`', function test( t ) {
-	t.equal( FLOAT32_LN10, 2.3025851249694824, 'returns expected value' );
+	t.strictEqual( FLOAT32_LN10, 2.3025851249694824, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float32/ln-two-pi/test/test.js b/lib/node_modules/@stdlib/constants/float32/ln-two-pi/test/test.js
index 9e53d2ddfda7..737ac767996a 100644
--- a/lib/node_modules/@stdlib/constants/float32/ln-two-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/ln-two-pi/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to `1.8378770351409912`', function test( t ) {
-	t.equal( FLOAT32_LN_TWO_PI, 1.8378770351409912, 'returns expected value' );
+	t.strictEqual( FLOAT32_LN_TWO_PI, 1.8378770351409912, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float32/ln-two/test/test.js b/lib/node_modules/@stdlib/constants/float32/ln-two/test/test.js
index 988fbc7d47d8..35b0025d5bac 100644
--- a/lib/node_modules/@stdlib/constants/float32/ln-two/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/ln-two/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to `0.6931471824645996`', function test( t ) {
-	t.equal( FLOAT32_LN2, float64ToFloat32( 0.6931471805599453 ), 'returns expected value' );
+	t.strictEqual( FLOAT32_LN2, float64ToFloat32( 0.6931471805599453 ), 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float32/log10-e/test/test.js b/lib/node_modules/@stdlib/constants/float32/log10-e/test/test.js
index 4ffd129a65fb..2e4161841a18 100644
--- a/lib/node_modules/@stdlib/constants/float32/log10-e/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/log10-e/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to 0.4342944920063019', function test( t ) {
-	t.equal( FLOAT32_LOG10E, 0.4342944920063019, 'returns expected value' );
+	t.strictEqual( FLOAT32_LOG10E, 0.4342944920063019, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/log2-e/test/test.js b/lib/node_modules/@stdlib/constants/float32/log2-e/test/test.js
index ce5002758d16..0c40e13744ba 100644
--- a/lib/node_modules/@stdlib/constants/float32/log2-e/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/log2-e/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to 1.4426950216293335', function test( t ) {
-	t.equal( FLOAT32_LOG2E, 1.4426950216293335, 'returns expected value' );
+	t.strictEqual( FLOAT32_LOG2E, 1.4426950216293335, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/max-base10-exponent-subnormal/test/test.js b/lib/node_modules/@stdlib/constants/float32/max-base10-exponent-subnormal/test/test.js
index 6fd530678fce..23ff3dab1561 100644
--- a/lib/node_modules/@stdlib/constants/float32/max-base10-exponent-subnormal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/max-base10-exponent-subnormal/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is `-38`', function test( t ) {
-	t.equal( FLOAT32_MAX_BASE10_EXPONENT_SUBNORMAL, -38, 'returns expected value' );
+	t.strictEqual( FLOAT32_MAX_BASE10_EXPONENT_SUBNORMAL, -38, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/max-base10-exponent/test/test.js b/lib/node_modules/@stdlib/constants/float32/max-base10-exponent/test/test.js
index 5a611737bb77..0d8be514681c 100644
--- a/lib/node_modules/@stdlib/constants/float32/max-base10-exponent/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/max-base10-exponent/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is `38`', function test( t ) {
-	t.equal( FLOAT32_MAX_BASE10_EXPONENT, 38, 'returns expected value' );
+	t.strictEqual( FLOAT32_MAX_BASE10_EXPONENT, 38, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/max-base2-exponent-subnormal/test/test.js b/lib/node_modules/@stdlib/constants/float32/max-base2-exponent-subnormal/test/test.js
index cafc2338d314..add0dc8ca0fc 100644
--- a/lib/node_modules/@stdlib/constants/float32/max-base2-exponent-subnormal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/max-base2-exponent-subnormal/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is -127', function test( t ) {
-	t.equal( FLOAT32_MAX_BASE2_EXPONENT_SUBNORMAL, -127, 'returns expected value' );
+	t.strictEqual( FLOAT32_MAX_BASE2_EXPONENT_SUBNORMAL, -127, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/max-base2-exponent/test/test.js b/lib/node_modules/@stdlib/constants/float32/max-base2-exponent/test/test.js
index 13ff10573afb..6c4a027977bb 100644
--- a/lib/node_modules/@stdlib/constants/float32/max-base2-exponent/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/max-base2-exponent/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 127', function test( t ) {
-	t.equal( FLOAT32_MAX_BASE2_EXPONENT, 127, 'returns expected value' );
+	t.strictEqual( FLOAT32_MAX_BASE2_EXPONENT, 127, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/max-ln/test/test.js b/lib/node_modules/@stdlib/constants/float32/max-ln/test/test.js
index 28dd1a614fb5..6feedeb2ad07 100644
--- a/lib/node_modules/@stdlib/constants/float32/max-ln/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/max-ln/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to the natural logarithm of the max single-precision floating-point number', function test( t ) {
-	t.equal( FLOAT32_MAX_LN, float64ToFloat32( lnf( float64ToFloat32( pow( 2, 127 ) ) * float64ToFloat32( 2 - float64ToFloat32( pow( 2, -23 ) ) ) ) ), 'returns expected value' );
-	t.equal( FLOAT32_MAX_LN, lnf( FLOAT32_MAX ), 'returns expected value' );
+	t.strictEqual( FLOAT32_MAX_LN, float64ToFloat32( lnf( float64ToFloat32( pow( 2, 127 ) ) * float64ToFloat32( 2 - float64ToFloat32( pow( 2, -23 ) ) ) ) ), 'returns expected value' );
+	t.strictEqual( FLOAT32_MAX_LN, lnf( FLOAT32_MAX ), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/max-safe-integer/test/test.js b/lib/node_modules/@stdlib/constants/float32/max-safe-integer/test/test.js
index 92e6c2b6f497..397a57f28f43 100644
--- a/lib/node_modules/@stdlib/constants/float32/max-safe-integer/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/max-safe-integer/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 2**24-1', function test( t ) {
-	t.equal( FLOAT32_MAX_SAFE_INTEGER, pow( 2, 24 )-1, 'returns expected value' );
+	t.strictEqual( FLOAT32_MAX_SAFE_INTEGER, pow( 2, 24 )-1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/max/test/test.js b/lib/node_modules/@stdlib/constants/float32/max/test/test.js
index d9a6b95588c7..c69615cde621 100644
--- a/lib/node_modules/@stdlib/constants/float32/max/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/max/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is equal to the maximum single-precision floating-point number', function test( t ) {
-	t.equal( FLOAT32_MAX, pow(2, 127) * (2-pow(2, -23)), 'returns expected value' );
+	t.strictEqual( FLOAT32_MAX, pow(2, 127) * (2-pow(2, -23)), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/min-base10-exponent-subnormal/test/test.js b/lib/node_modules/@stdlib/constants/float32/min-base10-exponent-subnormal/test/test.js
index b2297de6a59b..45d4df0e10af 100644
--- a/lib/node_modules/@stdlib/constants/float32/min-base10-exponent-subnormal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/min-base10-exponent-subnormal/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is `-45`', function test( t ) {
-	t.equal( FLOAT32_MIN_BASE10_EXPONENT_SUBNORMAL, -45, 'returns expected value' );
+	t.strictEqual( FLOAT32_MIN_BASE10_EXPONENT_SUBNORMAL, -45, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/min-base10-exponent/test/test.js b/lib/node_modules/@stdlib/constants/float32/min-base10-exponent/test/test.js
index 71e7cfaf937b..f5a746ab0968 100644
--- a/lib/node_modules/@stdlib/constants/float32/min-base10-exponent/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/min-base10-exponent/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is `-37`', function test( t ) {
-	t.equal( FLOAT32_MIN_BASE10_EXPONENT, -37, 'returns expected value' );
+	t.strictEqual( FLOAT32_MIN_BASE10_EXPONENT, -37, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/min-base2-exponent-subnormal/test/test.js b/lib/node_modules/@stdlib/constants/float32/min-base2-exponent-subnormal/test/test.js
index 567770ed81e7..53737f890973 100644
--- a/lib/node_modules/@stdlib/constants/float32/min-base2-exponent-subnormal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/min-base2-exponent-subnormal/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is -149', function test( t ) {
-	t.equal( FLOAT32_MIN_BASE2_EXPONENT_SUBNORMAL, -149, 'returns expected value' );
+	t.strictEqual( FLOAT32_MIN_BASE2_EXPONENT_SUBNORMAL, -149, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/min-base2-exponent/test/test.js b/lib/node_modules/@stdlib/constants/float32/min-base2-exponent/test/test.js
index 28c7bc56e5b5..1280e71b9149 100644
--- a/lib/node_modules/@stdlib/constants/float32/min-base2-exponent/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/min-base2-exponent/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is `-126`', function test( t ) {
-	t.equal( FLOAT32_MIN_BASE2_EXPONENT, -126, 'returns expected value' );
+	t.strictEqual( FLOAT32_MIN_BASE2_EXPONENT, -126, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/min-ln/test/test.js b/lib/node_modules/@stdlib/constants/float32/min-ln/test/test.js
index 414533540510..94fd5199ea82 100644
--- a/lib/node_modules/@stdlib/constants/float32/min-ln/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/min-ln/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to the natural logarithm of the smallest normalized single-precision floating-point number', function test( t ) {
-	t.equal( FLOAT32_MIN_LN, -lnf( float64ToFloat32( pow( 2, 126 ) ) ), 'returns expected value' );
-	t.equal( FLOAT32_MIN_LN, lnf( SMALLEST_NORMAL ), 'returns expected value' );
+	t.strictEqual( FLOAT32_MIN_LN, -lnf( float64ToFloat32( pow( 2, 126 ) ) ), 'returns expected value' );
+	t.strictEqual( FLOAT32_MIN_LN, lnf( SMALLEST_NORMAL ), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/min-safe-integer/test/test.js b/lib/node_modules/@stdlib/constants/float32/min-safe-integer/test/test.js
index ef236574b010..5422e5c14edc 100644
--- a/lib/node_modules/@stdlib/constants/float32/min-safe-integer/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/min-safe-integer/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is -2**24+1', function test( t ) {
-	t.equal( FLOAT32_MIN_SAFE_INTEGER, -pow( 2, 24 )+1, 'returns expected value' );
+	t.strictEqual( FLOAT32_MIN_SAFE_INTEGER, -pow( 2, 24 )+1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/ninf/test/test.js b/lib/node_modules/@stdlib/constants/float32/ninf/test/test.js
index 3ecf3592f483..dd509a8b7956 100644
--- a/lib/node_modules/@stdlib/constants/float32/ninf/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/ninf/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is a number', function test( t ) {
 
 tape( 'export is equal to negative infinity', function test( t ) {
 	// Note: we rely on implicit type promotion. A 32-bit infinity should be promoted to a 64-bit infinity...
-	t.equal( FLOAT32_NINF, Number.NEGATIVE_INFINITY, 'returns expected value' );
+	t.strictEqual( FLOAT32_NINF, Number.NEGATIVE_INFINITY, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/num-bytes/test/test.js b/lib/node_modules/@stdlib/constants/float32/num-bytes/test/test.js
index 948fed8e36d9..488ccfac9220 100644
--- a/lib/node_modules/@stdlib/constants/float32/num-bytes/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/num-bytes/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 4', function test( t ) {
-	t.equal( NUM_BYTES, 4, 'returns expected value' );
+	t.strictEqual( NUM_BYTES, 4, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/num-significand-bits/test/test.js b/lib/node_modules/@stdlib/constants/float32/num-significand-bits/test/test.js
index 2b25e8d48b5e..7204960966d9 100644
--- a/lib/node_modules/@stdlib/constants/float32/num-significand-bits/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/num-significand-bits/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 23', function test( t ) {
-	t.equal( FLOAT32_NUM_SIGNIFICAND_BITS, 23, 'returns expected value' );
+	t.strictEqual( FLOAT32_NUM_SIGNIFICAND_BITS, 23, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/phi/test/test.js b/lib/node_modules/@stdlib/constants/float32/phi/test/test.js
index c95eed8a92dd..484c07bd4810 100644
--- a/lib/node_modules/@stdlib/constants/float32/phi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/phi/test/test.js
@@ -35,11 +35,11 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 1.6180340051651', function test( t ) {
-	t.equal( FLOAT32_PHI, float64ToFloat32( 1.618033988749895 ), 'returns expected value' );
+	t.strictEqual( FLOAT32_PHI, float64ToFloat32( 1.618033988749895 ), 'returns expected value' );
 	t.end();
 });
 
 tape( 'the exported value equals ( 1 + sqrtf( 5 ) ) / 2', function test( t ) {
-	t.equal( FLOAT32_PHI, float64ToFloat32( float64ToFloat32( 1.0 + sqrtf( 5.0 ) ) / 2.0 ), 'returns expected value' );
+	t.strictEqual( FLOAT32_PHI, float64ToFloat32( float64ToFloat32( 1.0 + sqrtf( 5.0 ) ) / 2.0 ), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/pi-squared/test/test.js b/lib/node_modules/@stdlib/constants/float32/pi-squared/test/test.js
index 973c8e89a1d1..b8c0a0fdf18a 100644
--- a/lib/node_modules/@stdlib/constants/float32/pi-squared/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/pi-squared/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 9.869604110717773', function test( t ) {
-	t.equal( FLOAT32_PI_SQUARED, 9.869604110717773, 'returns expected value' );
+	t.strictEqual( FLOAT32_PI_SQUARED, 9.869604110717773, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float32/pi/test/test.js b/lib/node_modules/@stdlib/constants/float32/pi/test/test.js
index b54bcb9e789a..ab24e735f764 100644
--- a/lib/node_modules/@stdlib/constants/float32/pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/pi/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to 3.1415927410125732', function test( t ) {
-	t.equal( FLOAT32_PI, float64ToFloat32( 3.141592653589793 ), 'returns expected value' );
+	t.strictEqual( FLOAT32_PI, float64ToFloat32( 3.141592653589793 ), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/pinf/test/test.js b/lib/node_modules/@stdlib/constants/float32/pinf/test/test.js
index 633b4d144b2c..289991ede34c 100644
--- a/lib/node_modules/@stdlib/constants/float32/pinf/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/pinf/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is a number', function test( t ) {
 
 tape( 'export is equal to positive infinity', function test( t ) {
 	// Note: we rely on implicit type promotion. A 32-bit infinity should be promoted to a 64-bit infinity...
-	t.equal( FLOAT32_PINF, Number.POSITIVE_INFINITY, 'returns expected value' );
+	t.strictEqual( FLOAT32_PINF, Number.POSITIVE_INFINITY, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/precision/test/test.js b/lib/node_modules/@stdlib/constants/float32/precision/test/test.js
index bbf59bfc7623..00da9861ab5d 100644
--- a/lib/node_modules/@stdlib/constants/float32/precision/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/precision/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 24', function test( t ) {
-	t.equal( FLOAT32_PRECISION, 24, 'returns expected value' );
+	t.strictEqual( FLOAT32_PRECISION, 24, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/smallest-normal/test/test.js b/lib/node_modules/@stdlib/constants/float32/smallest-normal/test/test.js
index 8a586f77bb04..7cec397cba1f 100644
--- a/lib/node_modules/@stdlib/constants/float32/smallest-normal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/smallest-normal/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value equals the smallest normal value', function test( t ) {
-	t.equal( FLOAT32_SMALLEST_NORMAL, pow(2, -126), 'returns expected value' );
+	t.strictEqual( FLOAT32_SMALLEST_NORMAL, pow(2, -126), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/smallest-subnormal/test/test.js b/lib/node_modules/@stdlib/constants/float32/smallest-subnormal/test/test.js
index d1e32d6a8fde..a4c45ea7b023 100644
--- a/lib/node_modules/@stdlib/constants/float32/smallest-subnormal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/smallest-subnormal/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value equals the smallest single-precision floating-point denormalized value', function test( t ) {
-	t.equal( FLOAT32_SMALLEST_SUBNORMAL, pow(2, -126)*pow(2, -23), 'returns expected value' );
+	t.strictEqual( FLOAT32_SMALLEST_SUBNORMAL, pow(2, -126)*pow(2, -23), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/sqrt-half-pi/test/test.js b/lib/node_modules/@stdlib/constants/float32/sqrt-half-pi/test/test.js
index bf2b450a7b2a..acb8968e87a3 100644
--- a/lib/node_modules/@stdlib/constants/float32/sqrt-half-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/sqrt-half-pi/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is a single-precision floating-point number equal to `1.2533141374588013`', function test( t ) {
-	t.equal( FLOAT32_SQRT_HALF_PI, 1.2533141374588013, 'returns expected value' );
+	t.strictEqual( FLOAT32_SQRT_HALF_PI, 1.2533141374588013, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/sqrt-half/test/test.js b/lib/node_modules/@stdlib/constants/float32/sqrt-half/test/test.js
index 42f772502b4f..987fb7dda7fa 100644
--- a/lib/node_modules/@stdlib/constants/float32/sqrt-half/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/sqrt-half/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is a single-precision floating-point number equal to the square root of 1/2', function test( t ) {
-	t.equal( FLOAT32_SQRT_HALF, float64ToFloat32( sqrtf( 1/2 ) ), 'returns expected value' );
+	t.strictEqual( FLOAT32_SQRT_HALF, float64ToFloat32( sqrtf( 1/2 ) ), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/sqrt-phi/test/test.js b/lib/node_modules/@stdlib/constants/float32/sqrt-phi/test/test.js
index 3f67f1792378..e66f5d55a83e 100644
--- a/lib/node_modules/@stdlib/constants/float32/sqrt-phi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/sqrt-phi/test/test.js
@@ -35,11 +35,11 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to 1.272019624710083', function test( t ) {
-	t.equal( FLOAT32_SQRT_PHI, 1.272019624710083, 'returns expected value' );
+	t.strictEqual( FLOAT32_SQRT_PHI, 1.272019624710083, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the exported value equals sqrtf(φ)', function test( t ) {
-	t.equal( FLOAT32_SQRT_PHI, sqrtf(PHI), 'returns expected value' );
+	t.strictEqual( FLOAT32_SQRT_PHI, sqrtf(PHI), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/sqrt-pi/test/test.js b/lib/node_modules/@stdlib/constants/float32/sqrt-pi/test/test.js
index de578521633d..7855f546eb16 100644
--- a/lib/node_modules/@stdlib/constants/float32/sqrt-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/sqrt-pi/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to `1.7724539041519165`', function test( t ) {
-	t.equal( FLOAT32_SQRT_PI, 1.7724539041519165, 'returns expected value' );
+	t.strictEqual( FLOAT32_SQRT_PI, 1.7724539041519165, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/sqrt-three/test/test.js b/lib/node_modules/@stdlib/constants/float32/sqrt-three/test/test.js
index ae7c04d2f901..fc9f90462a1c 100644
--- a/lib/node_modules/@stdlib/constants/float32/sqrt-three/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/sqrt-three/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is a single-precision floating-point number equal to the square root of 3', function test( t ) {
-	t.equal( FLOAT32_SQRT3, float64ToFloat32( sqrtf( 3 ) ), 'returns expected value' );
+	t.strictEqual( FLOAT32_SQRT3, float64ToFloat32( sqrtf( 3 ) ), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/sqrt-two-pi/test/test.js b/lib/node_modules/@stdlib/constants/float32/sqrt-two-pi/test/test.js
index 80c0d240962b..5b8a12df7273 100644
--- a/lib/node_modules/@stdlib/constants/float32/sqrt-two-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/sqrt-two-pi/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is a single-precision floating-point number equal to square root of the `π` times `2`', function test( t ) {
-	t.equal( FLOAT32_SQRT_TWO_PI, 2.5066282749176025, 'returns expected value' );
+	t.strictEqual( FLOAT32_SQRT_TWO_PI, 2.5066282749176025, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/sqrt-two/test/test.js b/lib/node_modules/@stdlib/constants/float32/sqrt-two/test/test.js
index e01cc1b0865a..5dfeb68e45aa 100644
--- a/lib/node_modules/@stdlib/constants/float32/sqrt-two/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/sqrt-two/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is a number', function test( t ) {
 
 tape( 'the exported value is a single-precision floating-point number equal to the square root of 2', function test( t ) {
 	var expected = sqrtf( 2 );
-	t.equal( FLOAT32_SQRT2, expected, 'returns expected value' );
+	t.strictEqual( FLOAT32_SQRT2, expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/test/test.js b/lib/node_modules/@stdlib/constants/float32/test/test.js
index 1b76e1509199..6cf498aee928 100644
--- a/lib/node_modules/@stdlib/constants/float32/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains constants', function test( t ) {
 	var keys = objectKeys( constants );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float32/two-pi/test/test.js b/lib/node_modules/@stdlib/constants/float32/two-pi/test/test.js
index 0a598a557607..ca067f911893 100644
--- a/lib/node_modules/@stdlib/constants/float32/two-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float32/two-pi/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a single-precision floating-point number equal to 6.2831854820251465', function test( t ) {
-	t.equal( FLOAT32_TWO_PI, float64ToFloat32( 6.283185307179586 ), 'returns expected value' );
+	t.strictEqual( FLOAT32_TWO_PI, float64ToFloat32( 6.283185307179586 ), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/apery/test/test.js b/lib/node_modules/@stdlib/constants/float64/apery/test/test.js
index 829ad4ba2872..3d8be9e7bf79 100644
--- a/lib/node_modules/@stdlib/constants/float64/apery/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/apery/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is a double-precision floating-point number equal to 1.2020569031595942', function test( t ) {
-	t.equal( APERY, 1.2020569031595942, 'returns expected value' );
+	t.strictEqual( APERY, 1.2020569031595942, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/catalan/test/test.js b/lib/node_modules/@stdlib/constants/float64/catalan/test/test.js
index 534143eb2555..500c49874d46 100644
--- a/lib/node_modules/@stdlib/constants/float64/catalan/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/catalan/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is a double-precision floating-point number equal to 0.915965594177219', function test( t ) {
-	t.equal( CATALAN, 0.915965594177219, 'returns expected value' );
+	t.strictEqual( CATALAN, 0.915965594177219, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/cbrt-eps/test/test.js b/lib/node_modules/@stdlib/constants/float64/cbrt-eps/test/test.js
index 46647fa5f575..3ef54ce539d6 100644
--- a/lib/node_modules/@stdlib/constants/float64/cbrt-eps/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/cbrt-eps/test/test.js
@@ -36,6 +36,6 @@ tape( 'main export is a number', function test( t ) {
 
 tape( 'the exported value equals the cube root of the difference between one and the smallest value greater than one which is representable as a double (2**-52)', function test( t ) {
 	var expected = cbrt( pow( 2, -52 ) );
-	t.equal( FLOAT64_CBRT_EPSILON, expected, 'returns expected value' );
+	t.strictEqual( FLOAT64_CBRT_EPSILON, expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/e/test/test.js b/lib/node_modules/@stdlib/constants/float64/e/test/test.js
index c948f3ed520a..91496b3b2f3c 100644
--- a/lib/node_modules/@stdlib/constants/float64/e/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/e/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 2.718281828459045', function test( t ) {
-	t.equal( E, 2.718281828459045, 'returns expected value' );
+	t.strictEqual( E, 2.718281828459045, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/eps/test/test.js b/lib/node_modules/@stdlib/constants/float64/eps/test/test.js
index 029960186c2d..bf5ed90de630 100644
--- a/lib/node_modules/@stdlib/constants/float64/eps/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/eps/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is a number', function test( t ) {
 
 tape( 'the exported value equals the difference between one and the smallest value greater than one which is representable as a double (2**-52)', function test( t ) {
 	var expected = pow( 2, -52 );
-	t.equal( FLOAT64_EPSILON, expected, 'returns expected value' );
+	t.strictEqual( FLOAT64_EPSILON, expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/eulergamma/test/test.js b/lib/node_modules/@stdlib/constants/float64/eulergamma/test/test.js
index d07f28c102bf..21ed1b10cce3 100644
--- a/lib/node_modules/@stdlib/constants/float64/eulergamma/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/eulergamma/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is a double-precision floating-point number equal to 0.5772156649015329', function test( t ) {
-	t.equal( EULERGAMMA, 0.5772156649015329, 'returns expected value' );
+	t.strictEqual( EULERGAMMA, 0.5772156649015329, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/exponent-bias/test/test.js b/lib/node_modules/@stdlib/constants/float64/exponent-bias/test/test.js
index 91f9b614d611..4bcdef822b62 100644
--- a/lib/node_modules/@stdlib/constants/float64/exponent-bias/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/exponent-bias/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 1023', function test( t ) {
-	t.equal( FLOAT64_EXPONENT_BIAS, 1023, 'returns expected value' );
+	t.strictEqual( FLOAT64_EXPONENT_BIAS, 1023, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/fourth-pi/test/test.js b/lib/node_modules/@stdlib/constants/float64/fourth-pi/test/test.js
index 7045c32d1808..eb52d11abd54 100644
--- a/lib/node_modules/@stdlib/constants/float64/fourth-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/fourth-pi/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 7.85398163397448309616e-1', function test( t ) {
-	t.equal( FOURTH_PI, 7.85398163397448309616e-1, 'returns expected value' );
+	t.strictEqual( FOURTH_PI, 7.85398163397448309616e-1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/fourth-root-eps/test/test.js b/lib/node_modules/@stdlib/constants/float64/fourth-root-eps/test/test.js
index 76e0bd9c5bde..aa0cbc9c96cb 100644
--- a/lib/node_modules/@stdlib/constants/float64/fourth-root-eps/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/fourth-root-eps/test/test.js
@@ -36,6 +36,6 @@ tape( 'main export is a number', function test( t ) {
 
 tape( 'the exported value equals the fourth root of the difference between one and the smallest value greater than one which is representable as a double (2**-52)', function test( t ) {
 	var expected = sqrt( sqrt( pow( 2, -52 ) ) );
-	t.equal( FLOAT64_FOURTH_ROOT_EPS, expected, 'returns expected value' );
+	t.strictEqual( FLOAT64_FOURTH_ROOT_EPS, expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/glaisher-kinkelin/test/test.js b/lib/node_modules/@stdlib/constants/float64/glaisher-kinkelin/test/test.js
index 44c88419ed85..8a0d83e59678 100644
--- a/lib/node_modules/@stdlib/constants/float64/glaisher-kinkelin/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/glaisher-kinkelin/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is a double-precision floating-point number equal to `1.2824271291006226`', function test( t ) {
-	t.equal( A, 1.2824271291006226, 'returns expected value' );
+	t.strictEqual( A, 1.2824271291006226, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/half-ln-two/test/test.js b/lib/node_modules/@stdlib/constants/float64/half-ln-two/test/test.js
index 094a06573a39..35cfd8eee01c 100644
--- a/lib/node_modules/@stdlib/constants/float64/half-ln-two/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/half-ln-two/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to `3.46573590279972654709e-01`', function test( t ) {
-	t.equal( HALF_LN2, 3.46573590279972654709e-01, 'returns expected value' );
+	t.strictEqual( HALF_LN2, 3.46573590279972654709e-01, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float64/half-pi/test/test.js b/lib/node_modules/@stdlib/constants/float64/half-pi/test/test.js
index fd1fd647d9a1..c2cf421eb58f 100644
--- a/lib/node_modules/@stdlib/constants/float64/half-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/half-pi/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 1.5707963267948966', function test( t ) {
-	t.equal( HALF_PI, 1.5707963267948966, 'returns expected value' );
+	t.strictEqual( HALF_PI, 1.5707963267948966, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/ln-half/test/test.js b/lib/node_modules/@stdlib/constants/float64/ln-half/test/test.js
index a429b8d043e6..85b3c6d6005f 100644
--- a/lib/node_modules/@stdlib/constants/float64/ln-half/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/ln-half/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to `-0.6931471805599453`', function test( t ) {
-	t.equal( LN_HALF, -0.6931471805599453, 'returns expected value' );
+	t.strictEqual( LN_HALF, -0.6931471805599453, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float64/ln-pi/test/test.js b/lib/node_modules/@stdlib/constants/float64/ln-pi/test/test.js
index aa6d4212c474..a057b2670592 100644
--- a/lib/node_modules/@stdlib/constants/float64/ln-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/ln-pi/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 1.1447298858494002', function test( t ) {
-	t.equal( LN_PI, 1.1447298858494002, 'returns expected value' );
+	t.strictEqual( LN_PI, 1.1447298858494002, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/ln-sqrt-two-pi/test/test.js b/lib/node_modules/@stdlib/constants/float64/ln-sqrt-two-pi/test/test.js
index 7e9c5ae2ad53..678af7ac5b34 100644
--- a/lib/node_modules/@stdlib/constants/float64/ln-sqrt-two-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/ln-sqrt-two-pi/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 0.9189385332046728', function test( t ) {
-	t.equal( LN_SQRT_TWO_PI, 0.9189385332046728, 'returns expected value' );
+	t.strictEqual( LN_SQRT_TWO_PI, 0.9189385332046728, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float64/ln-ten/test/test.js b/lib/node_modules/@stdlib/constants/float64/ln-ten/test/test.js
index 9156b6f0c2c2..5e11bf47bea6 100644
--- a/lib/node_modules/@stdlib/constants/float64/ln-ten/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/ln-ten/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to `2.302585092994046`', function test( t ) {
-	t.equal( LN10, 2.302585092994046, 'returns expected value' );
+	t.strictEqual( LN10, 2.302585092994046, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float64/ln-two-pi/test/test.js b/lib/node_modules/@stdlib/constants/float64/ln-two-pi/test/test.js
index cba10aa7aa86..6adde11c1995 100644
--- a/lib/node_modules/@stdlib/constants/float64/ln-two-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/ln-two-pi/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to `1.8378770664093456`', function test( t ) {
-	t.equal( LN_TWO_PI, 1.8378770664093456, 'returns expected value' );
+	t.strictEqual( LN_TWO_PI, 1.8378770664093456, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float64/ln-two/test/test.js b/lib/node_modules/@stdlib/constants/float64/ln-two/test/test.js
index bc44dfe270de..f28804029254 100644
--- a/lib/node_modules/@stdlib/constants/float64/ln-two/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/ln-two/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to `0.6931471805599453`', function test( t ) {
-	t.equal( LN2, 0.6931471805599453, 'returns expected value' );
+	t.strictEqual( LN2, 0.6931471805599453, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float64/log10-e/test/test.js b/lib/node_modules/@stdlib/constants/float64/log10-e/test/test.js
index 1b7bf4ab2d14..9ba52cbbd5b0 100644
--- a/lib/node_modules/@stdlib/constants/float64/log10-e/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/log10-e/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 0.4342944819032518', function test( t ) {
-	t.equal( LOG10E, 0.4342944819032518, 'returns expected value' );
+	t.strictEqual( LOG10E, 0.4342944819032518, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/log2-e/test/test.js b/lib/node_modules/@stdlib/constants/float64/log2-e/test/test.js
index 3e4b72324521..55fbc497bf3f 100644
--- a/lib/node_modules/@stdlib/constants/float64/log2-e/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/log2-e/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 1.4426950408889634', function test( t ) {
-	t.equal( LOG2E, 1.4426950408889634, 'returns expected value' );
+	t.strictEqual( LOG2E, 1.4426950408889634, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/max-base10-exponent-subnormal/test/test.js b/lib/node_modules/@stdlib/constants/float64/max-base10-exponent-subnormal/test/test.js
index 0b7a674da776..334adc27d38e 100644
--- a/lib/node_modules/@stdlib/constants/float64/max-base10-exponent-subnormal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/max-base10-exponent-subnormal/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is `-308`', function test( t ) {
-	t.equal( FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL, -308, 'returns expected value' );
+	t.strictEqual( FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL, -308, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/max-base10-exponent/test/test.js b/lib/node_modules/@stdlib/constants/float64/max-base10-exponent/test/test.js
index 3c9bbc99db30..0da4ca1d9670 100644
--- a/lib/node_modules/@stdlib/constants/float64/max-base10-exponent/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/max-base10-exponent/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is `308`', function test( t ) {
-	t.equal( FLOAT64_MAX_BASE10_EXPONENT, 308, 'returns expected value' );
+	t.strictEqual( FLOAT64_MAX_BASE10_EXPONENT, 308, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/max-base2-exponent-subnormal/test/test.js b/lib/node_modules/@stdlib/constants/float64/max-base2-exponent-subnormal/test/test.js
index 362d64667463..a08eeca64c83 100644
--- a/lib/node_modules/@stdlib/constants/float64/max-base2-exponent-subnormal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/max-base2-exponent-subnormal/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is -1023', function test( t ) {
-	t.equal( FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL, -1023, 'returns expected value' );
+	t.strictEqual( FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL, -1023, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/max-base2-exponent/test/test.js b/lib/node_modules/@stdlib/constants/float64/max-base2-exponent/test/test.js
index b2fd993c6461..1bdf64e76502 100644
--- a/lib/node_modules/@stdlib/constants/float64/max-base2-exponent/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/max-base2-exponent/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 1023', function test( t ) {
-	t.equal( FLOAT64_MAX_BASE2_EXPONENT, 1023, 'returns expected value' );
+	t.strictEqual( FLOAT64_MAX_BASE2_EXPONENT, 1023, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/max-ln/test/test.js b/lib/node_modules/@stdlib/constants/float64/max-ln/test/test.js
index b1b822c1a4c2..18384f5055f7 100644
--- a/lib/node_modules/@stdlib/constants/float64/max-ln/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/max-ln/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to the natural logarithm of the max double-precision floating-point number', function test( t ) {
-	t.equal( FLOAT64_MAX_LN, ln( pow(2, 1023) * (2-pow(2, -52)) ), 'equals the logarithm of the max value (computed)' );
-	t.equal( FLOAT64_MAX_LN, ln( FLOAT64_MAX ), 'equals the logarithm of the max value' );
+	t.strictEqual( FLOAT64_MAX_LN, ln( pow(2, 1023) * (2-pow(2, -52)) ), 'equals the logarithm of the max value (computed)' );
+	t.strictEqual( FLOAT64_MAX_LN, ln( FLOAT64_MAX ), 'equals the logarithm of the max value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/max-safe-integer/test/test.js b/lib/node_modules/@stdlib/constants/float64/max-safe-integer/test/test.js
index 80bec8c8f439..a88609379324 100644
--- a/lib/node_modules/@stdlib/constants/float64/max-safe-integer/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/max-safe-integer/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 2**53-1', function test( t ) {
-	t.equal( FLOAT64_MAX_SAFE_INTEGER, pow(2, 53)-1, 'returns expected value' );
+	t.strictEqual( FLOAT64_MAX_SAFE_INTEGER, pow(2, 53)-1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/max/test/test.js b/lib/node_modules/@stdlib/constants/float64/max/test/test.js
index dd853301357c..8f5a0493764c 100644
--- a/lib/node_modules/@stdlib/constants/float64/max/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/max/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to the max double-precision floating-point number', function test( t ) {
-	t.equal( FLOAT64_MAX, pow(2, 1023) * (2-pow(2, -52)), 'equals max value' );
-	t.equal( FLOAT64_MAX, Number.MAX_VALUE, 'equals max value (Number object)' );
+	t.strictEqual( FLOAT64_MAX, pow(2, 1023) * (2-pow(2, -52)), 'equals max value' );
+	t.strictEqual( FLOAT64_MAX, Number.MAX_VALUE, 'equals max value (Number object)' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/min-base10-exponent-subnormal/test/test.js b/lib/node_modules/@stdlib/constants/float64/min-base10-exponent-subnormal/test/test.js
index a9102e5fda34..940b75b7f1b8 100644
--- a/lib/node_modules/@stdlib/constants/float64/min-base10-exponent-subnormal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/min-base10-exponent-subnormal/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is `-324`', function test( t ) {
-	t.equal( FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL, -324, 'returns expected value' );
+	t.strictEqual( FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL, -324, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/min-base10-exponent/test/test.js b/lib/node_modules/@stdlib/constants/float64/min-base10-exponent/test/test.js
index bfef5b90d473..1157f464de99 100644
--- a/lib/node_modules/@stdlib/constants/float64/min-base10-exponent/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/min-base10-exponent/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is `-308`', function test( t ) {
-	t.equal( FLOAT64_MIN_BASE10_EXPONENT, -308, 'returns expected value' );
+	t.strictEqual( FLOAT64_MIN_BASE10_EXPONENT, -308, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/min-base2-exponent-subnormal/test/test.js b/lib/node_modules/@stdlib/constants/float64/min-base2-exponent-subnormal/test/test.js
index 12dcb1f4e2ea..49c49053e297 100644
--- a/lib/node_modules/@stdlib/constants/float64/min-base2-exponent-subnormal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/min-base2-exponent-subnormal/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is -1074', function test( t ) {
-	t.equal( FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL, -1074, 'returns expected value' );
+	t.strictEqual( FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL, -1074, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/min-base2-exponent/test/test.js b/lib/node_modules/@stdlib/constants/float64/min-base2-exponent/test/test.js
index 44f574907605..6d3940ec84d5 100644
--- a/lib/node_modules/@stdlib/constants/float64/min-base2-exponent/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/min-base2-exponent/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is `-1022`', function test( t ) {
-	t.equal( FLOAT64_MIN_BASE2_EXPONENT, -1022, 'returns expected value' );
+	t.strictEqual( FLOAT64_MIN_BASE2_EXPONENT, -1022, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/min-ln/test/test.js b/lib/node_modules/@stdlib/constants/float64/min-ln/test/test.js
index 39681296b737..d21a7b8ac1e6 100644
--- a/lib/node_modules/@stdlib/constants/float64/min-ln/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/min-ln/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to the natural logarithm of the smallest normalized double-precision floating-point number', function test( t ) {
-	t.equal( FLOAT64_MIN_LN, -ln( pow( 2, 1022 ) ), 'equals the logarithm of the smallest normalized double-precision floating-point number' );
-	t.equal( FLOAT64_MIN_LN, ln( SMALLEST_NORMAL ), 'equals the logarithm of the smallest normalized double-precision floating-point number' );
+	t.strictEqual( FLOAT64_MIN_LN, -ln( pow( 2, 1022 ) ), 'equals the logarithm of the smallest normalized double-precision floating-point number' );
+	t.strictEqual( FLOAT64_MIN_LN, ln( SMALLEST_NORMAL ), 'equals the logarithm of the smallest normalized double-precision floating-point number' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/min-safe-integer/test/test.js b/lib/node_modules/@stdlib/constants/float64/min-safe-integer/test/test.js
index ad187df15b54..208c3765eb06 100644
--- a/lib/node_modules/@stdlib/constants/float64/min-safe-integer/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/min-safe-integer/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is -2**53+1', function test( t ) {
-	t.equal( FLOAT64_MIN_SAFE_INTEGER, -pow(2, 53)+1, 'returns expected value' );
+	t.strictEqual( FLOAT64_MIN_SAFE_INTEGER, -pow(2, 53)+1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/ninf/test/test.js b/lib/node_modules/@stdlib/constants/float64/ninf/test/test.js
index aea01591d408..8241a7563dae 100644
--- a/lib/node_modules/@stdlib/constants/float64/ninf/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/ninf/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is equal to negative infinity', function test( t ) {
-	t.equal( FLOAT64_NINF, Number.NEGATIVE_INFINITY, 'returns expected value' );
+	t.strictEqual( FLOAT64_NINF, Number.NEGATIVE_INFINITY, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/num-bytes/test/test.js b/lib/node_modules/@stdlib/constants/float64/num-bytes/test/test.js
index 22e604a7a3e0..778e039999c3 100644
--- a/lib/node_modules/@stdlib/constants/float64/num-bytes/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/num-bytes/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 8', function test( t ) {
-	t.equal( NUM_BYTES, 8, 'returns expected value' );
+	t.strictEqual( NUM_BYTES, 8, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/num-high-word-significand-bits/test/test.js b/lib/node_modules/@stdlib/constants/float64/num-high-word-significand-bits/test/test.js
index 35132a72ea41..220f22a97602 100644
--- a/lib/node_modules/@stdlib/constants/float64/num-high-word-significand-bits/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/num-high-word-significand-bits/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 20', function test( t ) {
-	t.equal( FLOAT64_NUM_HIGH_WORD_SIGNIFICAND_BITS, 20, 'returns expected value' );
+	t.strictEqual( FLOAT64_NUM_HIGH_WORD_SIGNIFICAND_BITS, 20, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/phi/test/test.js b/lib/node_modules/@stdlib/constants/float64/phi/test/test.js
index e1d7f602a59c..63b0f2f4df06 100644
--- a/lib/node_modules/@stdlib/constants/float64/phi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/phi/test/test.js
@@ -34,11 +34,11 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 1.618033988749895', function test( t ) {
-	t.equal( PHI, 1.618033988749895, 'returns expected value' );
+	t.strictEqual( PHI, 1.618033988749895, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the exported value equals (1+sqrt(5))/2', function test( t ) {
-	t.equal( PHI, (1.0+sqrt(5.0))/2.0, 'returns expected value' );
+	t.strictEqual( PHI, (1.0+sqrt(5.0))/2.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/pi-squared/test/test.js b/lib/node_modules/@stdlib/constants/float64/pi-squared/test/test.js
index 4d4d33ca12a3..8f150b69889e 100644
--- a/lib/node_modules/@stdlib/constants/float64/pi-squared/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/pi-squared/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 9.869604401089358', function test( t ) {
-	t.equal( PI_SQUARED, 9.869604401089358, 'returns expected value' );
+	t.strictEqual( PI_SQUARED, 9.869604401089358, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/constants/float64/pi/test/test.js b/lib/node_modules/@stdlib/constants/float64/pi/test/test.js
index 5cdfa30db650..05271ab880c4 100644
--- a/lib/node_modules/@stdlib/constants/float64/pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/pi/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 3.141592653589793', function test( t ) {
-	t.equal( PI, 3.141592653589793, 'returns expected value' );
+	t.strictEqual( PI, 3.141592653589793, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/pinf/test/test.js b/lib/node_modules/@stdlib/constants/float64/pinf/test/test.js
index 82c327f7f046..b829b86e5ba7 100644
--- a/lib/node_modules/@stdlib/constants/float64/pinf/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/pinf/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is equal to positive infinity', function test( t ) {
-	t.equal( FLOAT64_PINF, Number.POSITIVE_INFINITY, 'returns expected value' );
+	t.strictEqual( FLOAT64_PINF, Number.POSITIVE_INFINITY, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/precision/test/test.js b/lib/node_modules/@stdlib/constants/float64/precision/test/test.js
index d23eb46ebada..67feb6021c91 100644
--- a/lib/node_modules/@stdlib/constants/float64/precision/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/precision/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 53', function test( t ) {
-	t.equal( FLOAT64_PRECISION, 53, 'returns expected value' );
+	t.strictEqual( FLOAT64_PRECISION, 53, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/smallest-normal/test/test.js b/lib/node_modules/@stdlib/constants/float64/smallest-normal/test/test.js
index b2433b3e8521..ca64a5734f6a 100644
--- a/lib/node_modules/@stdlib/constants/float64/smallest-normal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/smallest-normal/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value equals the smallest normalized double-precision floating-point number', function test( t ) {
-	t.equal( FLOAT64_SMALLEST_NORMAL, 2.2250738585072014e-308, 'returns expected value' );
+	t.strictEqual( FLOAT64_SMALLEST_NORMAL, 2.2250738585072014e-308, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/smallest-subnormal/test/test.js b/lib/node_modules/@stdlib/constants/float64/smallest-subnormal/test/test.js
index 70a33605e68e..a89b411d150b 100644
--- a/lib/node_modules/@stdlib/constants/float64/smallest-subnormal/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/smallest-subnormal/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value equals the smallest double-precision floating-point denormalized value', function test( t ) {
-	t.equal( FLOAT64_SMALLEST_SUBNORMAL, pow(2, -1022)*pow(2, -52), 'returns expected value' );
+	t.strictEqual( FLOAT64_SMALLEST_SUBNORMAL, pow(2, -1022)*pow(2, -52), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/sqrt-eps/test/test.js b/lib/node_modules/@stdlib/constants/float64/sqrt-eps/test/test.js
index e334a3d532c0..5e20fb1374e0 100644
--- a/lib/node_modules/@stdlib/constants/float64/sqrt-eps/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/sqrt-eps/test/test.js
@@ -36,6 +36,6 @@ tape( 'main export is a number', function test( t ) {
 
 tape( 'the exported value equals the square root of the difference between one and the smallest value greater than one which is representable as a double (2**-52)', function test( t ) {
 	var expected = sqrt( pow( 2, -52 ) );
-	t.equal( FLOAT64_SQRT_EPSILON, expected, 'returns expected value' );
+	t.strictEqual( FLOAT64_SQRT_EPSILON, expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/sqrt-half-pi/test/test.js b/lib/node_modules/@stdlib/constants/float64/sqrt-half-pi/test/test.js
index f93fab6e7702..d771c5e429f9 100644
--- a/lib/node_modules/@stdlib/constants/float64/sqrt-half-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/sqrt-half-pi/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to `1.2533141373155003`', function test( t ) {
-	t.equal( SQRT_HALF_PI, 1.2533141373155003, 'returns expected value' );
+	t.strictEqual( SQRT_HALF_PI, 1.2533141373155003, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/sqrt-half/test/test.js b/lib/node_modules/@stdlib/constants/float64/sqrt-half/test/test.js
index 8949e9ecea4c..afe8cbf35b14 100644
--- a/lib/node_modules/@stdlib/constants/float64/sqrt-half/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/sqrt-half/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is a number', function test( t ) {
 
 tape( 'the exported value is a double-precision floating-point number which equals the square root of 1/2', function test( t ) {
 	var expected = sqrt( 1/2 );
-	t.equal( SQRT_HALF, expected, 'returns expected value' );
+	t.strictEqual( SQRT_HALF, expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/sqrt-phi/test/test.js b/lib/node_modules/@stdlib/constants/float64/sqrt-phi/test/test.js
index 589fe407e8f5..69efc1244a4f 100644
--- a/lib/node_modules/@stdlib/constants/float64/sqrt-phi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/sqrt-phi/test/test.js
@@ -35,11 +35,11 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 1.272019649514069', function test( t ) {
-	t.equal( SQRT_PHI, 1.272019649514069, 'returns expected value' );
+	t.strictEqual( SQRT_PHI, 1.272019649514069, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the exported value equals sqrt(φ)', function test( t ) {
-	t.equal( SQRT_PHI, sqrt(PHI), 'returns expected value' );
+	t.strictEqual( SQRT_PHI, sqrt(PHI), 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/sqrt-pi/test/test.js b/lib/node_modules/@stdlib/constants/float64/sqrt-pi/test/test.js
index 18f04de1863b..da1d67f31ef0 100644
--- a/lib/node_modules/@stdlib/constants/float64/sqrt-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/sqrt-pi/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to `1.7724538509055160`', function test( t ) {
-	t.equal( SQRT_PI, 1.7724538509055160, 'returns expected value' );
+	t.strictEqual( SQRT_PI, 1.7724538509055160, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/sqrt-three/test/test.js b/lib/node_modules/@stdlib/constants/float64/sqrt-three/test/test.js
index 47df163bbe09..8692cc70c3a7 100644
--- a/lib/node_modules/@stdlib/constants/float64/sqrt-three/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/sqrt-three/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is a number', function test( t ) {
 
 tape( 'the exported value is a double-precision floating-point number equal to the square root of 3', function test( t ) {
 	var expected = sqrt( 3 );
-	t.equal( SQRT3, expected, 'returns expected value' );
+	t.strictEqual( SQRT3, expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/sqrt-two-pi/test/test.js b/lib/node_modules/@stdlib/constants/float64/sqrt-two-pi/test/test.js
index 76901109c1db..ffa204e2a510 100644
--- a/lib/node_modules/@stdlib/constants/float64/sqrt-two-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/sqrt-two-pi/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to `2.5066282746310007`', function test( t ) {
-	t.equal( SQRT_TWO_PI, 2.5066282746310007, 'returns expected value' );
+	t.strictEqual( SQRT_TWO_PI, 2.5066282746310007, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/sqrt-two/test/test.js b/lib/node_modules/@stdlib/constants/float64/sqrt-two/test/test.js
index 93a8a28a16b2..5f7a6e7c6612 100644
--- a/lib/node_modules/@stdlib/constants/float64/sqrt-two/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/sqrt-two/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is a number', function test( t ) {
 
 tape( 'the exported value is a double-precision floating-point number equal to the square root of 2', function test( t ) {
 	var expected = sqrt( 2 );
-	t.equal( SQRT2, expected, 'returns expected value' );
+	t.strictEqual( SQRT2, expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/test/test.js b/lib/node_modules/@stdlib/constants/float64/test/test.js
index 1b76e1509199..6cf498aee928 100644
--- a/lib/node_modules/@stdlib/constants/float64/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains constants', function test( t ) {
 	var keys = objectKeys( constants );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/float64/two-pi/test/test.js b/lib/node_modules/@stdlib/constants/float64/two-pi/test/test.js
index 135f84ef4fc8..d68057812c0b 100644
--- a/lib/node_modules/@stdlib/constants/float64/two-pi/test/test.js
+++ b/lib/node_modules/@stdlib/constants/float64/two-pi/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'export is a double-precision floating-point number equal to 6.283185307179586', function test( t ) {
-	t.equal( TWO_PI, 6.283185307179586, 'returns expected value' );
+	t.strictEqual( TWO_PI, 6.283185307179586, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/int16/max/test/test.js b/lib/node_modules/@stdlib/constants/int16/max/test/test.js
index bfd0952aaba1..697bc2ada9cf 100644
--- a/lib/node_modules/@stdlib/constants/int16/max/test/test.js
+++ b/lib/node_modules/@stdlib/constants/int16/max/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the value equals 2**15 - 1', function test( t ) {
-	t.equal( INT16_MAX, pow(2, 15) - 1, 'equals 2**15 - 1' );
+	t.strictEqual( INT16_MAX, pow(2, 15) - 1, 'equals 2**15 - 1' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/int16/min/test/test.js b/lib/node_modules/@stdlib/constants/int16/min/test/test.js
index 12e029e3d620..260078a910b4 100644
--- a/lib/node_modules/@stdlib/constants/int16/min/test/test.js
+++ b/lib/node_modules/@stdlib/constants/int16/min/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value equals -2**15', function test( t ) {
-	t.equal( INT16_MIN, -pow(2, 15), 'equals -1 * 2**15' );
+	t.strictEqual( INT16_MIN, -pow(2, 15), 'equals -1 * 2**15' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/int16/num-bytes/test/test.js b/lib/node_modules/@stdlib/constants/int16/num-bytes/test/test.js
index d3b9eee8b0cf..52768ebbbaa0 100644
--- a/lib/node_modules/@stdlib/constants/int16/num-bytes/test/test.js
+++ b/lib/node_modules/@stdlib/constants/int16/num-bytes/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 2', function test( t ) {
-	t.equal( NUM_BYTES, 2, 'equals 2' );
+	t.strictEqual( NUM_BYTES, 2, 'equals 2' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/int16/test/test.js b/lib/node_modules/@stdlib/constants/int16/test/test.js
index 1b76e1509199..6cf498aee928 100644
--- a/lib/node_modules/@stdlib/constants/int16/test/test.js
+++ b/lib/node_modules/@stdlib/constants/int16/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains constants', function test( t ) {
 	var keys = objectKeys( constants );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/int32/max/test/test.js b/lib/node_modules/@stdlib/constants/int32/max/test/test.js
index 935fbe6cf8fa..c035c43b4532 100644
--- a/lib/node_modules/@stdlib/constants/int32/max/test/test.js
+++ b/lib/node_modules/@stdlib/constants/int32/max/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value equals 2**31 - 1', function test( t ) {
-	t.equal( INT32_MAX, pow(2, 31) - 1, 'equals 2**31 - 1' );
+	t.strictEqual( INT32_MAX, pow(2, 31) - 1, 'equals 2**31 - 1' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/int32/min/test/test.js b/lib/node_modules/@stdlib/constants/int32/min/test/test.js
index e87349ed1af0..31f703588161 100644
--- a/lib/node_modules/@stdlib/constants/int32/min/test/test.js
+++ b/lib/node_modules/@stdlib/constants/int32/min/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value equals -2**31', function test( t ) {
-	t.equal( INT32_MIN, -pow(2, 31), 'equals -1 * 2**31' );
+	t.strictEqual( INT32_MIN, -pow(2, 31), 'equals -1 * 2**31' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/int32/num-bytes/test/test.js b/lib/node_modules/@stdlib/constants/int32/num-bytes/test/test.js
index 3709f8aeb3e1..809b1765efba 100644
--- a/lib/node_modules/@stdlib/constants/int32/num-bytes/test/test.js
+++ b/lib/node_modules/@stdlib/constants/int32/num-bytes/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 4', function test( t ) {
-	t.equal( NUM_BYTES, 4, 'equals 4' );
+	t.strictEqual( NUM_BYTES, 4, 'equals 4' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/int32/test/test.js b/lib/node_modules/@stdlib/constants/int32/test/test.js
index 1b76e1509199..6cf498aee928 100644
--- a/lib/node_modules/@stdlib/constants/int32/test/test.js
+++ b/lib/node_modules/@stdlib/constants/int32/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains constants', function test( t ) {
 	var keys = objectKeys( constants );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/int8/max/test/test.js b/lib/node_modules/@stdlib/constants/int8/max/test/test.js
index d92234c44cb0..d85bc7c252c5 100644
--- a/lib/node_modules/@stdlib/constants/int8/max/test/test.js
+++ b/lib/node_modules/@stdlib/constants/int8/max/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value equals 2**7 - 1', function test( t ) {
-	t.equal( INT8_MAX, pow(2, 7)-1, 'equals 2**7-1' );
+	t.strictEqual( INT8_MAX, pow(2, 7)-1, 'equals 2**7-1' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/int8/min/test/test.js b/lib/node_modules/@stdlib/constants/int8/min/test/test.js
index 4a7120c5d70c..40f1738a4482 100644
--- a/lib/node_modules/@stdlib/constants/int8/min/test/test.js
+++ b/lib/node_modules/@stdlib/constants/int8/min/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value equals -2**7', function test( t ) {
-	t.equal( INT8_MIN, -pow(2, 7), 'equals -1 * 2**7' );
+	t.strictEqual( INT8_MIN, -pow(2, 7), 'equals -1 * 2**7' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/int8/num-bytes/test/test.js b/lib/node_modules/@stdlib/constants/int8/num-bytes/test/test.js
index 5495803fc05c..184a630747ee 100644
--- a/lib/node_modules/@stdlib/constants/int8/num-bytes/test/test.js
+++ b/lib/node_modules/@stdlib/constants/int8/num-bytes/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 1', function test( t ) {
-	t.equal( NUM_BYTES, 1, 'equals 1' );
+	t.strictEqual( NUM_BYTES, 1, 'equals 1' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/int8/test/test.js b/lib/node_modules/@stdlib/constants/int8/test/test.js
index 1b76e1509199..6cf498aee928 100644
--- a/lib/node_modules/@stdlib/constants/int8/test/test.js
+++ b/lib/node_modules/@stdlib/constants/int8/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains constants', function test( t ) {
 	var keys = objectKeys( constants );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/path/delimiter-posix/test/test.js b/lib/node_modules/@stdlib/constants/path/delimiter-posix/test/test.js
index 351c8346a306..0c3883af0963 100644
--- a/lib/node_modules/@stdlib/constants/path/delimiter-posix/test/test.js
+++ b/lib/node_modules/@stdlib/constants/path/delimiter-posix/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a string', function test( t ) {
 });
 
 tape( 'string is equal to \':\'', function test( t ) {
-	t.equal( PATH_DELIMITER_POSIX, ':', 'equals :' );
+	t.strictEqual( PATH_DELIMITER_POSIX, ':', 'equals :' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/path/delimiter-win32/test/test.js b/lib/node_modules/@stdlib/constants/path/delimiter-win32/test/test.js
index 36e197363099..2e0b8e03a1a1 100644
--- a/lib/node_modules/@stdlib/constants/path/delimiter-win32/test/test.js
+++ b/lib/node_modules/@stdlib/constants/path/delimiter-win32/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a string', function test( t ) {
 });
 
 tape( 'string is equal to \';\'', function test( t ) {
-	t.equal( PATH_DELIMITER_WIN32, ';', 'equals ;' );
+	t.strictEqual( PATH_DELIMITER_WIN32, ';', 'equals ;' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/path/delimiter/test/test.js b/lib/node_modules/@stdlib/constants/path/delimiter/test/test.js
index 9610cb160897..4f61545cbd83 100644
--- a/lib/node_modules/@stdlib/constants/path/delimiter/test/test.js
+++ b/lib/node_modules/@stdlib/constants/path/delimiter/test/test.js
@@ -39,7 +39,7 @@ tape( 'if platform is POSIX, export is the POSIX path delimiter', function test(
 	var PATH_DELIMITER = proxyquire( './../lib', {
 		'@stdlib/assert/is-windows': false
 	});
-	t.equal( PATH_DELIMITER, PATH_DELIMITER_POSIX, 'equals POSIX delimiter' );
+	t.strictEqual( PATH_DELIMITER, PATH_DELIMITER_POSIX, 'equals POSIX delimiter' );
 	t.end();
 });
 
@@ -47,6 +47,6 @@ tape( 'if platform is Windows, export is the Windows path delimiter', function t
 	var PATH_DELIMITER = proxyquire( './../lib', {
 		'@stdlib/assert/is-windows': true
 	});
-	t.equal( PATH_DELIMITER, PATH_DELIMITER_WIN32, 'equals Windows delimiter' );
+	t.strictEqual( PATH_DELIMITER, PATH_DELIMITER_WIN32, 'equals Windows delimiter' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/path/sep-posix/test/test.js b/lib/node_modules/@stdlib/constants/path/sep-posix/test/test.js
index ae91201e2c31..70ee40c3a457 100644
--- a/lib/node_modules/@stdlib/constants/path/sep-posix/test/test.js
+++ b/lib/node_modules/@stdlib/constants/path/sep-posix/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a string', function test( t ) {
 });
 
 tape( 'string is equal to \'/\'', function test( t ) {
-	t.equal( PATH_SEP_POSIX, '/', 'equals /' );
+	t.strictEqual( PATH_SEP_POSIX, '/', 'equals /' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/path/sep-win32/test/test.js b/lib/node_modules/@stdlib/constants/path/sep-win32/test/test.js
index 4f82cea3e6f1..2d3e4c99591f 100644
--- a/lib/node_modules/@stdlib/constants/path/sep-win32/test/test.js
+++ b/lib/node_modules/@stdlib/constants/path/sep-win32/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a string', function test( t ) {
 });
 
 tape( 'string is equal to \'\\\'', function test( t ) {
-	t.equal( PATH_SEP_WIN32, '\\', 'equals \\' );
+	t.strictEqual( PATH_SEP_WIN32, '\\', 'equals \\' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/path/sep/test/test.js b/lib/node_modules/@stdlib/constants/path/sep/test/test.js
index b15dfee3f988..29cf89dd9d3c 100644
--- a/lib/node_modules/@stdlib/constants/path/sep/test/test.js
+++ b/lib/node_modules/@stdlib/constants/path/sep/test/test.js
@@ -39,7 +39,7 @@ tape( 'if platform is POSIX, export is the POSIX path separator', function test(
 	var PATH_SEP = proxyquire( './../lib', {
 		'@stdlib/assert/is-windows': false
 	});
-	t.equal( PATH_SEP, PATH_SEP_POSIX, 'equals POSIX separator' );
+	t.strictEqual( PATH_SEP, PATH_SEP_POSIX, 'equals POSIX separator' );
 	t.end();
 });
 
@@ -47,6 +47,6 @@ tape( 'if platform is Windows, export is the Windows path separator', function t
 	var PATH_SEP = proxyquire( './../lib', {
 		'@stdlib/assert/is-windows': true
 	});
-	t.equal( PATH_SEP, PATH_SEP_WIN32, 'equals Windows separator' );
+	t.strictEqual( PATH_SEP, PATH_SEP_WIN32, 'equals Windows separator' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/test/test.js b/lib/node_modules/@stdlib/constants/test/test.js
index 7ef87403bac9..89edd8872507 100644
--- a/lib/node_modules/@stdlib/constants/test/test.js
+++ b/lib/node_modules/@stdlib/constants/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/uint16/max/test/test.js b/lib/node_modules/@stdlib/constants/uint16/max/test/test.js
index 7877caa67590..93a727424a4a 100644
--- a/lib/node_modules/@stdlib/constants/uint16/max/test/test.js
+++ b/lib/node_modules/@stdlib/constants/uint16/max/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 2**16-1', function test( t ) {
-	t.equal( UINT16_MAX, pow(2, 16)-1, 'returns 2**16-1' );
+	t.strictEqual( UINT16_MAX, pow(2, 16)-1, 'returns 2**16-1' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/uint16/num-bytes/test/test.js b/lib/node_modules/@stdlib/constants/uint16/num-bytes/test/test.js
index d3b9eee8b0cf..52768ebbbaa0 100644
--- a/lib/node_modules/@stdlib/constants/uint16/num-bytes/test/test.js
+++ b/lib/node_modules/@stdlib/constants/uint16/num-bytes/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 2', function test( t ) {
-	t.equal( NUM_BYTES, 2, 'equals 2' );
+	t.strictEqual( NUM_BYTES, 2, 'equals 2' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/uint16/test/test.js b/lib/node_modules/@stdlib/constants/uint16/test/test.js
index 1b76e1509199..6cf498aee928 100644
--- a/lib/node_modules/@stdlib/constants/uint16/test/test.js
+++ b/lib/node_modules/@stdlib/constants/uint16/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains constants', function test( t ) {
 	var keys = objectKeys( constants );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/uint32/max/test/test.js b/lib/node_modules/@stdlib/constants/uint32/max/test/test.js
index 7c74baa284b2..1f49647e717f 100644
--- a/lib/node_modules/@stdlib/constants/uint32/max/test/test.js
+++ b/lib/node_modules/@stdlib/constants/uint32/max/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value equals 2**32 - 1', function test( t ) {
-	t.equal( UINT32_MAX, pow(2, 32) - 1, 'equals 2**32 - 1' );
+	t.strictEqual( UINT32_MAX, pow(2, 32) - 1, 'equals 2**32 - 1' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/uint32/num-bytes/test/test.js b/lib/node_modules/@stdlib/constants/uint32/num-bytes/test/test.js
index 3709f8aeb3e1..809b1765efba 100644
--- a/lib/node_modules/@stdlib/constants/uint32/num-bytes/test/test.js
+++ b/lib/node_modules/@stdlib/constants/uint32/num-bytes/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 4', function test( t ) {
-	t.equal( NUM_BYTES, 4, 'equals 4' );
+	t.strictEqual( NUM_BYTES, 4, 'equals 4' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/uint32/test/test.js b/lib/node_modules/@stdlib/constants/uint32/test/test.js
index 1b76e1509199..6cf498aee928 100644
--- a/lib/node_modules/@stdlib/constants/uint32/test/test.js
+++ b/lib/node_modules/@stdlib/constants/uint32/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains constants', function test( t ) {
 	var keys = objectKeys( constants );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/uint8/max/test/test.js b/lib/node_modules/@stdlib/constants/uint8/max/test/test.js
index d6ed838a40cb..98e5478fcfed 100644
--- a/lib/node_modules/@stdlib/constants/uint8/max/test/test.js
+++ b/lib/node_modules/@stdlib/constants/uint8/max/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 2**8-1', function test( t ) {
-	t.equal( UINT8_MAX, pow(2, 8)-1, 'returns 2**8-1' );
+	t.strictEqual( UINT8_MAX, pow(2, 8)-1, 'returns 2**8-1' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/uint8/num-bytes/test/test.js b/lib/node_modules/@stdlib/constants/uint8/num-bytes/test/test.js
index 5495803fc05c..184a630747ee 100644
--- a/lib/node_modules/@stdlib/constants/uint8/num-bytes/test/test.js
+++ b/lib/node_modules/@stdlib/constants/uint8/num-bytes/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 1', function test( t ) {
-	t.equal( NUM_BYTES, 1, 'equals 1' );
+	t.strictEqual( NUM_BYTES, 1, 'equals 1' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/uint8/test/test.js b/lib/node_modules/@stdlib/constants/uint8/test/test.js
index 1b76e1509199..6cf498aee928 100644
--- a/lib/node_modules/@stdlib/constants/uint8/test/test.js
+++ b/lib/node_modules/@stdlib/constants/uint8/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains constants', function test( t ) {
 	var keys = objectKeys( constants );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/unicode/max-bmp/test/test.js b/lib/node_modules/@stdlib/constants/unicode/max-bmp/test/test.js
index 2295eb3ca2cf..944fe3e73165 100644
--- a/lib/node_modules/@stdlib/constants/unicode/max-bmp/test/test.js
+++ b/lib/node_modules/@stdlib/constants/unicode/max-bmp/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 65535', function test( t ) {
-	t.equal( UNICODE_MAX_BMP, 65535, 'equals 65535' );
+	t.strictEqual( UNICODE_MAX_BMP, 65535, 'equals 65535' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/constants/unicode/max/test/test.js b/lib/node_modules/@stdlib/constants/unicode/max/test/test.js
index 6ca08a2225b8..9ea5865fb6f9 100644
--- a/lib/node_modules/@stdlib/constants/unicode/max/test/test.js
+++ b/lib/node_modules/@stdlib/constants/unicode/max/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is 1114111', function test( t ) {
-	t.equal( UNICODE_MAX, 1114111, 'equals 1114111' );
+	t.strictEqual( UNICODE_MAX, 1114111, 'equals 1114111' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/acronym/test/test.validate.js b/lib/node_modules/@stdlib/string/acronym/test/test.validate.js
index d03f7a284f11..ac48a5b14339 100644
--- a/lib/node_modules/@stdlib/string/acronym/test/test.validate.js
+++ b/lib/node_modules/@stdlib/string/acronym/test/test.validate.js
@@ -93,8 +93,8 @@ tape( 'if all options are valid, the function returns null', function test( t )
 	};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( opts.stopwords, options.stopwords, 'sets the `stopwords` option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( opts.stopwords, options.stopwords, 'sets the `stopwords` option' );
 
 	t.end();
 });
@@ -105,6 +105,6 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 		'a': null,
 		'b': 5
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/atob/test/test.js b/lib/node_modules/@stdlib/string/base/atob/test/test.js
index 999fad36b8cf..c75c3d4a7647 100644
--- a/lib/node_modules/@stdlib/string/base/atob/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/atob/test/test.js
@@ -39,7 +39,7 @@ tape( 'the main export is a polyfill if an environment does not support `atob`',
 	var atob = proxyquire( './../lib', {
 		'@stdlib/assert/has-atob-support': detect
 	});
-	t.equal( atob, polyfill, 'returns expected value' );
+	t.strictEqual( atob, polyfill, 'returns expected value' );
 	t.end();
 
 	function detect() {
@@ -51,7 +51,7 @@ tape( 'the main export is a wrapper around a builtin if an environment supports
 	var atob = proxyquire( './../lib', {
 		'@stdlib/assert/has-atob-support': detect
 	});
-	t.equal( atob, main, 'returns expected value' );
+	t.strictEqual( atob, main, 'returns expected value' );
 	t.end();
 
 	function detect() {
diff --git a/lib/node_modules/@stdlib/string/base/capitalize/test/test.js b/lib/node_modules/@stdlib/string/base/capitalize/test/test.js
index cc192563bd4b..0ce0588be8e9 100644
--- a/lib/node_modules/@stdlib/string/base/capitalize/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/capitalize/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an empty string if provided an empty string', function test( t ) {
-	t.equal( capitalize( '' ), '', 'returns empty string' );
+	t.strictEqual( capitalize( '' ), '', 'returns empty string' );
 	t.end();
 });
 
@@ -41,13 +41,13 @@ tape( 'the function capitalizes the first character in a provided string', funct
 	var out;
 
 	out = capitalize( 'hello world' );
-	t.equal( out, 'Hello world', 'capitalizes first character' );
+	t.strictEqual( out, 'Hello world', 'capitalizes first character' );
 
 	out = capitalize( '!!!' );
-	t.equal( out, '!!!', 'does not change non-alphabetical characters' );
+	t.strictEqual( out, '!!!', 'does not change non-alphabetical characters' );
 
 	out = capitalize( 'Hello World' );
-	t.equal( out, 'Hello World', 'leaves uppercase letters in uppercase' );
+	t.strictEqual( out, 'Hello World', 'leaves uppercase letters in uppercase' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/distances/test/test.js b/lib/node_modules/@stdlib/string/base/distances/test/test.js
index d1059bd42280..3849d6be4a45 100644
--- a/lib/node_modules/@stdlib/string/base/distances/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/distances/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains various implementations of string similarity metrics', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/ends-with/test/test.js b/lib/node_modules/@stdlib/string/base/ends-with/test/test.js
index 4542e5020e31..09e009e8d438 100644
--- a/lib/node_modules/@stdlib/string/base/ends-with/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/ends-with/test/test.js
@@ -39,7 +39,7 @@ tape( 'the main export is a polyfill if an environment does not support String.p
 	var endsWith = proxyquire( './../lib', {
 		'./has_builtin.js': false
 	});
-	t.equal( endsWith, polyfill, 'returns expected value' );
+	t.strictEqual( endsWith, polyfill, 'returns expected value' );
 	t.end();
 });
 
@@ -47,7 +47,7 @@ tape( 'the main export is a wrapper around a builtin if an environment supports
 	var endsWith = proxyquire( './../lib', {
 		'./has_builtin.js': true
 	});
-	t.equal( endsWith, main, 'returns expected value' );
+	t.strictEqual( endsWith, main, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/string/base/left-pad/test/test.js b/lib/node_modules/@stdlib/string/base/left-pad/test/test.js
index 063af406f169..99b3e0f5d0fa 100644
--- a/lib/node_modules/@stdlib/string/base/left-pad/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/left-pad/test/test.js
@@ -34,24 +34,24 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function left pads a string with spaces', function test( t ) {
 	var str = lpad( 'a', 5, ' ' );
-	t.equal( str, '    a', 'left padded with spaces' );
+	t.strictEqual( str, '    a', 'left padded with spaces' );
 	t.end();
 });
 
 tape( 'the function supports left padding a string with a custom pad string', function test( t ) {
 	var str = lpad( 'beep', 10, 'b' );
-	t.equal( str, 'bbbbbbbeep', 'left padded to desired length' );
+	t.strictEqual( str, 'bbbbbbbeep', 'left padded to desired length' );
 	t.end();
 });
 
 tape( 'the function left pads a string such that an output string may exceed the specified length (minimum bound)', function test( t ) {
 	var str = lpad( 'a', 5, 'beepboop' );
-	t.equal( str, 'beepboopa', 'left padded and length exceeds minimum length' );
+	t.strictEqual( str, 'beepboopa', 'left padded and length exceeds minimum length' );
 	t.end();
 });
 
 tape( 'if the specified string length is less than or equal to the input string length, the function returns the input string', function test( t ) {
-	t.equal( lpad( 'boop', 2, 'beep' ), 'boop', 'returns input string (<)' );
-	t.equal( lpad( 'boop', 4, 'beep' ), 'boop', 'returns input string (=)' );
+	t.strictEqual( lpad( 'boop', 2, 'beep' ), 'boop', 'returns input string (<)' );
+	t.strictEqual( lpad( 'boop', 4, 'beep' ), 'boop', 'returns input string (=)' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/left-trim/test/test.js b/lib/node_modules/@stdlib/string/base/left-trim/test/test.js
index ed0bceca428e..dbcc8095a5b8 100644
--- a/lib/node_modules/@stdlib/string/base/left-trim/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/left-trim/test/test.js
@@ -39,7 +39,7 @@ tape( 'the main export is a polyfill if an environment does not support String.p
 	var ltrim = proxyquire( './../lib', {
 		'./has_builtin.js': false
 	});
-	t.equal( ltrim, polyfill, 'returns expected value' );
+	t.strictEqual( ltrim, polyfill, 'returns expected value' );
 	t.end();
 });
 
@@ -47,7 +47,7 @@ tape( 'the main export is a wrapper around a builtin if an environment supports
 	var ltrim = proxyquire( './../lib', {
 		'./has_builtin.js': true
 	});
-	t.equal( ltrim, main, 'returns expected value' );
+	t.strictEqual( ltrim, main, 'returns expected value' );
 	t.end();
 });
 
@@ -57,111 +57,111 @@ tape( 'the function removes all whitespace characters at the beginning of a stri
 
 	expected = 'Whitespace   ';
 	actual = ltrim( '   Whitespace   ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'Tabs\t\t\t';
 	actual = ltrim( '\t\t\tTabs\t\t\t' );
-	t.equal( actual, expected, 'removes all tabs' );
+	t.strictEqual( actual, expected, 'removes all tabs' );
 
 	expected = 'New Lines\n\n\n';
 	actual = ltrim( '\n\n\nNew Lines\n\n\n' );
-	t.equal( actual, expected, 'removes all newline characters' );
+	t.strictEqual( actual, expected, 'removes all newline characters' );
 
 	expected = 'New Lines\r\n\r\n\r\n';
 	actual = ltrim( '\r\n\r\n\r\nNew Lines\r\n\r\n\r\n' );
-	t.equal( actual, expected, 'removes all newline and carriage return characters' );
+	t.strictEqual( actual, expected, 'removes all newline and carriage return characters' );
 
 	expected = 'Beep \r\n \t';
 	actual = ltrim( ' \t\r\n Beep \r\n \t' );
-	t.equal( actual, expected, 'removes all whitespace characters' );
+	t.strictEqual( actual, expected, 'removes all whitespace characters' );
 
 	expected = 'beep';
 	actual = ltrim( '\fbeep' );
-	t.equal( actual, expected, 'removes \\f' );
+	t.strictEqual( actual, expected, 'removes \\f' );
 
 	expected = 'beep';
 	actual = ltrim( '\nbeep' );
-	t.equal( actual, expected, 'removes \\n' );
+	t.strictEqual( actual, expected, 'removes \\n' );
 
 	expected = 'beep';
 	actual = ltrim( '\tbeep' );
-	t.equal( actual, expected, 'removes \\t' );
+	t.strictEqual( actual, expected, 'removes \\t' );
 
 	expected = 'beep';
 	actual = ltrim( '\vbeep' );
-	t.equal( actual, expected, 'removes \\v' );
+	t.strictEqual( actual, expected, 'removes \\v' );
 
 	expected = 'beep';
 	actual = ltrim( '\u1680beep' );
-	t.equal( actual, expected, 'removes \\u1680' );
+	t.strictEqual( actual, expected, 'removes \\u1680' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2000beep' );
-	t.equal( actual, expected, 'removes \\u2000' );
+	t.strictEqual( actual, expected, 'removes \\u2000' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2001beep' );
-	t.equal( actual, expected, 'removes \\u2001' );
+	t.strictEqual( actual, expected, 'removes \\u2001' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2002beep' );
-	t.equal( actual, expected, 'removes \\u2002' );
+	t.strictEqual( actual, expected, 'removes \\u2002' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2003beep' );
-	t.equal( actual, expected, 'removes \\u2003' );
+	t.strictEqual( actual, expected, 'removes \\u2003' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2004beep' );
-	t.equal( actual, expected, 'removes \\u2004' );
+	t.strictEqual( actual, expected, 'removes \\u2004' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2005beep' );
-	t.equal( actual, expected, 'removes \\u2005' );
+	t.strictEqual( actual, expected, 'removes \\u2005' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2006beep' );
-	t.equal( actual, expected, 'removes \\u2006' );
+	t.strictEqual( actual, expected, 'removes \\u2006' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2007beep' );
-	t.equal( actual, expected, 'removes \\u2007' );
+	t.strictEqual( actual, expected, 'removes \\u2007' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2008beep' );
-	t.equal( actual, expected, 'removes \\u2008' );
+	t.strictEqual( actual, expected, 'removes \\u2008' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2009beep' );
-	t.equal( actual, expected, 'removes \\u2009' );
+	t.strictEqual( actual, expected, 'removes \\u2009' );
 
 	expected = 'beep';
 	actual = ltrim( '\u200abeep' );
-	t.equal( actual, expected, 'removes \\u200a' );
+	t.strictEqual( actual, expected, 'removes \\u200a' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2028beep' );
-	t.equal( actual, expected, 'removes \\u2028' );
+	t.strictEqual( actual, expected, 'removes \\u2028' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2029beep' );
-	t.equal( actual, expected, 'removes \\u2029' );
+	t.strictEqual( actual, expected, 'removes \\u2029' );
 
 	expected = 'beep';
 	actual = ltrim( '\u202fbeep' );
-	t.equal( actual, expected, 'removes \\u202f' );
+	t.strictEqual( actual, expected, 'removes \\u202f' );
 
 	expected = 'beep';
 	actual = ltrim( '\u205fbeep' );
-	t.equal( actual, expected, 'removes \\u205f' );
+	t.strictEqual( actual, expected, 'removes \\u205f' );
 
 	expected = 'beep';
 	actual = ltrim( '\u3000beep' );
-	t.equal( actual, expected, 'removes \\u3000' );
+	t.strictEqual( actual, expected, 'removes \\u3000' );
 
 	expected = 'beep';
 	actual = ltrim( '\ufeffbeep' );
-	t.equal( actual, expected, 'removes \\ufefff' );
+	t.strictEqual( actual, expected, 'removes \\ufefff' );
 
 	t.end();
 });
@@ -172,7 +172,7 @@ tape( 'the function does not remove the Mongolian space separator in accordance
 
 	expected = '\u180ebeep';
 	actual = ltrim( '\u180ebeep' );
-	t.equal( actual, expected, 'does not remove \\u180e' );
+	t.strictEqual( actual, expected, 'does not remove \\u180e' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/left-trim/test/test.main.js b/lib/node_modules/@stdlib/string/base/left-trim/test/test.main.js
index 2eb462751fbe..2873695fb503 100644
--- a/lib/node_modules/@stdlib/string/base/left-trim/test/test.main.js
+++ b/lib/node_modules/@stdlib/string/base/left-trim/test/test.main.js
@@ -46,111 +46,111 @@ tape( 'the function removes all whitespace characters at the beginning of a stri
 
 	expected = 'Whitespace   ';
 	actual = ltrim( '   Whitespace   ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'Tabs\t\t\t';
 	actual = ltrim( '\t\t\tTabs\t\t\t' );
-	t.equal( actual, expected, 'removes all tabs' );
+	t.strictEqual( actual, expected, 'removes all tabs' );
 
 	expected = 'New Lines\n\n\n';
 	actual = ltrim( '\n\n\nNew Lines\n\n\n' );
-	t.equal( actual, expected, 'removes all newline characters' );
+	t.strictEqual( actual, expected, 'removes all newline characters' );
 
 	expected = 'New Lines\r\n\r\n\r\n';
 	actual = ltrim( '\r\n\r\n\r\nNew Lines\r\n\r\n\r\n' );
-	t.equal( actual, expected, 'removes all newline and carriage return characters' );
+	t.strictEqual( actual, expected, 'removes all newline and carriage return characters' );
 
 	expected = 'Beep \r\n \t';
 	actual = ltrim( ' \t\r\n Beep \r\n \t' );
-	t.equal( actual, expected, 'removes all whitespace characters' );
+	t.strictEqual( actual, expected, 'removes all whitespace characters' );
 
 	expected = 'beep';
 	actual = ltrim( '\fbeep' );
-	t.equal( actual, expected, 'removes \\f' );
+	t.strictEqual( actual, expected, 'removes \\f' );
 
 	expected = 'beep';
 	actual = ltrim( '\nbeep' );
-	t.equal( actual, expected, 'removes \\n' );
+	t.strictEqual( actual, expected, 'removes \\n' );
 
 	expected = 'beep';
 	actual = ltrim( '\tbeep' );
-	t.equal( actual, expected, 'removes \\t' );
+	t.strictEqual( actual, expected, 'removes \\t' );
 
 	expected = 'beep';
 	actual = ltrim( '\vbeep' );
-	t.equal( actual, expected, 'removes \\v' );
+	t.strictEqual( actual, expected, 'removes \\v' );
 
 	expected = 'beep';
 	actual = ltrim( '\u1680beep' );
-	t.equal( actual, expected, 'removes \\u1680' );
+	t.strictEqual( actual, expected, 'removes \\u1680' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2000beep' );
-	t.equal( actual, expected, 'removes \\u2000' );
+	t.strictEqual( actual, expected, 'removes \\u2000' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2001beep' );
-	t.equal( actual, expected, 'removes \\u2001' );
+	t.strictEqual( actual, expected, 'removes \\u2001' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2002beep' );
-	t.equal( actual, expected, 'removes \\u2002' );
+	t.strictEqual( actual, expected, 'removes \\u2002' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2003beep' );
-	t.equal( actual, expected, 'removes \\u2003' );
+	t.strictEqual( actual, expected, 'removes \\u2003' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2004beep' );
-	t.equal( actual, expected, 'removes \\u2004' );
+	t.strictEqual( actual, expected, 'removes \\u2004' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2005beep' );
-	t.equal( actual, expected, 'removes \\u2005' );
+	t.strictEqual( actual, expected, 'removes \\u2005' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2006beep' );
-	t.equal( actual, expected, 'removes \\u2006' );
+	t.strictEqual( actual, expected, 'removes \\u2006' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2007beep' );
-	t.equal( actual, expected, 'removes \\u2007' );
+	t.strictEqual( actual, expected, 'removes \\u2007' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2008beep' );
-	t.equal( actual, expected, 'removes \\u2008' );
+	t.strictEqual( actual, expected, 'removes \\u2008' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2009beep' );
-	t.equal( actual, expected, 'removes \\u2009' );
+	t.strictEqual( actual, expected, 'removes \\u2009' );
 
 	expected = 'beep';
 	actual = ltrim( '\u200abeep' );
-	t.equal( actual, expected, 'removes \\u200a' );
+	t.strictEqual( actual, expected, 'removes \\u200a' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2028beep' );
-	t.equal( actual, expected, 'removes \\u2028' );
+	t.strictEqual( actual, expected, 'removes \\u2028' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2029beep' );
-	t.equal( actual, expected, 'removes \\u2029' );
+	t.strictEqual( actual, expected, 'removes \\u2029' );
 
 	expected = 'beep';
 	actual = ltrim( '\u202fbeep' );
-	t.equal( actual, expected, 'removes \\u202f' );
+	t.strictEqual( actual, expected, 'removes \\u202f' );
 
 	expected = 'beep';
 	actual = ltrim( '\u205fbeep' );
-	t.equal( actual, expected, 'removes \\u205f' );
+	t.strictEqual( actual, expected, 'removes \\u205f' );
 
 	expected = 'beep';
 	actual = ltrim( '\u3000beep' );
-	t.equal( actual, expected, 'removes \\u3000' );
+	t.strictEqual( actual, expected, 'removes \\u3000' );
 
 	expected = 'beep';
 	actual = ltrim( '\ufeffbeep' );
-	t.equal( actual, expected, 'removes \\ufefff' );
+	t.strictEqual( actual, expected, 'removes \\ufefff' );
 
 	t.end();
 });
@@ -161,7 +161,7 @@ tape( 'the function does not remove the Mongolian space separator in accordance
 
 	expected = '\u180ebeep';
 	actual = ltrim( '\u180ebeep' );
-	t.equal( actual, expected, 'does not remove \\u180e' );
+	t.strictEqual( actual, expected, 'does not remove \\u180e' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/left-trim/test/test.polyfill.js b/lib/node_modules/@stdlib/string/base/left-trim/test/test.polyfill.js
index 4d70e6f2209e..cc1f93c48d83 100644
--- a/lib/node_modules/@stdlib/string/base/left-trim/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/string/base/left-trim/test/test.polyfill.js
@@ -38,111 +38,111 @@ tape( 'the function removes all whitespace characters at the beginning of a stri
 
 	expected = 'Whitespace   ';
 	actual = ltrim( '   Whitespace   ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'Tabs\t\t\t';
 	actual = ltrim( '\t\t\tTabs\t\t\t' );
-	t.equal( actual, expected, 'removes all tabs' );
+	t.strictEqual( actual, expected, 'removes all tabs' );
 
 	expected = 'New Lines\n\n\n';
 	actual = ltrim( '\n\n\nNew Lines\n\n\n' );
-	t.equal( actual, expected, 'removes all newline characters' );
+	t.strictEqual( actual, expected, 'removes all newline characters' );
 
 	expected = 'New Lines\r\n\r\n\r\n';
 	actual = ltrim( '\r\n\r\n\r\nNew Lines\r\n\r\n\r\n' );
-	t.equal( actual, expected, 'removes all newline and carriage return characters' );
+	t.strictEqual( actual, expected, 'removes all newline and carriage return characters' );
 
 	expected = 'Beep \r\n \t';
 	actual = ltrim( ' \t\r\n Beep \r\n \t' );
-	t.equal( actual, expected, 'removes all whitespace characters' );
+	t.strictEqual( actual, expected, 'removes all whitespace characters' );
 
 	expected = 'beep';
 	actual = ltrim( '\fbeep' );
-	t.equal( actual, expected, 'removes \\f' );
+	t.strictEqual( actual, expected, 'removes \\f' );
 
 	expected = 'beep';
 	actual = ltrim( '\nbeep' );
-	t.equal( actual, expected, 'removes \\n' );
+	t.strictEqual( actual, expected, 'removes \\n' );
 
 	expected = 'beep';
 	actual = ltrim( '\tbeep' );
-	t.equal( actual, expected, 'removes \\t' );
+	t.strictEqual( actual, expected, 'removes \\t' );
 
 	expected = 'beep';
 	actual = ltrim( '\vbeep' );
-	t.equal( actual, expected, 'removes \\v' );
+	t.strictEqual( actual, expected, 'removes \\v' );
 
 	expected = 'beep';
 	actual = ltrim( '\u1680beep' );
-	t.equal( actual, expected, 'removes \\u1680' );
+	t.strictEqual( actual, expected, 'removes \\u1680' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2000beep' );
-	t.equal( actual, expected, 'removes \\u2000' );
+	t.strictEqual( actual, expected, 'removes \\u2000' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2001beep' );
-	t.equal( actual, expected, 'removes \\u2001' );
+	t.strictEqual( actual, expected, 'removes \\u2001' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2002beep' );
-	t.equal( actual, expected, 'removes \\u2002' );
+	t.strictEqual( actual, expected, 'removes \\u2002' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2003beep' );
-	t.equal( actual, expected, 'removes \\u2003' );
+	t.strictEqual( actual, expected, 'removes \\u2003' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2004beep' );
-	t.equal( actual, expected, 'removes \\u2004' );
+	t.strictEqual( actual, expected, 'removes \\u2004' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2005beep' );
-	t.equal( actual, expected, 'removes \\u2005' );
+	t.strictEqual( actual, expected, 'removes \\u2005' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2006beep' );
-	t.equal( actual, expected, 'removes \\u2006' );
+	t.strictEqual( actual, expected, 'removes \\u2006' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2007beep' );
-	t.equal( actual, expected, 'removes \\u2007' );
+	t.strictEqual( actual, expected, 'removes \\u2007' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2008beep' );
-	t.equal( actual, expected, 'removes \\u2008' );
+	t.strictEqual( actual, expected, 'removes \\u2008' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2009beep' );
-	t.equal( actual, expected, 'removes \\u2009' );
+	t.strictEqual( actual, expected, 'removes \\u2009' );
 
 	expected = 'beep';
 	actual = ltrim( '\u200abeep' );
-	t.equal( actual, expected, 'removes \\u200a' );
+	t.strictEqual( actual, expected, 'removes \\u200a' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2028beep' );
-	t.equal( actual, expected, 'removes \\u2028' );
+	t.strictEqual( actual, expected, 'removes \\u2028' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2029beep' );
-	t.equal( actual, expected, 'removes \\u2029' );
+	t.strictEqual( actual, expected, 'removes \\u2029' );
 
 	expected = 'beep';
 	actual = ltrim( '\u202fbeep' );
-	t.equal( actual, expected, 'removes \\u202f' );
+	t.strictEqual( actual, expected, 'removes \\u202f' );
 
 	expected = 'beep';
 	actual = ltrim( '\u205fbeep' );
-	t.equal( actual, expected, 'removes \\u205f' );
+	t.strictEqual( actual, expected, 'removes \\u205f' );
 
 	expected = 'beep';
 	actual = ltrim( '\u3000beep' );
-	t.equal( actual, expected, 'removes \\u3000' );
+	t.strictEqual( actual, expected, 'removes \\u3000' );
 
 	expected = 'beep';
 	actual = ltrim( '\ufeffbeep' );
-	t.equal( actual, expected, 'removes \\ufefff' );
+	t.strictEqual( actual, expected, 'removes \\ufefff' );
 
 	t.end();
 });
@@ -153,7 +153,7 @@ tape( 'the function does not remove the Mongolian space separator in accordance
 
 	expected = '\u180ebeep';
 	actual = ltrim( '\u180ebeep' );
-	t.equal( actual, expected, 'does not remove \\u180e' );
+	t.strictEqual( actual, expected, 'does not remove \\u180e' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/lowercase/test/test.js b/lib/node_modules/@stdlib/string/base/lowercase/test/test.js
index 9dd37c6350a5..67b43a2c9399 100644
--- a/lib/node_modules/@stdlib/string/base/lowercase/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/lowercase/test/test.js
@@ -56,7 +56,7 @@ tape( 'the function converts a string to lowercase', function test( t ) {
 	];
 	for ( i = 0; i < values.length; i++ ) {
 		actual = lowercase( values[i] );
-		t.equal( actual, expected[i], 'converts string to '+expected[i] );
+		t.strictEqual( actual, expected[i], 'converts string to '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/repeat/test/test.js b/lib/node_modules/@stdlib/string/base/repeat/test/test.js
index f3b7739c63ae..daa447c35b9f 100644
--- a/lib/node_modules/@stdlib/string/base/repeat/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/repeat/test/test.js
@@ -39,7 +39,7 @@ tape( 'the main export is a polyfill if an environment does not support String.p
 	var repeat = proxyquire( './../lib', {
 		'./has_builtin.js': false
 	});
-	t.equal( repeat, polyfill, 'returns expected value' );
+	t.strictEqual( repeat, polyfill, 'returns expected value' );
 	t.end();
 });
 
@@ -47,7 +47,7 @@ tape( 'the main export is a wrapper around a builtin if an environment supports
 	var repeat = proxyquire( './../lib', {
 		'./has_builtin.js': true
 	});
-	t.equal( repeat, main, 'returns expected value' );
+	t.strictEqual( repeat, main, 'returns expected value' );
 	t.end();
 });
 
@@ -55,20 +55,20 @@ tape( 'the function repeats an input string a specified number of times', functi
 	var str;
 
 	str = repeat( 'a', 5 );
-	t.equal( str, 'aaaaa', 'repeated 5 times' );
+	t.strictEqual( str, 'aaaaa', 'repeated 5 times' );
 
 	str = repeat( 'beep', 2 );
-	t.equal( str, 'beepbeep', 'repeated 2 times' );
+	t.strictEqual( str, 'beepbeep', 'repeated 2 times' );
 
 	t.end();
 });
 
 tape( 'if provided an empty string, the function returns an empty string', function test( t ) {
-	t.equal( repeat( '', 100 ), '', 'returns an empty string' );
+	t.strictEqual( repeat( '', 100 ), '', 'returns an empty string' );
 	t.end();
 });
 
 tape( 'if repeat number is 0, the function returns an empty string', function test( t ) {
-	t.equal( repeat( 'a', 0 ), '', 'returns empty string' );
+	t.strictEqual( repeat( 'a', 0 ), '', 'returns empty string' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/repeat/test/test.main.js b/lib/node_modules/@stdlib/string/base/repeat/test/test.main.js
index 49e784158c61..f18c39ad214a 100644
--- a/lib/node_modules/@stdlib/string/base/repeat/test/test.main.js
+++ b/lib/node_modules/@stdlib/string/base/repeat/test/test.main.js
@@ -44,20 +44,20 @@ tape( 'the function repeats an input string a specified number of times', opts,
 	var str;
 
 	str = repeat( 'a', 5 );
-	t.equal( str, 'aaaaa', 'repeated 5 times' );
+	t.strictEqual( str, 'aaaaa', 'repeated 5 times' );
 
 	str = repeat( 'beep', 2 );
-	t.equal( str, 'beepbeep', 'repeated 2 times' );
+	t.strictEqual( str, 'beepbeep', 'repeated 2 times' );
 
 	t.end();
 });
 
 tape( 'if provided an empty string, the function returns an empty string', opts, function test( t ) {
-	t.equal( repeat( '', 100 ), '', 'returns an empty string' );
+	t.strictEqual( repeat( '', 100 ), '', 'returns an empty string' );
 	t.end();
 });
 
 tape( 'if repeat number is 0, the function returns an empty string', opts, function test( t ) {
-	t.equal( repeat( 'a', 0 ), '', 'returns empty string' );
+	t.strictEqual( repeat( 'a', 0 ), '', 'returns empty string' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/repeat/test/test.polyfill.js b/lib/node_modules/@stdlib/string/base/repeat/test/test.polyfill.js
index 081d4092d3e4..6bb09281fd5f 100644
--- a/lib/node_modules/@stdlib/string/base/repeat/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/string/base/repeat/test/test.polyfill.js
@@ -36,20 +36,20 @@ tape( 'the function repeats an input string a specified number of times', functi
 	var str;
 
 	str = repeat( 'a', 5 );
-	t.equal( str, 'aaaaa', 'repeated 5 times' );
+	t.strictEqual( str, 'aaaaa', 'repeated 5 times' );
 
 	str = repeat( 'beep', 2 );
-	t.equal( str, 'beepbeep', 'repeated 2 times' );
+	t.strictEqual( str, 'beepbeep', 'repeated 2 times' );
 
 	t.end();
 });
 
 tape( 'if provided an empty string, the function returns an empty string', function test( t ) {
-	t.equal( repeat( '', 100 ), '', 'returns an empty string' );
+	t.strictEqual( repeat( '', 100 ), '', 'returns an empty string' );
 	t.end();
 });
 
 tape( 'if repeat number is 0, the function returns an empty string', function test( t ) {
-	t.equal( repeat( 'a', 0 ), '', 'returns empty string' );
+	t.strictEqual( repeat( 'a', 0 ), '', 'returns empty string' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/replace/test/test.js b/lib/node_modules/@stdlib/string/base/replace/test/test.js
index a95d0eacc5b3..55a277972740 100644
--- a/lib/node_modules/@stdlib/string/base/replace/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/replace/test/test.js
@@ -38,11 +38,11 @@ tape( 'the function replaces matches of a regular expression', function test( t
 
 	out = replace( 'aBcDeFgHiJkLmNoPqRsTuVwXYZ', /[A-Z]+/, '' );
 	expected = 'acDeFgHiJkLmNoPqRsTuVwXYZ';
-	t.equal( out, expected, 'replaces letters matching the regular expression (first occurrence)' );
+	t.strictEqual( out, expected, 'replaces letters matching the regular expression (first occurrence)' );
 
 	out = replace( 'aBcDeFgHiJkLmNoPqRsTuVwXYZ', /[A-Z]+/g, '' );
 	expected = 'acegikmoqsuw';
-	t.equal( out, expected, 'replaces letters matching the regular expression (global)' );
+	t.strictEqual( out, expected, 'replaces letters matching the regular expression (global)' );
 
 	t.end();
 });
@@ -56,7 +56,7 @@ tape( 'the function replaces matches with values returned by a replacer function
 	out = replace( str, /([^\s]+)/gi, replacer );
 
 	expected = '/Oranges/ /and/ /lemons/ /say/ /the/ /bells/ /of/ /St./ /Clement\'s/';
-	t.equal( out, expected, 'replaces matches using replacer function' );
+	t.strictEqual( out, expected, 'replaces matches using replacer function' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/string/base/right-pad/test/test.js b/lib/node_modules/@stdlib/string/base/right-pad/test/test.js
index 4f009681ea73..f7321fc9b505 100644
--- a/lib/node_modules/@stdlib/string/base/right-pad/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/right-pad/test/test.js
@@ -34,24 +34,24 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function right pads a string with spaces', function test( t ) {
 	var str = rpad( 'a', 5, ' ' );
-	t.equal( str, 'a    ', 'right padded with spaces' );
+	t.strictEqual( str, 'a    ', 'right padded with spaces' );
 	t.end();
 });
 
 tape( 'the function supports right padding a string with a custom pad string', function test( t ) {
 	var str = rpad( 'beep', 10, 'b' );
-	t.equal( str, 'beepbbbbbb', 'right padded to desired length' );
+	t.strictEqual( str, 'beepbbbbbb', 'right padded to desired length' );
 	t.end();
 });
 
 tape( 'the function right pads a string such that an output string may exceed the specified length (minimum bound)', function test( t ) {
 	var str = rpad( 'a', 5, 'beepboop' );
-	t.equal( str, 'abeepboop', 'right padded and length exceeds minimum length' );
+	t.strictEqual( str, 'abeepboop', 'right padded and length exceeds minimum length' );
 	t.end();
 });
 
 tape( 'if the specified string length is less than or equal to the input string length, the function returns the input string', function test( t ) {
-	t.equal( rpad( 'boop', 2, 'beep' ), 'boop', 'returns input string (<)' );
-	t.equal( rpad( 'boop', 4, 'beep' ), 'boop', 'returns input string (=)' );
+	t.strictEqual( rpad( 'boop', 2, 'beep' ), 'boop', 'returns input string (<)' );
+	t.strictEqual( rpad( 'boop', 4, 'beep' ), 'boop', 'returns input string (=)' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/right-trim/test/test.js b/lib/node_modules/@stdlib/string/base/right-trim/test/test.js
index e99169e7dfaa..712d133577cd 100644
--- a/lib/node_modules/@stdlib/string/base/right-trim/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/right-trim/test/test.js
@@ -39,7 +39,7 @@ tape( 'the main export is a polyfill if an environment does not support String.p
 	var rtrim = proxyquire( './../lib', {
 		'./has_builtin.js': false
 	});
-	t.equal( rtrim, polyfill, 'returns expected value' );
+	t.strictEqual( rtrim, polyfill, 'returns expected value' );
 	t.end();
 });
 
@@ -47,7 +47,7 @@ tape( 'the main export is a wrapper around a builtin if an environment supports
 	var rtrim = proxyquire( './../lib', {
 		'./has_builtin.js': true
 	});
-	t.equal( rtrim, main, 'returns expected value' );
+	t.strictEqual( rtrim, main, 'returns expected value' );
 	t.end();
 });
 
@@ -57,107 +57,107 @@ tape( 'the function removes all whitespace characters at the end of a string', f
 
 	expected = '   Whitespace';
 	actual = rtrim( '   Whitespace   ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = '\t\t\tTabs';
 	actual = rtrim( '\t\t\tTabs\t\t\t' );
-	t.equal( actual, expected, 'removes all tabs' );
+	t.strictEqual( actual, expected, 'removes all tabs' );
 
 	expected = '\n\n\nNew Lines';
 	actual = rtrim( '\n\n\nNew Lines\n\n\n' );
-	t.equal( actual, expected, 'removes all newline characters' );
+	t.strictEqual( actual, expected, 'removes all newline characters' );
 
 	expected = ' \r\n \tBeep';
 	actual = rtrim( ' \r\n \tBeep \r\n\t' );
-	t.equal( actual, expected, 'removes all whitespace characters' );
+	t.strictEqual( actual, expected, 'removes all whitespace characters' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\f' );
-	t.equal( actual, expected, 'removes \\f' );
+	t.strictEqual( actual, expected, 'removes \\f' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\n' );
-	t.equal( actual, expected, 'removes \\n' );
+	t.strictEqual( actual, expected, 'removes \\n' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\t' );
-	t.equal( actual, expected, 'removes \\t' );
+	t.strictEqual( actual, expected, 'removes \\t' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\v' );
-	t.equal( actual, expected, 'removes \\v' );
+	t.strictEqual( actual, expected, 'removes \\v' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u1680' );
-	t.equal( actual, expected, 'removes \\u1680' );
+	t.strictEqual( actual, expected, 'removes \\u1680' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2000' );
-	t.equal( actual, expected, 'removes \\u2000' );
+	t.strictEqual( actual, expected, 'removes \\u2000' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2001' );
-	t.equal( actual, expected, 'removes \\u2001' );
+	t.strictEqual( actual, expected, 'removes \\u2001' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2002' );
-	t.equal( actual, expected, 'removes \\u2002' );
+	t.strictEqual( actual, expected, 'removes \\u2002' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2003' );
-	t.equal( actual, expected, 'removes \\u2003' );
+	t.strictEqual( actual, expected, 'removes \\u2003' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2004' );
-	t.equal( actual, expected, 'removes \\u2004' );
+	t.strictEqual( actual, expected, 'removes \\u2004' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2005' );
-	t.equal( actual, expected, 'removes \\u2005' );
+	t.strictEqual( actual, expected, 'removes \\u2005' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2006' );
-	t.equal( actual, expected, 'removes \\u2006' );
+	t.strictEqual( actual, expected, 'removes \\u2006' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2007' );
-	t.equal( actual, expected, 'removes \\u2007' );
+	t.strictEqual( actual, expected, 'removes \\u2007' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2008' );
-	t.equal( actual, expected, 'removes \\u2008' );
+	t.strictEqual( actual, expected, 'removes \\u2008' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2009' );
-	t.equal( actual, expected, 'removes \\u2009' );
+	t.strictEqual( actual, expected, 'removes \\u2009' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u200a' );
-	t.equal( actual, expected, 'removes \\u200a' );
+	t.strictEqual( actual, expected, 'removes \\u200a' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2028' );
-	t.equal( actual, expected, 'removes \\u2028' );
+	t.strictEqual( actual, expected, 'removes \\u2028' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2029' );
-	t.equal( actual, expected, 'removes \\u2029' );
+	t.strictEqual( actual, expected, 'removes \\u2029' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u202f' );
-	t.equal( actual, expected, 'removes \\u202f' );
+	t.strictEqual( actual, expected, 'removes \\u202f' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u205f' );
-	t.equal( actual, expected, 'removes \\u205f' );
+	t.strictEqual( actual, expected, 'removes \\u205f' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u3000' );
-	t.equal( actual, expected, 'removes \\u3000' );
+	t.strictEqual( actual, expected, 'removes \\u3000' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\ufeff' );
-	t.equal( actual, expected, 'removes \\ufefff' );
+	t.strictEqual( actual, expected, 'removes \\ufefff' );
 
 	t.end();
 });
@@ -168,7 +168,7 @@ tape( 'the function does not trim the Mongolian space separator in accordance wi
 
 	expected = 'beep\u180e';
 	actual = rtrim( 'beep\u180e' );
-	t.equal( actual, expected, 'does not remove \\u180e' );
+	t.strictEqual( actual, expected, 'does not remove \\u180e' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/right-trim/test/test.main.js b/lib/node_modules/@stdlib/string/base/right-trim/test/test.main.js
index 39b2e05ee70b..f667db032a9a 100644
--- a/lib/node_modules/@stdlib/string/base/right-trim/test/test.main.js
+++ b/lib/node_modules/@stdlib/string/base/right-trim/test/test.main.js
@@ -46,107 +46,107 @@ tape( 'the function removes all whitespace characters at the end of a string', o
 
 	expected = '   Whitespace';
 	actual = rtrim( '   Whitespace   ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = '\t\t\tTabs';
 	actual = rtrim( '\t\t\tTabs\t\t\t' );
-	t.equal( actual, expected, 'removes all tabs' );
+	t.strictEqual( actual, expected, 'removes all tabs' );
 
 	expected = '\n\n\nNew Lines';
 	actual = rtrim( '\n\n\nNew Lines\n\n\n' );
-	t.equal( actual, expected, 'removes all newline characters' );
+	t.strictEqual( actual, expected, 'removes all newline characters' );
 
 	expected = ' \r\n \tBeep';
 	actual = rtrim( ' \r\n \tBeep \r\n\t' );
-	t.equal( actual, expected, 'removes all whitespace characters' );
+	t.strictEqual( actual, expected, 'removes all whitespace characters' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\f' );
-	t.equal( actual, expected, 'removes \\f' );
+	t.strictEqual( actual, expected, 'removes \\f' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\n' );
-	t.equal( actual, expected, 'removes \\n' );
+	t.strictEqual( actual, expected, 'removes \\n' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\t' );
-	t.equal( actual, expected, 'removes \\t' );
+	t.strictEqual( actual, expected, 'removes \\t' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\v' );
-	t.equal( actual, expected, 'removes \\v' );
+	t.strictEqual( actual, expected, 'removes \\v' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u1680' );
-	t.equal( actual, expected, 'removes \\u1680' );
+	t.strictEqual( actual, expected, 'removes \\u1680' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2000' );
-	t.equal( actual, expected, 'removes \\u2000' );
+	t.strictEqual( actual, expected, 'removes \\u2000' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2001' );
-	t.equal( actual, expected, 'removes \\u2001' );
+	t.strictEqual( actual, expected, 'removes \\u2001' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2002' );
-	t.equal( actual, expected, 'removes \\u2002' );
+	t.strictEqual( actual, expected, 'removes \\u2002' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2003' );
-	t.equal( actual, expected, 'removes \\u2003' );
+	t.strictEqual( actual, expected, 'removes \\u2003' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2004' );
-	t.equal( actual, expected, 'removes \\u2004' );
+	t.strictEqual( actual, expected, 'removes \\u2004' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2005' );
-	t.equal( actual, expected, 'removes \\u2005' );
+	t.strictEqual( actual, expected, 'removes \\u2005' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2006' );
-	t.equal( actual, expected, 'removes \\u2006' );
+	t.strictEqual( actual, expected, 'removes \\u2006' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2007' );
-	t.equal( actual, expected, 'removes \\u2007' );
+	t.strictEqual( actual, expected, 'removes \\u2007' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2008' );
-	t.equal( actual, expected, 'removes \\u2008' );
+	t.strictEqual( actual, expected, 'removes \\u2008' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2009' );
-	t.equal( actual, expected, 'removes \\u2009' );
+	t.strictEqual( actual, expected, 'removes \\u2009' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u200a' );
-	t.equal( actual, expected, 'removes \\u200a' );
+	t.strictEqual( actual, expected, 'removes \\u200a' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2028' );
-	t.equal( actual, expected, 'removes \\u2028' );
+	t.strictEqual( actual, expected, 'removes \\u2028' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2029' );
-	t.equal( actual, expected, 'removes \\u2029' );
+	t.strictEqual( actual, expected, 'removes \\u2029' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u202f' );
-	t.equal( actual, expected, 'removes \\u202f' );
+	t.strictEqual( actual, expected, 'removes \\u202f' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u205f' );
-	t.equal( actual, expected, 'removes \\u205f' );
+	t.strictEqual( actual, expected, 'removes \\u205f' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u3000' );
-	t.equal( actual, expected, 'removes \\u3000' );
+	t.strictEqual( actual, expected, 'removes \\u3000' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\ufeff' );
-	t.equal( actual, expected, 'removes \\ufefff' );
+	t.strictEqual( actual, expected, 'removes \\ufefff' );
 
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'the function does not trim the Mongolian space separator in accordance wi
 
 	expected = 'beep\u180e';
 	actual = rtrim( 'beep\u180e' );
-	t.equal( actual, expected, 'does not remove \\u180e' );
+	t.strictEqual( actual, expected, 'does not remove \\u180e' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/right-trim/test/test.polyfill.js b/lib/node_modules/@stdlib/string/base/right-trim/test/test.polyfill.js
index aa991577cf8c..e842dd7da7d4 100644
--- a/lib/node_modules/@stdlib/string/base/right-trim/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/string/base/right-trim/test/test.polyfill.js
@@ -38,107 +38,107 @@ tape( 'the function removes all whitespace characters at the end of a string', f
 
 	expected = '   Whitespace';
 	actual = rtrim( '   Whitespace   ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = '\t\t\tTabs';
 	actual = rtrim( '\t\t\tTabs\t\t\t' );
-	t.equal( actual, expected, 'removes all tabs' );
+	t.strictEqual( actual, expected, 'removes all tabs' );
 
 	expected = '\n\n\nNew Lines';
 	actual = rtrim( '\n\n\nNew Lines\n\n\n' );
-	t.equal( actual, expected, 'removes all newline characters' );
+	t.strictEqual( actual, expected, 'removes all newline characters' );
 
 	expected = ' \r\n \tBeep';
 	actual = rtrim( ' \r\n \tBeep \r\n\t' );
-	t.equal( actual, expected, 'removes all whitespace characters' );
+	t.strictEqual( actual, expected, 'removes all whitespace characters' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\f' );
-	t.equal( actual, expected, 'removes \\f' );
+	t.strictEqual( actual, expected, 'removes \\f' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\n' );
-	t.equal( actual, expected, 'removes \\n' );
+	t.strictEqual( actual, expected, 'removes \\n' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\t' );
-	t.equal( actual, expected, 'removes \\t' );
+	t.strictEqual( actual, expected, 'removes \\t' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\v' );
-	t.equal( actual, expected, 'removes \\v' );
+	t.strictEqual( actual, expected, 'removes \\v' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u1680' );
-	t.equal( actual, expected, 'removes \\u1680' );
+	t.strictEqual( actual, expected, 'removes \\u1680' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2000' );
-	t.equal( actual, expected, 'removes \\u2000' );
+	t.strictEqual( actual, expected, 'removes \\u2000' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2001' );
-	t.equal( actual, expected, 'removes \\u2001' );
+	t.strictEqual( actual, expected, 'removes \\u2001' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2002' );
-	t.equal( actual, expected, 'removes \\u2002' );
+	t.strictEqual( actual, expected, 'removes \\u2002' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2003' );
-	t.equal( actual, expected, 'removes \\u2003' );
+	t.strictEqual( actual, expected, 'removes \\u2003' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2004' );
-	t.equal( actual, expected, 'removes \\u2004' );
+	t.strictEqual( actual, expected, 'removes \\u2004' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2005' );
-	t.equal( actual, expected, 'removes \\u2005' );
+	t.strictEqual( actual, expected, 'removes \\u2005' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2006' );
-	t.equal( actual, expected, 'removes \\u2006' );
+	t.strictEqual( actual, expected, 'removes \\u2006' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2007' );
-	t.equal( actual, expected, 'removes \\u2007' );
+	t.strictEqual( actual, expected, 'removes \\u2007' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2008' );
-	t.equal( actual, expected, 'removes \\u2008' );
+	t.strictEqual( actual, expected, 'removes \\u2008' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2009' );
-	t.equal( actual, expected, 'removes \\u2009' );
+	t.strictEqual( actual, expected, 'removes \\u2009' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u200a' );
-	t.equal( actual, expected, 'removes \\u200a' );
+	t.strictEqual( actual, expected, 'removes \\u200a' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2028' );
-	t.equal( actual, expected, 'removes \\u2028' );
+	t.strictEqual( actual, expected, 'removes \\u2028' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2029' );
-	t.equal( actual, expected, 'removes \\u2029' );
+	t.strictEqual( actual, expected, 'removes \\u2029' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u202f' );
-	t.equal( actual, expected, 'removes \\u202f' );
+	t.strictEqual( actual, expected, 'removes \\u202f' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u205f' );
-	t.equal( actual, expected, 'removes \\u205f' );
+	t.strictEqual( actual, expected, 'removes \\u205f' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u3000' );
-	t.equal( actual, expected, 'removes \\u3000' );
+	t.strictEqual( actual, expected, 'removes \\u3000' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\ufeff' );
-	t.equal( actual, expected, 'removes \\ufefff' );
+	t.strictEqual( actual, expected, 'removes \\ufefff' );
 
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function does not trim the Mongolian space separator in accordance wi
 
 	expected = 'beep\u180e';
 	actual = rtrim( 'beep\u180e' );
-	t.equal( actual, expected, 'does not remove \\u180e' );
+	t.strictEqual( actual, expected, 'does not remove \\u180e' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/starts-with/test/test.js b/lib/node_modules/@stdlib/string/base/starts-with/test/test.js
index a2c580d910e6..67253542cab1 100644
--- a/lib/node_modules/@stdlib/string/base/starts-with/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/starts-with/test/test.js
@@ -39,7 +39,7 @@ tape( 'the main export is a polyfill if an environment does not support String.p
 	var startsWith = proxyquire( './../lib', {
 		'./has_builtin.js': false
 	});
-	t.equal( startsWith, polyfill, 'returns expected value' );
+	t.strictEqual( startsWith, polyfill, 'returns expected value' );
 	t.end();
 });
 
@@ -47,7 +47,7 @@ tape( 'the main export is a wrapper around a builtin if an environment supports
 	var startsWith = proxyquire( './../lib', {
 		'./has_builtin.js': true
 	});
-	t.equal( startsWith, main, 'returns expected value' );
+	t.strictEqual( startsWith, main, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/string/base/test/test.js b/lib/node_modules/@stdlib/string/base/test/test.js
index 7dc695dca1ea..893b0402a754 100644
--- a/lib/node_modules/@stdlib/string/base/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains base (i.e., lower-level) string functions', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/trim/test/test.js b/lib/node_modules/@stdlib/string/base/trim/test/test.js
index 291b1e49bf5f..04893756061b 100644
--- a/lib/node_modules/@stdlib/string/base/trim/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/trim/test/test.js
@@ -39,7 +39,7 @@ tape( 'the main export is a polyfill if an environment does not support String.p
 	var trim = proxyquire( './../lib', {
 		'./has_builtin.js': false
 	});
-	t.equal( trim, polyfill, 'returns expected value' );
+	t.strictEqual( trim, polyfill, 'returns expected value' );
 	t.end();
 });
 
@@ -48,7 +48,7 @@ tape( 'the main export is a polyfill if an environment has deprecated String.pro
 		'./has_builtin.js': true,
 		'./check.js': mock
 	});
-	t.equal( trim, polyfill, 'returns expected value' );
+	t.strictEqual( trim, polyfill, 'returns expected value' );
 	t.end();
 
 	function mock() {
@@ -61,7 +61,7 @@ tape( 'the main export is a wrapper around a builtin if an environment supports
 		'./has_builtin.js': true,
 		'./check.js': mock
 	});
-	t.equal( trim, main, 'returns expected value' );
+	t.strictEqual( trim, main, 'returns expected value' );
 	t.end();
 
 	function mock() {
@@ -75,131 +75,131 @@ tape( 'the function removes all whitespace characters at the beginning and end o
 
 	expected = 'Whitespace';
 	actual = trim( '   Whitespace   ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'beep';
 	actual = trim( '    beep' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'boop';
 	actual = trim( 'boop        ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'foo foo';
 	actual = trim( '   foo foo     ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = '# bar bar bar';
 	actual = trim( '# bar bar bar    ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = '# beep boop';
 	actual = trim( '         # beep boop' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'foo \n\n\n\n foo';
 	actual = trim( '   foo \n\n\n\n foo     ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'Tabs';
 	actual = trim( '\t\t\tTabs\t\t\t' );
-	t.equal( actual, expected, 'removes all tabs' );
+	t.strictEqual( actual, expected, 'removes all tabs' );
 
 	expected = 'New Lines';
 	actual = trim( '\n\n\nNew Lines\n\n\n' );
-	t.equal( actual, expected, 'removes all newline characters' );
+	t.strictEqual( actual, expected, 'removes all newline characters' );
 
 	expected = 'Beep';
 	actual = trim( ' \r\n\tBeep \r\n\t' );
-	t.equal( actual, expected, 'removes all whitespace characters' );
+	t.strictEqual( actual, expected, 'removes all whitespace characters' );
 
 	expected = 'beep';
 	actual = trim( '\fbeep\f' );
-	t.equal( actual, expected, 'removes \\f' );
+	t.strictEqual( actual, expected, 'removes \\f' );
 
 	expected = 'beep';
 	actual = trim( '\nbeep\n' );
-	t.equal( actual, expected, 'removes \\n' );
+	t.strictEqual( actual, expected, 'removes \\n' );
 
 	expected = 'beep';
 	actual = trim( '\tbeep\t' );
-	t.equal( actual, expected, 'removes \\t' );
+	t.strictEqual( actual, expected, 'removes \\t' );
 
 	expected = 'beep';
 	actual = trim( '\vbeep\v' );
-	t.equal( actual, expected, 'removes \\v' );
+	t.strictEqual( actual, expected, 'removes \\v' );
 
 	expected = 'beep';
 	actual = trim( '\u1680beep\u1680' );
-	t.equal( actual, expected, 'removes \\u1680' );
+	t.strictEqual( actual, expected, 'removes \\u1680' );
 
 	expected = 'beep';
 	actual = trim( '\u2000beep\u2000' );
-	t.equal( actual, expected, 'removes \\u2000' );
+	t.strictEqual( actual, expected, 'removes \\u2000' );
 
 	expected = 'beep';
 	actual = trim( '\u2001beep\u2001' );
-	t.equal( actual, expected, 'removes \\u2001' );
+	t.strictEqual( actual, expected, 'removes \\u2001' );
 
 	expected = 'beep';
 	actual = trim( '\u2002beep\u2002' );
-	t.equal( actual, expected, 'removes \\u2002' );
+	t.strictEqual( actual, expected, 'removes \\u2002' );
 
 	expected = 'beep';
 	actual = trim( '\u2003beep\u2003' );
-	t.equal( actual, expected, 'removes \\u2003' );
+	t.strictEqual( actual, expected, 'removes \\u2003' );
 
 	expected = 'beep';
 	actual = trim( '\u2004beep\u2004' );
-	t.equal( actual, expected, 'removes \\u2004' );
+	t.strictEqual( actual, expected, 'removes \\u2004' );
 
 	expected = 'beep';
 	actual = trim( '\u2005beep\u2005' );
-	t.equal( actual, expected, 'removes \\u2005' );
+	t.strictEqual( actual, expected, 'removes \\u2005' );
 
 	expected = 'beep';
 	actual = trim( '\u2006beep\u2006' );
-	t.equal( actual, expected, 'removes \\u2006' );
+	t.strictEqual( actual, expected, 'removes \\u2006' );
 
 	expected = 'beep';
 	actual = trim( '\u2007beep\u2007' );
-	t.equal( actual, expected, 'removes \\u2007' );
+	t.strictEqual( actual, expected, 'removes \\u2007' );
 
 	expected = 'beep';
 	actual = trim( '\u2008beep\u2008' );
-	t.equal( actual, expected, 'removes \\u2008' );
+	t.strictEqual( actual, expected, 'removes \\u2008' );
 
 	expected = 'beep';
 	actual = trim( '\u2009beep\u2009' );
-	t.equal( actual, expected, 'removes \\u2009' );
+	t.strictEqual( actual, expected, 'removes \\u2009' );
 
 	expected = 'beep';
 	actual = trim( '\u200abeep\u200a' );
-	t.equal( actual, expected, 'removes \\u200a' );
+	t.strictEqual( actual, expected, 'removes \\u200a' );
 
 	expected = 'beep';
 	actual = trim( '\u2028beep\u2028' );
-	t.equal( actual, expected, 'removes \\u2028' );
+	t.strictEqual( actual, expected, 'removes \\u2028' );
 
 	expected = 'beep';
 	actual = trim( '\u2029beep\u2029' );
-	t.equal( actual, expected, 'removes \\u2029' );
+	t.strictEqual( actual, expected, 'removes \\u2029' );
 
 	expected = 'beep';
 	actual = trim( '\u202fbeep\u202f' );
-	t.equal( actual, expected, 'removes \\u202f' );
+	t.strictEqual( actual, expected, 'removes \\u202f' );
 
 	expected = 'beep';
 	actual = trim( '\u205fbeep\u205f' );
-	t.equal( actual, expected, 'removes \\u205f' );
+	t.strictEqual( actual, expected, 'removes \\u205f' );
 
 	expected = 'beep';
 	actual = trim( '\u3000beep\u3000' );
-	t.equal( actual, expected, 'removes \\u3000' );
+	t.strictEqual( actual, expected, 'removes \\u3000' );
 
 	expected = 'beep';
 	actual = trim( '\ufeffbeep\ufeff' );
-	t.equal( actual, expected, 'removes \\ufefff' );
+	t.strictEqual( actual, expected, 'removes \\ufefff' );
 
 	t.end();
 });
@@ -210,7 +210,7 @@ tape( 'the function does not remove the Mongolian space separator in accordance
 
 	expected = '\u180ebeep\u180e';
 	actual = trim( '\u180ebeep\u180e' );
-	t.equal( actual, expected, 'does not remove \\u180e' );
+	t.strictEqual( actual, expected, 'does not remove \\u180e' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/trim/test/test.main.js b/lib/node_modules/@stdlib/string/base/trim/test/test.main.js
index 69759cb9ee50..8c8155d0fdf5 100644
--- a/lib/node_modules/@stdlib/string/base/trim/test/test.main.js
+++ b/lib/node_modules/@stdlib/string/base/trim/test/test.main.js
@@ -46,131 +46,131 @@ tape( 'the function removes all whitespace characters at the beginning and end o
 
 	expected = 'Whitespace';
 	actual = trim( '   Whitespace   ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'beep';
 	actual = trim( '    beep' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'boop';
 	actual = trim( 'boop        ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'foo foo';
 	actual = trim( '   foo foo     ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = '# bar bar bar';
 	actual = trim( '# bar bar bar    ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = '# beep boop';
 	actual = trim( '         # beep boop' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'foo \n\n\n\n foo';
 	actual = trim( '   foo \n\n\n\n foo     ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'Tabs';
 	actual = trim( '\t\t\tTabs\t\t\t' );
-	t.equal( actual, expected, 'removes all tabs' );
+	t.strictEqual( actual, expected, 'removes all tabs' );
 
 	expected = 'New Lines';
 	actual = trim( '\n\n\nNew Lines\n\n\n' );
-	t.equal( actual, expected, 'removes all newline characters' );
+	t.strictEqual( actual, expected, 'removes all newline characters' );
 
 	expected = 'Beep';
 	actual = trim( ' \r\n\tBeep \r\n\t' );
-	t.equal( actual, expected, 'removes all whitespace characters' );
+	t.strictEqual( actual, expected, 'removes all whitespace characters' );
 
 	expected = 'beep';
 	actual = trim( '\fbeep\f' );
-	t.equal( actual, expected, 'removes \\f' );
+	t.strictEqual( actual, expected, 'removes \\f' );
 
 	expected = 'beep';
 	actual = trim( '\nbeep\n' );
-	t.equal( actual, expected, 'removes \\n' );
+	t.strictEqual( actual, expected, 'removes \\n' );
 
 	expected = 'beep';
 	actual = trim( '\tbeep\t' );
-	t.equal( actual, expected, 'removes \\t' );
+	t.strictEqual( actual, expected, 'removes \\t' );
 
 	expected = 'beep';
 	actual = trim( '\vbeep\v' );
-	t.equal( actual, expected, 'removes \\v' );
+	t.strictEqual( actual, expected, 'removes \\v' );
 
 	expected = 'beep';
 	actual = trim( '\u1680beep\u1680' );
-	t.equal( actual, expected, 'removes \\u1680' );
+	t.strictEqual( actual, expected, 'removes \\u1680' );
 
 	expected = 'beep';
 	actual = trim( '\u2000beep\u2000' );
-	t.equal( actual, expected, 'removes \\u2000' );
+	t.strictEqual( actual, expected, 'removes \\u2000' );
 
 	expected = 'beep';
 	actual = trim( '\u2001beep\u2001' );
-	t.equal( actual, expected, 'removes \\u2001' );
+	t.strictEqual( actual, expected, 'removes \\u2001' );
 
 	expected = 'beep';
 	actual = trim( '\u2002beep\u2002' );
-	t.equal( actual, expected, 'removes \\u2002' );
+	t.strictEqual( actual, expected, 'removes \\u2002' );
 
 	expected = 'beep';
 	actual = trim( '\u2003beep\u2003' );
-	t.equal( actual, expected, 'removes \\u2003' );
+	t.strictEqual( actual, expected, 'removes \\u2003' );
 
 	expected = 'beep';
 	actual = trim( '\u2004beep\u2004' );
-	t.equal( actual, expected, 'removes \\u2004' );
+	t.strictEqual( actual, expected, 'removes \\u2004' );
 
 	expected = 'beep';
 	actual = trim( '\u2005beep\u2005' );
-	t.equal( actual, expected, 'removes \\u2005' );
+	t.strictEqual( actual, expected, 'removes \\u2005' );
 
 	expected = 'beep';
 	actual = trim( '\u2006beep\u2006' );
-	t.equal( actual, expected, 'removes \\u2006' );
+	t.strictEqual( actual, expected, 'removes \\u2006' );
 
 	expected = 'beep';
 	actual = trim( '\u2007beep\u2007' );
-	t.equal( actual, expected, 'removes \\u2007' );
+	t.strictEqual( actual, expected, 'removes \\u2007' );
 
 	expected = 'beep';
 	actual = trim( '\u2008beep\u2008' );
-	t.equal( actual, expected, 'removes \\u2008' );
+	t.strictEqual( actual, expected, 'removes \\u2008' );
 
 	expected = 'beep';
 	actual = trim( '\u2009beep\u2009' );
-	t.equal( actual, expected, 'removes \\u2009' );
+	t.strictEqual( actual, expected, 'removes \\u2009' );
 
 	expected = 'beep';
 	actual = trim( '\u200abeep\u200a' );
-	t.equal( actual, expected, 'removes \\u200a' );
+	t.strictEqual( actual, expected, 'removes \\u200a' );
 
 	expected = 'beep';
 	actual = trim( '\u2028beep\u2028' );
-	t.equal( actual, expected, 'removes \\u2028' );
+	t.strictEqual( actual, expected, 'removes \\u2028' );
 
 	expected = 'beep';
 	actual = trim( '\u2029beep\u2029' );
-	t.equal( actual, expected, 'removes \\u2029' );
+	t.strictEqual( actual, expected, 'removes \\u2029' );
 
 	expected = 'beep';
 	actual = trim( '\u202fbeep\u202f' );
-	t.equal( actual, expected, 'removes \\u202f' );
+	t.strictEqual( actual, expected, 'removes \\u202f' );
 
 	expected = 'beep';
 	actual = trim( '\u205fbeep\u205f' );
-	t.equal( actual, expected, 'removes \\u205f' );
+	t.strictEqual( actual, expected, 'removes \\u205f' );
 
 	expected = 'beep';
 	actual = trim( '\u3000beep\u3000' );
-	t.equal( actual, expected, 'removes \\u3000' );
+	t.strictEqual( actual, expected, 'removes \\u3000' );
 
 	expected = 'beep';
 	actual = trim( '\ufeffbeep\ufeff' );
-	t.equal( actual, expected, 'removes \\ufefff' );
+	t.strictEqual( actual, expected, 'removes \\ufefff' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/trim/test/test.polyfill.js b/lib/node_modules/@stdlib/string/base/trim/test/test.polyfill.js
index 73d1d8fa4c75..5e240cf7b349 100644
--- a/lib/node_modules/@stdlib/string/base/trim/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/string/base/trim/test/test.polyfill.js
@@ -38,131 +38,131 @@ tape( 'the function removes all whitespace characters at the beginning and end o
 
 	expected = 'Whitespace';
 	actual = trim( '   Whitespace   ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'beep';
 	actual = trim( '    beep' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'boop';
 	actual = trim( 'boop        ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'foo foo';
 	actual = trim( '   foo foo     ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = '# bar bar bar';
 	actual = trim( '# bar bar bar    ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = '# beep boop';
 	actual = trim( '         # beep boop' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'foo \n\n\n\n foo';
 	actual = trim( '   foo \n\n\n\n foo     ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'Tabs';
 	actual = trim( '\t\t\tTabs\t\t\t' );
-	t.equal( actual, expected, 'removes all tabs' );
+	t.strictEqual( actual, expected, 'removes all tabs' );
 
 	expected = 'New Lines';
 	actual = trim( '\n\n\nNew Lines\n\n\n' );
-	t.equal( actual, expected, 'removes all newline characters' );
+	t.strictEqual( actual, expected, 'removes all newline characters' );
 
 	expected = 'Beep';
 	actual = trim( ' \r\n\tBeep \r\n\t' );
-	t.equal( actual, expected, 'removes all whitespace characters' );
+	t.strictEqual( actual, expected, 'removes all whitespace characters' );
 
 	expected = 'beep';
 	actual = trim( '\fbeep\f' );
-	t.equal( actual, expected, 'removes \\f' );
+	t.strictEqual( actual, expected, 'removes \\f' );
 
 	expected = 'beep';
 	actual = trim( '\nbeep\n' );
-	t.equal( actual, expected, 'removes \\n' );
+	t.strictEqual( actual, expected, 'removes \\n' );
 
 	expected = 'beep';
 	actual = trim( '\tbeep\t' );
-	t.equal( actual, expected, 'removes \\t' );
+	t.strictEqual( actual, expected, 'removes \\t' );
 
 	expected = 'beep';
 	actual = trim( '\vbeep\v' );
-	t.equal( actual, expected, 'removes \\v' );
+	t.strictEqual( actual, expected, 'removes \\v' );
 
 	expected = 'beep';
 	actual = trim( '\u1680beep\u1680' );
-	t.equal( actual, expected, 'removes \\u1680' );
+	t.strictEqual( actual, expected, 'removes \\u1680' );
 
 	expected = 'beep';
 	actual = trim( '\u2000beep\u2000' );
-	t.equal( actual, expected, 'removes \\u2000' );
+	t.strictEqual( actual, expected, 'removes \\u2000' );
 
 	expected = 'beep';
 	actual = trim( '\u2001beep\u2001' );
-	t.equal( actual, expected, 'removes \\u2001' );
+	t.strictEqual( actual, expected, 'removes \\u2001' );
 
 	expected = 'beep';
 	actual = trim( '\u2002beep\u2002' );
-	t.equal( actual, expected, 'removes \\u2002' );
+	t.strictEqual( actual, expected, 'removes \\u2002' );
 
 	expected = 'beep';
 	actual = trim( '\u2003beep\u2003' );
-	t.equal( actual, expected, 'removes \\u2003' );
+	t.strictEqual( actual, expected, 'removes \\u2003' );
 
 	expected = 'beep';
 	actual = trim( '\u2004beep\u2004' );
-	t.equal( actual, expected, 'removes \\u2004' );
+	t.strictEqual( actual, expected, 'removes \\u2004' );
 
 	expected = 'beep';
 	actual = trim( '\u2005beep\u2005' );
-	t.equal( actual, expected, 'removes \\u2005' );
+	t.strictEqual( actual, expected, 'removes \\u2005' );
 
 	expected = 'beep';
 	actual = trim( '\u2006beep\u2006' );
-	t.equal( actual, expected, 'removes \\u2006' );
+	t.strictEqual( actual, expected, 'removes \\u2006' );
 
 	expected = 'beep';
 	actual = trim( '\u2007beep\u2007' );
-	t.equal( actual, expected, 'removes \\u2007' );
+	t.strictEqual( actual, expected, 'removes \\u2007' );
 
 	expected = 'beep';
 	actual = trim( '\u2008beep\u2008' );
-	t.equal( actual, expected, 'removes \\u2008' );
+	t.strictEqual( actual, expected, 'removes \\u2008' );
 
 	expected = 'beep';
 	actual = trim( '\u2009beep\u2009' );
-	t.equal( actual, expected, 'removes \\u2009' );
+	t.strictEqual( actual, expected, 'removes \\u2009' );
 
 	expected = 'beep';
 	actual = trim( '\u200abeep\u200a' );
-	t.equal( actual, expected, 'removes \\u200a' );
+	t.strictEqual( actual, expected, 'removes \\u200a' );
 
 	expected = 'beep';
 	actual = trim( '\u2028beep\u2028' );
-	t.equal( actual, expected, 'removes \\u2028' );
+	t.strictEqual( actual, expected, 'removes \\u2028' );
 
 	expected = 'beep';
 	actual = trim( '\u2029beep\u2029' );
-	t.equal( actual, expected, 'removes \\u2029' );
+	t.strictEqual( actual, expected, 'removes \\u2029' );
 
 	expected = 'beep';
 	actual = trim( '\u202fbeep\u202f' );
-	t.equal( actual, expected, 'removes \\u202f' );
+	t.strictEqual( actual, expected, 'removes \\u202f' );
 
 	expected = 'beep';
 	actual = trim( '\u205fbeep\u205f' );
-	t.equal( actual, expected, 'removes \\u205f' );
+	t.strictEqual( actual, expected, 'removes \\u205f' );
 
 	expected = 'beep';
 	actual = trim( '\u3000beep\u3000' );
-	t.equal( actual, expected, 'removes \\u3000' );
+	t.strictEqual( actual, expected, 'removes \\u3000' );
 
 	expected = 'beep';
 	actual = trim( '\ufeffbeep\ufeff' );
-	t.equal( actual, expected, 'removes \\ufefff' );
+	t.strictEqual( actual, expected, 'removes \\ufefff' );
 
 	t.end();
 });
@@ -173,7 +173,7 @@ tape( 'the function does not remove the Mongolian space separator in accordance
 
 	expected = '\u180ebeep\u180e';
 	actual = trim( '\u180ebeep\u180e' );
-	t.equal( actual, expected, 'does not remove \\u180e' );
+	t.strictEqual( actual, expected, 'does not remove \\u180e' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/uncapitalize/test/test.js b/lib/node_modules/@stdlib/string/base/uncapitalize/test/test.js
index cc8a601acd71..dcd43583cedd 100644
--- a/lib/node_modules/@stdlib/string/base/uncapitalize/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/uncapitalize/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an empty string if provided an empty string', function test( t ) {
-	t.equal( uncapitalize( '' ), '', 'returns empty string' );
+	t.strictEqual( uncapitalize( '' ), '', 'returns empty string' );
 	t.end();
 });
 
@@ -41,13 +41,13 @@ tape( 'the function converts the first character of an input string to lowercase
 	var out;
 
 	out = uncapitalize( 'Hello world' );
-	t.equal( out, 'hello world', 'uncapitalizes first character' );
+	t.strictEqual( out, 'hello world', 'uncapitalizes first character' );
 
 	out = uncapitalize( '!!!' );
-	t.equal( out, '!!!', 'does not change non-alphabetical characters' );
+	t.strictEqual( out, '!!!', 'does not change non-alphabetical characters' );
 
 	out = uncapitalize( 'hello World' );
-	t.equal( out, 'hello World', 'leaves lowercase letters in lowercase' );
+	t.strictEqual( out, 'hello World', 'leaves lowercase letters in lowercase' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/uppercase/test/test.js b/lib/node_modules/@stdlib/string/base/uppercase/test/test.js
index 5d6328a10499..35246eea7cf2 100644
--- a/lib/node_modules/@stdlib/string/base/uppercase/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/uppercase/test/test.js
@@ -58,7 +58,7 @@ tape( 'the function converts a string to uppercase', function test( t ) {
 	];
 	for ( i = 0; i < values.length; i++ ) {
 		actual = uppercase( values[i] );
-		t.equal( actual, expected[i], 'converts string to '+expected[i] );
+		t.strictEqual( actual, expected[i], 'converts string to '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/capitalize/test/test.js b/lib/node_modules/@stdlib/string/capitalize/test/test.js
index 3659f9d356c8..ee90106b786e 100644
--- a/lib/node_modules/@stdlib/string/capitalize/test/test.js
+++ b/lib/node_modules/@stdlib/string/capitalize/test/test.js
@@ -60,7 +60,7 @@ tape( 'the function throws an error if not provided a string', function test( t
 });
 
 tape( 'the function returns an empty string if provided an empty string', function test( t ) {
-	t.equal( capitalize( '' ), '', 'returns empty string' );
+	t.strictEqual( capitalize( '' ), '', 'returns empty string' );
 	t.end();
 });
 
@@ -68,13 +68,13 @@ tape( 'the function capitalizes the first character in a provided string', funct
 	var out;
 
 	out = capitalize( 'hello world' );
-	t.equal( out, 'Hello world', 'capitalizes first character' );
+	t.strictEqual( out, 'Hello world', 'capitalizes first character' );
 
 	out = capitalize( '!!!' );
-	t.equal( out, '!!!', 'does not change non-alphabetical characters' );
+	t.strictEqual( out, '!!!', 'does not change non-alphabetical characters' );
 
 	out = capitalize( 'Hello World' );
-	t.equal( out, 'Hello World', 'leaves uppercase letters in uppercase' );
+	t.strictEqual( out, 'Hello World', 'leaves uppercase letters in uppercase' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/left-pad/test/test.js b/lib/node_modules/@stdlib/string/left-pad/test/test.js
index 348f6369374c..8a1a40a23943 100644
--- a/lib/node_modules/@stdlib/string/left-pad/test/test.js
+++ b/lib/node_modules/@stdlib/string/left-pad/test/test.js
@@ -133,24 +133,24 @@ tape( 'if provided an empty pad string, the function throws an error', function
 
 tape( 'by default, the function left pads a string with spaces', function test( t ) {
 	var str = lpad( 'a', 5 );
-	t.equal( str, '    a', 'left padded with spaces' );
+	t.strictEqual( str, '    a', 'left padded with spaces' );
 	t.end();
 });
 
 tape( 'the function supports left padding a string with a custom pad string', function test( t ) {
 	var str = lpad( 'beep', 10, 'b' );
-	t.equal( str, 'bbbbbbbeep', 'left padded to desired length' );
+	t.strictEqual( str, 'bbbbbbbeep', 'left padded to desired length' );
 	t.end();
 });
 
 tape( 'the function left pads a string such that an output string may exceed the specified length (minimum bound)', function test( t ) {
 	var str = lpad( 'a', 5, 'beepboop' );
-	t.equal( str, 'beepboopa', 'left padded and length exceeds minimum length' );
+	t.strictEqual( str, 'beepboopa', 'left padded and length exceeds minimum length' );
 	t.end();
 });
 
 tape( 'if the specified string length is less than or equal to the input string length, the function returns the input string', function test( t ) {
-	t.equal( lpad( 'boop', 2, 'beep' ), 'boop', 'returns input string (<)' );
-	t.equal( lpad( 'boop', 4, 'beep' ), 'boop', 'returns input string (=)' );
+	t.strictEqual( lpad( 'boop', 2, 'beep' ), 'boop', 'returns input string (<)' );
+	t.strictEqual( lpad( 'boop', 4, 'beep' ), 'boop', 'returns input string (=)' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/left-trim/test/test.js b/lib/node_modules/@stdlib/string/left-trim/test/test.js
index 6f1d1c98c852..d029327b41c5 100644
--- a/lib/node_modules/@stdlib/string/left-trim/test/test.js
+++ b/lib/node_modules/@stdlib/string/left-trim/test/test.js
@@ -65,111 +65,111 @@ tape( 'the function removes all whitespace characters at the beginning of a stri
 
 	expected = 'Whitespace   ';
 	actual = ltrim( '   Whitespace   ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'Tabs\t\t\t';
 	actual = ltrim( '\t\t\tTabs\t\t\t' );
-	t.equal( actual, expected, 'removes all tabs' );
+	t.strictEqual( actual, expected, 'removes all tabs' );
 
 	expected = 'New Lines\n\n\n';
 	actual = ltrim( '\n\n\nNew Lines\n\n\n' );
-	t.equal( actual, expected, 'removes all newline characters' );
+	t.strictEqual( actual, expected, 'removes all newline characters' );
 
 	expected = 'New Lines\r\n\r\n\r\n';
 	actual = ltrim( '\r\n\r\n\r\nNew Lines\r\n\r\n\r\n' );
-	t.equal( actual, expected, 'removes all newline and carriage return characters' );
+	t.strictEqual( actual, expected, 'removes all newline and carriage return characters' );
 
 	expected = 'Beep \r\n \t';
 	actual = ltrim( ' \t\r\n Beep \r\n \t' );
-	t.equal( actual, expected, 'removes all whitespace characters' );
+	t.strictEqual( actual, expected, 'removes all whitespace characters' );
 
 	expected = 'beep';
 	actual = ltrim( '\fbeep' );
-	t.equal( actual, expected, 'removes \\f' );
+	t.strictEqual( actual, expected, 'removes \\f' );
 
 	expected = 'beep';
 	actual = ltrim( '\nbeep' );
-	t.equal( actual, expected, 'removes \\n' );
+	t.strictEqual( actual, expected, 'removes \\n' );
 
 	expected = 'beep';
 	actual = ltrim( '\tbeep' );
-	t.equal( actual, expected, 'removes \\t' );
+	t.strictEqual( actual, expected, 'removes \\t' );
 
 	expected = 'beep';
 	actual = ltrim( '\vbeep' );
-	t.equal( actual, expected, 'removes \\v' );
+	t.strictEqual( actual, expected, 'removes \\v' );
 
 	expected = 'beep';
 	actual = ltrim( '\u1680beep' );
-	t.equal( actual, expected, 'removes \\u1680' );
+	t.strictEqual( actual, expected, 'removes \\u1680' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2000beep' );
-	t.equal( actual, expected, 'removes \\u2000' );
+	t.strictEqual( actual, expected, 'removes \\u2000' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2001beep' );
-	t.equal( actual, expected, 'removes \\u2001' );
+	t.strictEqual( actual, expected, 'removes \\u2001' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2002beep' );
-	t.equal( actual, expected, 'removes \\u2002' );
+	t.strictEqual( actual, expected, 'removes \\u2002' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2003beep' );
-	t.equal( actual, expected, 'removes \\u2003' );
+	t.strictEqual( actual, expected, 'removes \\u2003' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2004beep' );
-	t.equal( actual, expected, 'removes \\u2004' );
+	t.strictEqual( actual, expected, 'removes \\u2004' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2005beep' );
-	t.equal( actual, expected, 'removes \\u2005' );
+	t.strictEqual( actual, expected, 'removes \\u2005' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2006beep' );
-	t.equal( actual, expected, 'removes \\u2006' );
+	t.strictEqual( actual, expected, 'removes \\u2006' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2007beep' );
-	t.equal( actual, expected, 'removes \\u2007' );
+	t.strictEqual( actual, expected, 'removes \\u2007' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2008beep' );
-	t.equal( actual, expected, 'removes \\u2008' );
+	t.strictEqual( actual, expected, 'removes \\u2008' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2009beep' );
-	t.equal( actual, expected, 'removes \\u2009' );
+	t.strictEqual( actual, expected, 'removes \\u2009' );
 
 	expected = 'beep';
 	actual = ltrim( '\u200abeep' );
-	t.equal( actual, expected, 'removes \\u200a' );
+	t.strictEqual( actual, expected, 'removes \\u200a' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2028beep' );
-	t.equal( actual, expected, 'removes \\u2028' );
+	t.strictEqual( actual, expected, 'removes \\u2028' );
 
 	expected = 'beep';
 	actual = ltrim( '\u2029beep' );
-	t.equal( actual, expected, 'removes \\u2029' );
+	t.strictEqual( actual, expected, 'removes \\u2029' );
 
 	expected = 'beep';
 	actual = ltrim( '\u202fbeep' );
-	t.equal( actual, expected, 'removes \\u202f' );
+	t.strictEqual( actual, expected, 'removes \\u202f' );
 
 	expected = 'beep';
 	actual = ltrim( '\u205fbeep' );
-	t.equal( actual, expected, 'removes \\u205f' );
+	t.strictEqual( actual, expected, 'removes \\u205f' );
 
 	expected = 'beep';
 	actual = ltrim( '\u3000beep' );
-	t.equal( actual, expected, 'removes \\u3000' );
+	t.strictEqual( actual, expected, 'removes \\u3000' );
 
 	expected = 'beep';
 	actual = ltrim( '\ufeffbeep' );
-	t.equal( actual, expected, 'removes \\ufefff' );
+	t.strictEqual( actual, expected, 'removes \\ufefff' );
 
 	t.end();
 });
@@ -180,7 +180,7 @@ tape( 'the function does not remove the Mongolian space separator in accordance
 
 	expected = '\u180ebeep';
 	actual = ltrim( '\u180ebeep' );
-	t.equal( actual, expected, 'does not remove \\u180e' );
+	t.strictEqual( actual, expected, 'does not remove \\u180e' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/lowercase/test/test.js b/lib/node_modules/@stdlib/string/lowercase/test/test.js
index f5784670e689..0b3384bc2d78 100644
--- a/lib/node_modules/@stdlib/string/lowercase/test/test.js
+++ b/lib/node_modules/@stdlib/string/lowercase/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function converts a string to lowercase', function test( t ) {
 	];
 	for ( i = 0; i < values.length; i++ ) {
 		actual = lowercase( values[i] );
-		t.equal( actual, expected[i], 'converts string to '+expected[i] );
+		t.strictEqual( actual, expected[i], 'converts string to '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/num2words/test/test.js b/lib/node_modules/@stdlib/string/num2words/test/test.js
index c0f5f5ef1876..7b06a12c3327 100644
--- a/lib/node_modules/@stdlib/string/num2words/test/test.js
+++ b/lib/node_modules/@stdlib/string/num2words/test/test.js
@@ -176,7 +176,7 @@ tape( 'the function converts an integer to its word representation (default lang
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( num2words( values[i] ), expected[i], 'returns expected value' );
+		t.strictEqual( num2words( values[i] ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -204,7 +204,7 @@ tape( 'the function converts a decimal number to its word representation (defaul
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( num2words( values[i] ), expected[i], 'returns expected value' );
+		t.strictEqual( num2words( values[i] ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -244,7 +244,7 @@ tape( 'the function converts an integer to its word representation (lang=en)', f
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( num2words( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( num2words( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -276,7 +276,7 @@ tape( 'the function converts a decimal number to its word representation (lang=e
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( num2words( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( num2words( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -333,7 +333,7 @@ tape( 'the function converts an integer to its word representation (lang=de)', f
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( num2words( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( num2words( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -364,14 +364,14 @@ tape( 'the function converts a decimal number to its word representation (lang=d
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( num2words( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( num2words( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
 
 tape( 'the function handles infinity (default language)', function test( t ) {
-	t.equal( num2words( PINF ), 'infinity', 'returns expected value' );
-	t.equal( num2words( NINF ), 'negative infinity', 'returns expected value' );
+	t.strictEqual( num2words( PINF ), 'infinity', 'returns expected value' );
+	t.strictEqual( num2words( NINF ), 'negative infinity', 'returns expected value' );
 	t.end();
 });
 
@@ -379,8 +379,8 @@ tape( 'the function handles infinity (lang=en)', function test( t ) {
 	var opts = {
 		'lang': 'en'
 	};
-	t.equal( num2words( PINF, opts ), 'infinity', 'returns expected value' );
-	t.equal( num2words( NINF, opts ), 'negative infinity', 'returns expected value' );
+	t.strictEqual( num2words( PINF, opts ), 'infinity', 'returns expected value' );
+	t.strictEqual( num2words( NINF, opts ), 'negative infinity', 'returns expected value' );
 	t.end();
 });
 
@@ -388,7 +388,7 @@ tape( 'the function handles infinity (lang=de)', function test( t ) {
 	var opts = {
 		'lang': 'de'
 	};
-	t.equal( num2words( PINF, opts ), 'unendlich', 'returns expected value' );
-	t.equal( num2words( NINF, opts ), 'minus unendlich', 'returns expected value' );
+	t.strictEqual( num2words( PINF, opts ), 'unendlich', 'returns expected value' );
+	t.strictEqual( num2words( NINF, opts ), 'minus unendlich', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/num2words/test/test.validate.js b/lib/node_modules/@stdlib/string/num2words/test/test.validate.js
index 7baf4de7530d..84dca3867db8 100644
--- a/lib/node_modules/@stdlib/string/num2words/test/test.validate.js
+++ b/lib/node_modules/@stdlib/string/num2words/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns a type error if provided a `lang` option which is no
 		err = validate( {}, {
 			'lang': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -119,7 +119,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/string/pad/test/test.js b/lib/node_modules/@stdlib/string/pad/test/test.js
index 6d93dd792c03..c7202d3d5415 100644
--- a/lib/node_modules/@stdlib/string/pad/test/test.js
+++ b/lib/node_modules/@stdlib/string/pad/test/test.js
@@ -143,7 +143,7 @@ tape( 'if no pad strings have a positive length, the function throws an error',
 
 tape( 'by default, the function right pads a string with spaces', function test( t ) {
 	var str = pad( 'a', 5 );
-	t.equal( str, 'a    ', 'right padded with spaces' );
+	t.strictEqual( str, 'a    ', 'right padded with spaces' );
 	t.end();
 });
 
@@ -151,7 +151,7 @@ tape( 'the function supports right padding a string with a custom pad string', f
 	var str = pad( 'beep', 10, {
 		'rpad': 'p'
 	});
-	t.equal( str, 'beeppppppp', 'right padded to desired length' );
+	t.strictEqual( str, 'beeppppppp', 'right padded to desired length' );
 	t.end();
 });
 
@@ -159,7 +159,7 @@ tape( 'the function right pads a string and trims any excess padding', function
 	var str = pad( 'a', 5, {
 		'rpad': 'beepboop'
 	});
-	t.equal( str, 'abeep', 'right padded and trimmed' );
+	t.strictEqual( str, 'abeep', 'right padded and trimmed' );
 	t.end();
 });
 
@@ -167,7 +167,7 @@ tape( 'the function supports left padding a string with a custom pad string', fu
 	var str = pad( 'beep', 10, {
 		'lpad': 'b'
 	});
-	t.equal( str, 'bbbbbbbeep', 'left padded to desired length' );
+	t.strictEqual( str, 'bbbbbbbeep', 'left padded to desired length' );
 	t.end();
 });
 
@@ -175,7 +175,7 @@ tape( 'the function left pads a string and trims any excess padding', function t
 	var str = pad( 'a', 5, {
 		'lpad': 'beepboop'
 	});
-	t.equal( str, 'boopa', 'left padded and trimmed' );
+	t.strictEqual( str, 'boopa', 'left padded and trimmed' );
 	t.end();
 });
 
@@ -186,13 +186,13 @@ tape( 'the function supports centering a string', function test( t ) {
 		'lpad': 'b',
 		'rpad': 'p'
 	});
-	t.equal( str, 'bbbbeepppp', 'returns centered string (simple)' );
+	t.strictEqual( str, 'bbbbeepppp', 'returns centered string (simple)' );
 
 	str = pad( 'beep', 10, {
 		'lpad': 'b!',
 		'rpad': 'p?*'
 	});
-	t.equal( str, 'b!bbeepp?*', 'returns centered string (harder)' );
+	t.strictEqual( str, 'b!bbeepp?*', 'returns centered string (harder)' );
 
 	t.end();
 });
@@ -204,13 +204,13 @@ tape( 'by default, the function centers an input string left in the event of a t
 		'lpad': 'b',
 		'rpad': 'p'
 	});
-	t.equal( str, 'bbbbeeppppp', 'returns left centered string (simple)' );
+	t.strictEqual( str, 'bbbbeeppppp', 'returns left centered string (simple)' );
 
 	str = pad( 'beep', 11, {
 		'lpad': 'b!',
 		'rpad': 'p?*'
 	});
-	t.equal( str, 'b!bbeepp?*p', 'returns left centered string (harder)' );
+	t.strictEqual( str, 'b!bbeepp?*p', 'returns left centered string (harder)' );
 
 	t.end();
 });
@@ -223,14 +223,14 @@ tape( 'the function supports centering an input string to the right in the event
 		'rpad': 'p',
 		'centerRight': true
 	});
-	t.equal( str, 'bbbbbeepppp', 'returns right centered string (simple)' );
+	t.strictEqual( str, 'bbbbbeepppp', 'returns right centered string (simple)' );
 
 	str = pad( 'beep', 11, {
 		'lpad': 'b!',
 		'rpad': 'p?*',
 		'centerRight': true
 	});
-	t.equal( str, 'b!b!beepp?*', 'returns right centered string (harder)' );
+	t.strictEqual( str, 'b!b!beepp?*', 'returns right centered string (harder)' );
 
 	t.end();
 });
@@ -242,50 +242,50 @@ tape( 'if the specified string length is less than or equal to the input string
 	str = pad( 'beep', 2, {
 		'rpad': 'boop'
 	});
-	t.equal( str, 'be', 'returns trimmed input string (right padded; <)' );
+	t.strictEqual( str, 'be', 'returns trimmed input string (right padded; <)' );
 
 	str = pad( 'beep', 4, {
 		'rpad': 'boop'
 	});
-	t.equal( str, 'beep', 'returns input string (right padded; =)' );
+	t.strictEqual( str, 'beep', 'returns input string (right padded; =)' );
 
 	// Left padded:
 	str = pad( 'beep', 2, {
 		'lpad': 'boop'
 	});
-	t.equal( str, 'ep', 'returns trimmed input string (left padded; <)' );
+	t.strictEqual( str, 'ep', 'returns trimmed input string (left padded; <)' );
 
 	str = pad( 'beep', 4, {
 		'lpad': 'boop'
 	});
-	t.equal( str, 'beep', 'returns input string (left padded; =)' );
+	t.strictEqual( str, 'beep', 'returns input string (left padded; =)' );
 
 	// Centered:
 	str = pad( 'beep', 2, {
 		'rpad': 'p',
 		'lpad': 'boop'
 	});
-	t.equal( str, 'ee', 'returns trimmed input string (center; <)' );
+	t.strictEqual( str, 'ee', 'returns trimmed input string (center; <)' );
 
 	str = pad( 'beep', 4, {
 		'lpad': 'boop',
 		'rpad': 'p'
 	});
-	t.equal( str, 'beep', 'returns input string (center; =)' );
+	t.strictEqual( str, 'beep', 'returns input string (center; =)' );
 
 	// Centered left/right:
 	str = pad( 'abcdef', 3, {
 		'lpad': '@',
 		'rpad': '!'
 	});
-	t.equal( str, 'cde', 'returns input string (center right; <)' );
+	t.strictEqual( str, 'cde', 'returns input string (center right; <)' );
 
 	str = pad( 'abcdef', 3, {
 		'lpad': '@',
 		'rpad': '!',
 		'centerRight': true
 	});
-	t.equal( str, 'bcd', 'returns input string (center left; <)' );
+	t.strictEqual( str, 'bcd', 'returns input string (center left; <)' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/pad/test/test.validate.js b/lib/node_modules/@stdlib/string/pad/test/test.validate.js
index 81a90cf098ef..aed58f2b7219 100644
--- a/lib/node_modules/@stdlib/string/pad/test/test.validate.js
+++ b/lib/node_modules/@stdlib/string/pad/test/test.validate.js
@@ -143,10 +143,10 @@ tape( 'if all options are valid, the function returns null', function test( t )
 	};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( opts.lpad, options.lpad, 'sets the `lpad` option' );
-	t.equal( opts.rpad, options.rpad, 'sets the `rpad` option' );
-	t.equal( opts.centerRight, options.centerRight, 'sets the `centerRight` option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( opts.lpad, options.lpad, 'sets the `lpad` option' );
+	t.strictEqual( opts.rpad, options.rpad, 'sets the `rpad` option' );
+	t.strictEqual( opts.centerRight, options.centerRight, 'sets the `centerRight` option' );
 
 	t.end();
 });
@@ -157,6 +157,6 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 		'a': null,
 		'b': 5
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/remove-punctuation/test/test.js b/lib/node_modules/@stdlib/string/remove-punctuation/test/test.js
index e4524bdbe71f..fa052d493d59 100644
--- a/lib/node_modules/@stdlib/string/remove-punctuation/test/test.js
+++ b/lib/node_modules/@stdlib/string/remove-punctuation/test/test.js
@@ -60,7 +60,7 @@ tape( 'the function throws an error if not provided a string', function test( t
 });
 
 tape( 'the function returns an empty string if provided an empty string', function test( t ) {
-	t.equal( removePunctuation( '' ), '', 'returns empty string' );
+	t.strictEqual( removePunctuation( '' ), '', 'returns empty string' );
 	t.end();
 });
 
@@ -70,19 +70,19 @@ tape( 'the function removes punctuation characters from a string', function test
 
 	out = removePunctuation( 'Hello, Sir!' );
 	expected = 'Hello Sir';
-	t.equal( out, expected, 'removes punctuation' );
+	t.strictEqual( out, expected, 'removes punctuation' );
 
 	out = removePunctuation( '"Too little, too late", he said to me...' );
 	expected = 'Too little too late he said to me';
-	t.equal( out, expected, 'removes punctuation' );
+	t.strictEqual( out, expected, 'removes punctuation' );
 
 	out = removePunctuation( 'We don\'t need no education, we don\'t need no thought control' );
 	expected = 'We dont need no education we dont need no thought control';
-	t.equal( out, expected, 'removes punctuation' );
+	t.strictEqual( out, expected, 'removes punctuation' );
 
 	out = removePunctuation( 'Sun Tzu said: "A leader leads by example not by force."' );
 	expected = 'Sun Tzu said A leader leads by example not by force';
-	t.equal( out, expected, 'removes punctuation' );
+	t.strictEqual( out, expected, 'removes punctuation' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/remove-utf8-bom/test/test.js b/lib/node_modules/@stdlib/string/remove-utf8-bom/test/test.js
index 41ebddbb59c4..f5cfbf14efce 100644
--- a/lib/node_modules/@stdlib/string/remove-utf8-bom/test/test.js
+++ b/lib/node_modules/@stdlib/string/remove-utf8-bom/test/test.js
@@ -64,11 +64,11 @@ tape( 'the function removes a UTF-8 byte order mark (BOM) from the beginning of
 	var str;
 
 	str = removeUTF8BOM( '\ufeffbeep' );
-	t.equal( str, 'beep', 'returns beep' );
+	t.strictEqual( str, 'beep', 'returns beep' );
 
 	str = string2buffer( '\ufeffboop' ).toString();
 	str = removeUTF8BOM( str );
-	t.equal( str, 'boop', 'returns boop' );
+	t.strictEqual( str, 'boop', 'returns boop' );
 
 	t.end();
 });
@@ -77,16 +77,16 @@ tape( 'the function ignores zero-width non-breaking spaces (Unicode) occurring e
 	var str;
 
 	str = removeUTF8BOM( 'boop\ufeff' );
-	t.equal( str, 'boop\ufeff', 'returns boop\ufeff' );
+	t.strictEqual( str, 'boop\ufeff', 'returns boop\ufeff' );
 
 	str = removeUTF8BOM( 'be\ufeffbop' );
-	t.equal( str, 'be\ufeffbop', 'returns be\ufeffbop' );
+	t.strictEqual( str, 'be\ufeffbop', 'returns be\ufeffbop' );
 
 	t.end();
 });
 
 tape( 'if a string does not begin with a BOM, the function returns the input string unchanged', function test( t ) {
 	var str = removeUTF8BOM( 'foobar' );
-	t.equal( str, 'foobar', 'returns foobar' );
+	t.strictEqual( str, 'foobar', 'returns foobar' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/remove-words/test/test.js b/lib/node_modules/@stdlib/string/remove-words/test/test.js
index e73c8fee2b91..97015785ac79 100644
--- a/lib/node_modules/@stdlib/string/remove-words/test/test.js
+++ b/lib/node_modules/@stdlib/string/remove-words/test/test.js
@@ -115,7 +115,7 @@ tape( 'if provided a third argument that is not a boolean primitive, the functio
 });
 
 tape( 'the function returns an empty string if provided an empty string', function test( t ) {
-	t.equal( removeWords( '', [ 'beep' ] ), '', 'returns empty string' );
+	t.strictEqual( removeWords( '', [ 'beep' ] ), '', 'returns empty string' );
 	t.end();
 });
 
@@ -129,19 +129,19 @@ tape( 'the function removes a list of words from a string (case-sensitive)', fun
 	words = [ 'all', 'noble' ];
 	out = removeWords( str, words );
 	expected = 'A  craft, but somehow a most melancholy! All  things are touched with that.';
-	t.equal( out, expected, 'removes words' );
+	t.strictEqual( out, expected, 'removes words' );
 
 	str = 'Even though I walk through the valley of the shadow of death, I fear no evil';
 	words = [ 'death', 'i', 'of' ];
 	out = removeWords( str, words );
 	expected = 'Even though I walk through the valley  the shadow  , I fear no evil';
-	t.equal( out, expected, 'removes words' );
+	t.strictEqual( out, expected, 'removes words' );
 
 	str = 'You, you will see no more the pain I suffered, all the pain I caused!';
 	words = [ 'pain', 'you' ];
 	out = removeWords( str, words );
 	expected = 'You,  will see no more the  I suffered, all the  I caused!';
-	t.equal( out, expected, 'removes words' );
+	t.strictEqual( out, expected, 'removes words' );
 
 	t.end();
 });
@@ -156,18 +156,18 @@ tape( 'the function removes a list of words from a string (case-insensitive)', f
 	words = [ 'all', 'noble' ];
 	out = removeWords( str, words, true );
 	expected = 'A  craft, but somehow a most melancholy!   things are touched with that.';
-	t.equal( out, expected, 'removes words' );
+	t.strictEqual( out, expected, 'removes words' );
 
 	str = 'Even though I walk through the valley of the shadow of death, I fear no evil';
 	words = [ 'death', 'i', 'of' ];
 	out = removeWords( str, words, true );
 	expected = 'Even though  walk through the valley  the shadow  ,  fear no evil';
-	t.equal( out, expected, 'removes words' );
+	t.strictEqual( out, expected, 'removes words' );
 
 	str = 'You, you will see no more the pain I suffered, all the pain I caused!';
 	words = [ 'pain', 'you' ];
 	out = removeWords( str, words, true );
 	expected = ',  will see no more the  I suffered, all the  I caused!';
-	t.equal( out, expected, 'removes words' );
+	t.strictEqual( out, expected, 'removes words' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/repeat/test/test.js b/lib/node_modules/@stdlib/string/repeat/test/test.js
index 08646afb43cc..ffb3a0974940 100644
--- a/lib/node_modules/@stdlib/string/repeat/test/test.js
+++ b/lib/node_modules/@stdlib/string/repeat/test/test.js
@@ -100,20 +100,20 @@ tape( 'the function repeats an input string a specified number of times', functi
 	var str;
 
 	str = repeat( 'a', 5 );
-	t.equal( str, 'aaaaa', 'repeated 5 times' );
+	t.strictEqual( str, 'aaaaa', 'repeated 5 times' );
 
 	str = repeat( 'beep', 2 );
-	t.equal( str, 'beepbeep', 'repeated 2 times' );
+	t.strictEqual( str, 'beepbeep', 'repeated 2 times' );
 
 	t.end();
 });
 
 tape( 'if provided an empty string, the function returns an empty string', function test( t ) {
-	t.equal( repeat( '', 100 ), '', 'returns an empty string' );
+	t.strictEqual( repeat( '', 100 ), '', 'returns an empty string' );
 	t.end();
 });
 
 tape( 'if repeat number is 0, the function returns an empty string', function test( t ) {
-	t.equal( repeat( 'a', 0 ), '', 'returns empty string' );
+	t.strictEqual( repeat( 'a', 0 ), '', 'returns empty string' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/replace/test/test.js b/lib/node_modules/@stdlib/string/replace/test/test.js
index d0a4242049c5..b3f2a9542079 100644
--- a/lib/node_modules/@stdlib/string/replace/test/test.js
+++ b/lib/node_modules/@stdlib/string/replace/test/test.js
@@ -120,13 +120,13 @@ tape( 'the function replaces all occurrences of a string search value', function
 	var out;
 
 	out = replace( 'abc abc abc', 'b', '' );
-	t.equal( out, 'ac ac ac', 'returns expected value' );
+	t.strictEqual( out, 'ac ac ac', 'returns expected value' );
 
 	out = replace( 'abc abc abc', 'b', 'cd' );
-	t.equal( out, 'acdc acdc acdc', 'returns expected value' );
+	t.strictEqual( out, 'acdc acdc acdc', 'returns expected value' );
 
 	out = replace( 'Et tu, Brute?', 'Brute?', 'Caesar?' );
-	t.equal( out, 'Et tu, Caesar?', 'returns expected value' );
+	t.strictEqual( out, 'Et tu, Caesar?', 'returns expected value' );
 
 	t.end();
 });
@@ -137,11 +137,11 @@ tape( 'the function replaces matches of a regular expression', function test( t
 
 	out = replace( 'aBcDeFgHiJkLmNoPqRsTuVwXYZ', /[A-Z]+/, '' );
 	expected = 'acDeFgHiJkLmNoPqRsTuVwXYZ';
-	t.equal( out, expected, 'replaces letters matching the regular expression (first occurrence)' );
+	t.strictEqual( out, expected, 'replaces letters matching the regular expression (first occurrence)' );
 
 	out = replace( 'aBcDeFgHiJkLmNoPqRsTuVwXYZ', /[A-Z]+/g, '' );
 	expected = 'acegikmoqsuw';
-	t.equal( out, expected, 'replaces letters matching the regular expression (global)' );
+	t.strictEqual( out, expected, 'replaces letters matching the regular expression (global)' );
 
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function replaces matches with values returned by a replacer function
 	out = replace( str, /([^\s]+)/gi, replacer );
 
 	expected = '/Oranges/ /and/ /lemons/ /say/ /the/ /bells/ /of/ /St./ /Clement\'s/';
-	t.equal( out, expected, 'replaces matches using replacer function' );
+	t.strictEqual( out, expected, 'replaces matches using replacer function' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/string/right-pad/test/test.js b/lib/node_modules/@stdlib/string/right-pad/test/test.js
index 4a8c7e67d541..cd4ef1ad5225 100644
--- a/lib/node_modules/@stdlib/string/right-pad/test/test.js
+++ b/lib/node_modules/@stdlib/string/right-pad/test/test.js
@@ -130,24 +130,24 @@ tape( 'if provided an empty pad string, the function throws an error', function
 
 tape( 'by default, the function right pads a string with spaces', function test( t ) {
 	var str = rpad( 'a', 5 );
-	t.equal( str, 'a    ', 'right padded with spaces' );
+	t.strictEqual( str, 'a    ', 'right padded with spaces' );
 	t.end();
 });
 
 tape( 'the function supports right padding a string with a custom pad string', function test( t ) {
 	var str = rpad( 'beep', 10, 'p' );
-	t.equal( str, 'beeppppppp', 'right padded to desired length' );
+	t.strictEqual( str, 'beeppppppp', 'right padded to desired length' );
 	t.end();
 });
 
 tape( 'the function right pads a string such that an output string may exceed the specified length (minimum bound)', function test( t ) {
 	var str = rpad( 'a', 5, 'beepboop' );
-	t.equal( str, 'abeepboop', 'right padded and length exceeds minimum length' );
+	t.strictEqual( str, 'abeepboop', 'right padded and length exceeds minimum length' );
 	t.end();
 });
 
 tape( 'if the specified string length is less than or equal to the input string length, the function returns the input string', function test( t ) {
-	t.equal( rpad( 'beep', 2, 'boop' ), 'beep', 'returns input string (<)' );
-	t.equal( rpad( 'beep', 4, 'boop' ), 'beep', 'returns input string (=)' );
+	t.strictEqual( rpad( 'beep', 2, 'boop' ), 'beep', 'returns input string (<)' );
+	t.strictEqual( rpad( 'beep', 4, 'boop' ), 'beep', 'returns input string (=)' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/right-trim/test/test.js b/lib/node_modules/@stdlib/string/right-trim/test/test.js
index c839f645cef1..679b51469981 100644
--- a/lib/node_modules/@stdlib/string/right-trim/test/test.js
+++ b/lib/node_modules/@stdlib/string/right-trim/test/test.js
@@ -66,107 +66,107 @@ tape( 'the function removes all whitespace characters at the end of a string', f
 
 	expected = '   Whitespace';
 	actual = rtrim( '   Whitespace   ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = '\t\t\tTabs';
 	actual = rtrim( '\t\t\tTabs\t\t\t' );
-	t.equal( actual, expected, 'removes all tabs' );
+	t.strictEqual( actual, expected, 'removes all tabs' );
 
 	expected = '\n\n\nNew Lines';
 	actual = rtrim( '\n\n\nNew Lines\n\n\n' );
-	t.equal( actual, expected, 'removes all newline characters' );
+	t.strictEqual( actual, expected, 'removes all newline characters' );
 
 	expected = ' \r\n \tBeep';
 	actual = rtrim( ' \r\n \tBeep \r\n\t' );
-	t.equal( actual, expected, 'removes all whitespace characters' );
+	t.strictEqual( actual, expected, 'removes all whitespace characters' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\f' );
-	t.equal( actual, expected, 'removes \\f' );
+	t.strictEqual( actual, expected, 'removes \\f' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\n' );
-	t.equal( actual, expected, 'removes \\n' );
+	t.strictEqual( actual, expected, 'removes \\n' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\t' );
-	t.equal( actual, expected, 'removes \\t' );
+	t.strictEqual( actual, expected, 'removes \\t' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\v' );
-	t.equal( actual, expected, 'removes \\v' );
+	t.strictEqual( actual, expected, 'removes \\v' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u1680' );
-	t.equal( actual, expected, 'removes \\u1680' );
+	t.strictEqual( actual, expected, 'removes \\u1680' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2000' );
-	t.equal( actual, expected, 'removes \\u2000' );
+	t.strictEqual( actual, expected, 'removes \\u2000' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2001' );
-	t.equal( actual, expected, 'removes \\u2001' );
+	t.strictEqual( actual, expected, 'removes \\u2001' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2002' );
-	t.equal( actual, expected, 'removes \\u2002' );
+	t.strictEqual( actual, expected, 'removes \\u2002' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2003' );
-	t.equal( actual, expected, 'removes \\u2003' );
+	t.strictEqual( actual, expected, 'removes \\u2003' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2004' );
-	t.equal( actual, expected, 'removes \\u2004' );
+	t.strictEqual( actual, expected, 'removes \\u2004' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2005' );
-	t.equal( actual, expected, 'removes \\u2005' );
+	t.strictEqual( actual, expected, 'removes \\u2005' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2006' );
-	t.equal( actual, expected, 'removes \\u2006' );
+	t.strictEqual( actual, expected, 'removes \\u2006' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2007' );
-	t.equal( actual, expected, 'removes \\u2007' );
+	t.strictEqual( actual, expected, 'removes \\u2007' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2008' );
-	t.equal( actual, expected, 'removes \\u2008' );
+	t.strictEqual( actual, expected, 'removes \\u2008' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2009' );
-	t.equal( actual, expected, 'removes \\u2009' );
+	t.strictEqual( actual, expected, 'removes \\u2009' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u200a' );
-	t.equal( actual, expected, 'removes \\u200a' );
+	t.strictEqual( actual, expected, 'removes \\u200a' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2028' );
-	t.equal( actual, expected, 'removes \\u2028' );
+	t.strictEqual( actual, expected, 'removes \\u2028' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u2029' );
-	t.equal( actual, expected, 'removes \\u2029' );
+	t.strictEqual( actual, expected, 'removes \\u2029' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u202f' );
-	t.equal( actual, expected, 'removes \\u202f' );
+	t.strictEqual( actual, expected, 'removes \\u202f' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u205f' );
-	t.equal( actual, expected, 'removes \\u205f' );
+	t.strictEqual( actual, expected, 'removes \\u205f' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\u3000' );
-	t.equal( actual, expected, 'removes \\u3000' );
+	t.strictEqual( actual, expected, 'removes \\u3000' );
 
 	expected = 'beep';
 	actual = rtrim( 'beep\ufeff' );
-	t.equal( actual, expected, 'removes \\ufefff' );
+	t.strictEqual( actual, expected, 'removes \\ufefff' );
 
 	t.end();
 });
@@ -177,7 +177,7 @@ tape( 'the function does not trim the Mongolian space separator in accordance wi
 
 	expected = 'beep\u180e';
 	actual = rtrim( 'beep\u180e' );
-	t.equal( actual, expected, 'does not remove \\u180e' );
+	t.strictEqual( actual, expected, 'does not remove \\u180e' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/test/test.js b/lib/node_modules/@stdlib/string/test/test.js
index b8fe1db33b94..31b69b182536 100644
--- a/lib/node_modules/@stdlib/string/test/test.js
+++ b/lib/node_modules/@stdlib/string/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains string manipulation functionality', function test( t ) {
 	var keys = objectKeys( string );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator-right/test/test.js b/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator-right/test/test.js
index 607c7a30eb18..778bfff1c35f 100644
--- a/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator-right/test/test.js
+++ b/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator-right/test/test.js
@@ -250,14 +250,14 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	expected = grev( expected.length-1, expected, 1 );
 
 	it = graphemeClusters2iteratorRight( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'string', 'returns a string' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'string', 'returns a string' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -281,14 +281,14 @@ tape( 'the function returns an iterator protocol-compliant object (empty string)
 	];
 
 	it = graphemeClusters2iteratorRight( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'string', 'returns a string' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'string', 'returns a string' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -306,19 +306,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = 'beep';
 
 	it = graphemeClusters2iteratorRight( values, transform );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -339,19 +339,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = '';
 
 	it = graphemeClusters2iteratorRight( values, transform );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -369,20 +369,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = graphemeClusters2iteratorRight( 'beep' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -394,20 +394,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = graphemeClusters2iteratorRight( 'beep', transform );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -423,20 +423,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = graphemeClusters2iteratorRight( 'beep' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -448,20 +448,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = graphemeClusters2iteratorRight( 'beep', transform );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -484,16 +484,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = 'beep';
 
 	it1 = graphemeClusters2iteratorRight( values );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -512,16 +512,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = 'beep';
 
 	it1 = graphemeClusters2iteratorRight( values, transform );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -539,7 +539,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = graphemeClusters2iteratorRight( 'beep' );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -553,7 +553,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = graphemeClusters2iteratorRight( 'beep', transform );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator/test/test.js b/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator/test/test.js
index b77ec49da3eb..0f7218a5b287 100644
--- a/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator/test/test.js
@@ -248,14 +248,14 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	];
 
 	it = graphemeClusters2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'string', 'returns a string' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'string', 'returns a string' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -279,14 +279,14 @@ tape( 'the function returns an iterator protocol-compliant object (empty string)
 	];
 
 	it = graphemeClusters2iterator( values );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.equal( typeof r.value, 'string', 'returns a string' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'string', 'returns a string' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	actual.push( it.next() );
 
@@ -304,19 +304,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = 'beep';
 
 	it = graphemeClusters2iterator( values, transform );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -337,19 +337,19 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	values = '';
 
 	it = graphemeClusters2iterator( values, transform );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, values.length, 'has expected length' );
+	t.strictEqual( expected.length, values.length, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -367,20 +367,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = graphemeClusters2iterator( 'beep' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -392,20 +392,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = graphemeClusters2iterator( 'beep', transform );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -421,20 +421,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = graphemeClusters2iterator( 'beep' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -446,20 +446,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = graphemeClusters2iterator( 'beep', transform );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'string', 'returns a string' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -482,16 +482,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = 'beep';
 
 	it1 = graphemeClusters2iterator( values );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -510,16 +510,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	values = 'beep';
 
 	it1 = graphemeClusters2iterator( values, transform );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -537,7 +537,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = graphemeClusters2iterator( 'beep' );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -551,7 +551,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = graphemeClusters2iterator( 'beep', transform );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/string/to-well-formed/test/test.js b/lib/node_modules/@stdlib/string/to-well-formed/test/test.js
index 76c914feff27..57aecc804188 100644
--- a/lib/node_modules/@stdlib/string/to-well-formed/test/test.js
+++ b/lib/node_modules/@stdlib/string/to-well-formed/test/test.js
@@ -33,14 +33,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a well-formed string by replacing lone surrogates with Unicode replacement character', function test( t ) {
-	t.equal( str2wellformed(''), '', 'returns an empty string for an empty input' );
-	t.equal( str2wellformed('\uDBFF'), '�', 'replaces lone high surrogate with Unicode replacement character' );
-	t.equal( str2wellformed('\uDBFFFF\uDBFF'), '�FF�', 'replaces multiple lone surrogates with Unicode replacement characters' );
-	t.equal( str2wellformed('Hello \uDBFFWorld'), 'Hello �World', 'replaces lone high surrogate in a string with Unicode replacement character' );
-	t.equal( str2wellformed('\uDBFF'), '�', 'replaces lone high surrogate with Unicode replacement character' );
-	t.equal( str2wellformed('\uDBFFFFF'), '�FFF', 'replaces lone high surrogate with Unicode replacement character' );
-	t.equal( str2wellformed('\uDC00\uDC00'), '��', 'replaces lone low surrogate with Unicode replacement character' );
-	t.equal( str2wellformed('5\uDBFF'), '5�', 'replaces lone high surrogate with Unicode replacement character' );
+	t.strictEqual( str2wellformed(''), '', 'returns an empty string for an empty input' );
+	t.strictEqual( str2wellformed('\uDBFF'), '�', 'replaces lone high surrogate with Unicode replacement character' );
+	t.strictEqual( str2wellformed('\uDBFFFF\uDBFF'), '�FF�', 'replaces multiple lone surrogates with Unicode replacement characters' );
+	t.strictEqual( str2wellformed('Hello \uDBFFWorld'), 'Hello �World', 'replaces lone high surrogate in a string with Unicode replacement character' );
+	t.strictEqual( str2wellformed('\uDBFF'), '�', 'replaces lone high surrogate with Unicode replacement character' );
+	t.strictEqual( str2wellformed('\uDBFFFFF'), '�FFF', 'replaces lone high surrogate with Unicode replacement character' );
+	t.strictEqual( str2wellformed('\uDC00\uDC00'), '��', 'replaces lone low surrogate with Unicode replacement character' );
+	t.strictEqual( str2wellformed('5\uDBFF'), '5�', 'replaces lone high surrogate with Unicode replacement character' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/tools/grapheme-cluster-break/test/test.js b/lib/node_modules/@stdlib/string/tools/grapheme-cluster-break/test/test.js
index d565cf2af605..b0d1b642233d 100644
--- a/lib/node_modules/@stdlib/string/tools/grapheme-cluster-break/test/test.js
+++ b/lib/node_modules/@stdlib/string/tools/grapheme-cluster-break/test/test.js
@@ -35,21 +35,21 @@ tape( 'main export is an object', function test( t ) {
 });
 
 tape( 'the exported object contains a `emojiProperty` method which is a function', function test( t ) {
-	t.equal( isFunction( grapheme.emojiProperty ), true, 'has function' );
+	t.strictEqual( isFunction( grapheme.emojiProperty ), true, 'has function' );
 	t.end();
 });
 
 tape( 'the exported object contains a `breakProperty` method which is a function', function test( t ) {
-	t.equal( isFunction( grapheme.breakProperty ), true, 'has function' );
+	t.strictEqual( isFunction( grapheme.breakProperty ), true, 'has function' );
 	t.end();
 });
 
 tape( 'the exported object contains a `breakType` method which is a function', function test( t ) {
-	t.equal( isFunction( grapheme.breakType ), true, 'has function' );
+	t.strictEqual( isFunction( grapheme.breakType ), true, 'has function' );
 	t.end();
 });
 
 tape( 'the exported object contains a `constants` object mapping break type names to integers', function test( t ) {
-	t.equal( isPlainObject( grapheme.constants ), true, 'is an object' );
+	t.strictEqual( isPlainObject( grapheme.constants ), true, 'is an object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/tools/test/test.js b/lib/node_modules/@stdlib/string/tools/test/test.js
index 27f3e44b82db..277e7766bd60 100644
--- a/lib/node_modules/@stdlib/string/tools/test/test.js
+++ b/lib/node_modules/@stdlib/string/tools/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains string utility tools', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/trim/test/test.js b/lib/node_modules/@stdlib/string/trim/test/test.js
index 00a12711a854..4a2c4c88823e 100644
--- a/lib/node_modules/@stdlib/string/trim/test/test.js
+++ b/lib/node_modules/@stdlib/string/trim/test/test.js
@@ -66,131 +66,131 @@ tape( 'the function removes all whitespace characters at the beginning and end o
 
 	expected = 'Whitespace';
 	actual = trim( '   Whitespace   ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'beep';
 	actual = trim( '    beep' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'boop';
 	actual = trim( 'boop        ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'foo foo';
 	actual = trim( '   foo foo     ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = '# bar bar bar';
 	actual = trim( '# bar bar bar    ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = '# beep boop';
 	actual = trim( '         # beep boop' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'foo \n\n\n\n foo';
 	actual = trim( '   foo \n\n\n\n foo     ' );
-	t.equal( actual, expected, 'removes all spaces' );
+	t.strictEqual( actual, expected, 'removes all spaces' );
 
 	expected = 'Tabs';
 	actual = trim( '\t\t\tTabs\t\t\t' );
-	t.equal( actual, expected, 'removes all tabs' );
+	t.strictEqual( actual, expected, 'removes all tabs' );
 
 	expected = 'New Lines';
 	actual = trim( '\n\n\nNew Lines\n\n\n' );
-	t.equal( actual, expected, 'removes all newline characters' );
+	t.strictEqual( actual, expected, 'removes all newline characters' );
 
 	expected = 'Beep';
 	actual = trim( ' \r\n\tBeep \r\n\t' );
-	t.equal( actual, expected, 'removes all whitespace characters' );
+	t.strictEqual( actual, expected, 'removes all whitespace characters' );
 
 	expected = 'beep';
 	actual = trim( '\fbeep\f' );
-	t.equal( actual, expected, 'removes \\f' );
+	t.strictEqual( actual, expected, 'removes \\f' );
 
 	expected = 'beep';
 	actual = trim( '\nbeep\n' );
-	t.equal( actual, expected, 'removes \\n' );
+	t.strictEqual( actual, expected, 'removes \\n' );
 
 	expected = 'beep';
 	actual = trim( '\tbeep\t' );
-	t.equal( actual, expected, 'removes \\t' );
+	t.strictEqual( actual, expected, 'removes \\t' );
 
 	expected = 'beep';
 	actual = trim( '\vbeep\v' );
-	t.equal( actual, expected, 'removes \\v' );
+	t.strictEqual( actual, expected, 'removes \\v' );
 
 	expected = 'beep';
 	actual = trim( '\u1680beep\u1680' );
-	t.equal( actual, expected, 'removes \\u1680' );
+	t.strictEqual( actual, expected, 'removes \\u1680' );
 
 	expected = 'beep';
 	actual = trim( '\u2000beep\u2000' );
-	t.equal( actual, expected, 'removes \\u2000' );
+	t.strictEqual( actual, expected, 'removes \\u2000' );
 
 	expected = 'beep';
 	actual = trim( '\u2001beep\u2001' );
-	t.equal( actual, expected, 'removes \\u2001' );
+	t.strictEqual( actual, expected, 'removes \\u2001' );
 
 	expected = 'beep';
 	actual = trim( '\u2002beep\u2002' );
-	t.equal( actual, expected, 'removes \\u2002' );
+	t.strictEqual( actual, expected, 'removes \\u2002' );
 
 	expected = 'beep';
 	actual = trim( '\u2003beep\u2003' );
-	t.equal( actual, expected, 'removes \\u2003' );
+	t.strictEqual( actual, expected, 'removes \\u2003' );
 
 	expected = 'beep';
 	actual = trim( '\u2004beep\u2004' );
-	t.equal( actual, expected, 'removes \\u2004' );
+	t.strictEqual( actual, expected, 'removes \\u2004' );
 
 	expected = 'beep';
 	actual = trim( '\u2005beep\u2005' );
-	t.equal( actual, expected, 'removes \\u2005' );
+	t.strictEqual( actual, expected, 'removes \\u2005' );
 
 	expected = 'beep';
 	actual = trim( '\u2006beep\u2006' );
-	t.equal( actual, expected, 'removes \\u2006' );
+	t.strictEqual( actual, expected, 'removes \\u2006' );
 
 	expected = 'beep';
 	actual = trim( '\u2007beep\u2007' );
-	t.equal( actual, expected, 'removes \\u2007' );
+	t.strictEqual( actual, expected, 'removes \\u2007' );
 
 	expected = 'beep';
 	actual = trim( '\u2008beep\u2008' );
-	t.equal( actual, expected, 'removes \\u2008' );
+	t.strictEqual( actual, expected, 'removes \\u2008' );
 
 	expected = 'beep';
 	actual = trim( '\u2009beep\u2009' );
-	t.equal( actual, expected, 'removes \\u2009' );
+	t.strictEqual( actual, expected, 'removes \\u2009' );
 
 	expected = 'beep';
 	actual = trim( '\u200abeep\u200a' );
-	t.equal( actual, expected, 'removes \\u200a' );
+	t.strictEqual( actual, expected, 'removes \\u200a' );
 
 	expected = 'beep';
 	actual = trim( '\u2028beep\u2028' );
-	t.equal( actual, expected, 'removes \\u2028' );
+	t.strictEqual( actual, expected, 'removes \\u2028' );
 
 	expected = 'beep';
 	actual = trim( '\u2029beep\u2029' );
-	t.equal( actual, expected, 'removes \\u2029' );
+	t.strictEqual( actual, expected, 'removes \\u2029' );
 
 	expected = 'beep';
 	actual = trim( '\u202fbeep\u202f' );
-	t.equal( actual, expected, 'removes \\u202f' );
+	t.strictEqual( actual, expected, 'removes \\u202f' );
 
 	expected = 'beep';
 	actual = trim( '\u205fbeep\u205f' );
-	t.equal( actual, expected, 'removes \\u205f' );
+	t.strictEqual( actual, expected, 'removes \\u205f' );
 
 	expected = 'beep';
 	actual = trim( '\u3000beep\u3000' );
-	t.equal( actual, expected, 'removes \\u3000' );
+	t.strictEqual( actual, expected, 'removes \\u3000' );
 
 	expected = 'beep';
 	actual = trim( '\ufeffbeep\ufeff' );
-	t.equal( actual, expected, 'removes \\ufefff' );
+	t.strictEqual( actual, expected, 'removes \\ufefff' );
 
 	t.end();
 });
@@ -201,7 +201,7 @@ tape( 'the function does not remove the Mongolian space separator in accordance
 
 	expected = '\u180ebeep\u180e';
 	actual = trim( '\u180ebeep\u180e' );
-	t.equal( actual, expected, 'does not remove \\u180e' );
+	t.strictEqual( actual, expected, 'does not remove \\u180e' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/uncapitalize/test/test.js b/lib/node_modules/@stdlib/string/uncapitalize/test/test.js
index 8cc1a1619ce7..b826392edc69 100644
--- a/lib/node_modules/@stdlib/string/uncapitalize/test/test.js
+++ b/lib/node_modules/@stdlib/string/uncapitalize/test/test.js
@@ -61,7 +61,7 @@ tape( 'the function throws an error if not provided a string', function test( t
 });
 
 tape( 'the function returns an empty string if provided an empty string', function test( t ) {
-	t.equal( uncapitalize( '' ), '', 'returns empty string' );
+	t.strictEqual( uncapitalize( '' ), '', 'returns empty string' );
 	t.end();
 });
 
@@ -69,13 +69,13 @@ tape( 'the function converts the first character of an input string to lowercase
 	var out;
 
 	out = uncapitalize( 'Hello world' );
-	t.equal( out, 'hello world', 'uncapitalizes first character' );
+	t.strictEqual( out, 'hello world', 'uncapitalizes first character' );
 
 	out = uncapitalize( '!!!' );
-	t.equal( out, '!!!', 'does not change non-alphabetical characters' );
+	t.strictEqual( out, '!!!', 'does not change non-alphabetical characters' );
 
 	out = uncapitalize( 'hello World' );
-	t.equal( out, 'hello World', 'leaves lowercase letters in lowercase' );
+	t.strictEqual( out, 'hello World', 'leaves lowercase letters in lowercase' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/uppercase/test/test.js b/lib/node_modules/@stdlib/string/uppercase/test/test.js
index c87505fe0b9a..4020b6c0ceaa 100644
--- a/lib/node_modules/@stdlib/string/uppercase/test/test.js
+++ b/lib/node_modules/@stdlib/string/uppercase/test/test.js
@@ -85,7 +85,7 @@ tape( 'the function converts a string to uppercase', function test( t ) {
 	];
 	for ( i = 0; i < values.length; i++ ) {
 		actual = uppercase( values[i] );
-		t.equal( actual, expected[i], 'converts string to '+expected[i] );
+		t.strictEqual( actual, expected[i], 'converts string to '+expected[i] );
 	}
 	t.end();
 });

From 474fc56c619e734d7718b1bda3e8c76e6353e657 Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Thu, 14 Aug 2025 12:47:53 -0500
Subject: [PATCH 08/32] test: fill arrays with undefined instead zero

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../array/to-sparse-iterator-right/test/test.js      | 12 ++++++------
 .../@stdlib/array/to-sparse-iterator/test/test.js    | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/lib/node_modules/@stdlib/array/to-sparse-iterator-right/test/test.js b/lib/node_modules/@stdlib/array/to-sparse-iterator-right/test/test.js
index 47a082fcb4ef..7770cc75274e 100644
--- a/lib/node_modules/@stdlib/array/to-sparse-iterator-right/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-sparse-iterator-right/test/test.js
@@ -24,7 +24,7 @@ var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
 var iteratorSymbol = require( '@stdlib/symbol/iterator' );
 var noop = require( '@stdlib/utils/noop' );
-var zeros = require( '@stdlib/array/base/zeros' );
+var filled = require( '@stdlib/array/base/filled' );
 var sparsearray2iteratorRight = require( './../lib' );
 
 
@@ -165,7 +165,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty array)'
 	var values;
 	var it;
 
-	values = zeros( 1e5 );
+	values = filled( void 0, 1e5 );
 	expected = [
 		{
 			'done': true
@@ -190,7 +190,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty end)',
 	var r;
 	var i;
 
-	values = zeros( 4 );
+	values = filled( void 0, 4 );
 
 	// Leave the last element empty:
 	for ( i = 0; i < values.length-1; i++ ) {
@@ -238,7 +238,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty start)'
 	var r;
 	var i;
 
-	values = zeros( 4 );
+	values = filled( void 0, 4 );
 
 	// Leave the first element empty:
 	for ( i = 1; i < values.length; i++ ) {
@@ -287,7 +287,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty start+e
 	var r;
 	var i;
 
-	values = zeros( 4 );
+	values = filled( void 0, 4 );
 
 	// Leave the first and last elements empty:
 	for ( i = 1; i < values.length-1; i++ ) {
@@ -379,7 +379,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	var r;
 	var i;
 
-	values = zeros( 4 );
+	values = filled( void 0, 4 );
 
 	// Leave the last element empty:
 	for ( i = 0; i < values.length-1; i++ ) {
diff --git a/lib/node_modules/@stdlib/array/to-sparse-iterator/test/test.js b/lib/node_modules/@stdlib/array/to-sparse-iterator/test/test.js
index e70a888a636f..85981549b1de 100644
--- a/lib/node_modules/@stdlib/array/to-sparse-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-sparse-iterator/test/test.js
@@ -24,7 +24,7 @@ var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
 var iteratorSymbol = require( '@stdlib/symbol/iterator' );
 var noop = require( '@stdlib/utils/noop' );
-var zeros = require( '@stdlib/array/base/zeros' );
+var filled = require( '@stdlib/array/base/filled' );
 var sparsearray2iterator = require( './../lib' );
 
 
@@ -165,7 +165,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty array)'
 	var values;
 	var it;
 
-	values = zeros( 1e5 );
+	values = filled( void 0, 1e5 );
 	expected = [
 		{
 			'done': true
@@ -190,7 +190,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty end)',
 	var r;
 	var i;
 
-	values = zeros( 4 );
+	values = filled( void 0, 4 );
 
 	// Leave the last element empty:
 	for ( i = 0; i < values.length-1; i++ ) {
@@ -238,7 +238,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty start)'
 	var r;
 	var i;
 
-	values = zeros( 4 );
+	values = filled( void 0, 4 );
 
 	// Leave the first element empty:
 	for ( i = 1; i < values.length; i++ ) {
@@ -287,7 +287,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty start+e
 	var r;
 	var i;
 
-	values = zeros( 4 );
+	values = filled( void 0, 4 );
 
 	// Leave the first and last elements empty:
 	for ( i = 1; i < values.length-1; i++ ) {
@@ -379,7 +379,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	var r;
 	var i;
 
-	values = zeros( 4 );
+	values = filled( void 0, 4 );
 
 	// Leave the last element empty:
 	for ( i = 0; i < values.length-1; i++ ) {

From b65c4fcdd14f2f62199a68d2e7159778a1fcb407 Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Thu, 14 Aug 2025 12:54:34 -0500
Subject: [PATCH 09/32] test: ensure no errors when gamma is not available

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../special/gamma/test/other/xtest.gamma.js   | 32 ++++++++++++-------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/lib/node_modules/@stdlib/math/base/special/gamma/test/other/xtest.gamma.js b/lib/node_modules/@stdlib/math/base/special/gamma/test/other/xtest.gamma.js
index b9f250d3210f..c5b5ec60198b 100644
--- a/lib/node_modules/@stdlib/math/base/special/gamma/test/other/xtest.gamma.js
+++ b/lib/node_modules/@stdlib/math/base/special/gamma/test/other/xtest.gamma.js
@@ -21,7 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
-var gamma = require( 'gamma' ); // eslint-disable-line stdlib/require-file-extensions
+var tryRequire = require( '@stdlib/utils/try-require' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var incrspace = require( '@stdlib/array/base/incrspace' );
 var abs = require( '@stdlib/math/base/special/abs' );
@@ -30,6 +30,14 @@ var PINF = require( '@stdlib/constants/float64/pinf' );
 var NINF = require( '@stdlib/constants/float64/ninf' );
 
 
+// VARIABLES //
+
+var gamma = tryRequire( 'gamma' );
+var opts = {
+	'skip': ( gamma instanceof Error )
+};
+
+
 // FIXTURES //
 
 var data1 = require( './../fixtures/r/data1.json' );
@@ -40,13 +48,13 @@ var expected2 = require( './../fixtures/r/expected2.json' );
 
 // TESTS //
 
-tape( 'main export is a function', function test( t ) {
+tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
 	t.strictEqual( typeof gamma, 'function', 'main export is a function' );
 	t.end();
 });
 
-tape( 'if provided a negative integer, the function returns `NaN`', function test( t ) {
+tape( 'if provided a negative integer, the function returns `NaN`', opts, function test( t ) {
 	var values = incrspace( -1.0, -1000.0, -1.0 );
 	var v;
 	var i;
@@ -58,31 +66,31 @@ tape( 'if provided a negative integer, the function returns `NaN`', function tes
 	t.end();
 });
 
-tape( 'if provided negative infinity, the function returns `NaN`', function test( t ) {
+tape( 'if provided negative infinity, the function returns `NaN`', opts, function test( t ) {
 	var v = gamma( NINF );
 	t.strictEqual( isnan( v ), true, 'returns NaN when provided negative infinity' );
 	t.end();
 });
 
-tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
+tape( 'if provided `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var v = gamma( NaN );
 	t.strictEqual( isnan( v ), true, 'returns NaN when provided a NaN' );
 	t.end();
 });
 
-tape( 'if provided `-0`, the function returns negative infinity', function test( t ) {
+tape( 'if provided `-0`, the function returns negative infinity', opts, function test( t ) {
 	var v = gamma( -0.0 );
 	t.strictEqual( v, NINF, 'returns -infinity' );
 	t.end();
 });
 
-tape( 'if provided `+0`, the function returns positive infinity', function test( t ) {
+tape( 'if provided `+0`, the function returns positive infinity', opts, function test( t ) {
 	var v = gamma( 0.0 );
 	t.strictEqual( v, PINF, 'returns +infinity' );
 	t.end();
 });
 
-tape( 'if `x > 171.6144...`, the function returns positive infinity', function test( t ) {
+tape( 'if `x > 171.6144...`, the function returns positive infinity', opts, function test( t ) {
 	var values = incrspace( 172.0, 1000.0, 10.1234 );
 	var v;
 	var i;
@@ -94,7 +102,7 @@ tape( 'if `x > 171.6144...`, the function returns positive infinity', function t
 	t.end();
 });
 
-tape( 'if `x < -170.56749...`, the function returns positive infinity', function test( t ) {
+tape( 'if `x < -170.56749...`, the function returns positive infinity', opts, function test( t ) {
 	var values = incrspace( -170.57, -1000.0, -10.1234 );
 	var v;
 	var i;
@@ -106,7 +114,7 @@ tape( 'if `x < -170.56749...`, the function returns positive infinity', function
 	t.end();
 });
 
-tape( 'the function evaluates the gamma function (positive integers)', function test( t ) {
+tape( 'the function evaluates the gamma function (positive integers)', opts, function test( t ) {
 	var delta;
 	var tol;
 	var v;
@@ -121,7 +129,7 @@ tape( 'the function evaluates the gamma function (positive integers)', function
 	t.end();
 });
 
-tape( 'the function evaluates the gamma function (decimal values)', function test( t ) {
+tape( 'the function evaluates the gamma function (decimal values)', opts, function test( t ) {
 	var delta;
 	var tol;
 	var v;
@@ -136,7 +144,7 @@ tape( 'the function evaluates the gamma function (decimal values)', function tes
 	t.end();
 });
 
-tape( 'if provided a positive integer, the function returns the factorial of (n-1)', function test( t ) {
+tape( 'if provided a positive integer, the function returns the factorial of (n-1)', opts, function test( t ) {
 	t.strictEqual( gamma( 4.0 ), 6.0, 'returns 6' );
 	t.strictEqual( gamma( 5.0 ), 24.0, 'returns 24' );
 	t.strictEqual( gamma( 6.0 ), 120.0, 'returns 120' );

From dbeef745d0fac4ce044f99efee1e575473c6a853 Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Thu, 14 Aug 2025 13:21:55 -0500
Subject: [PATCH 10/32] test: use .strictEqual() instead of .equal() and fix
 lint errors

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../browser-build/test/test.validate.js       |  18 +--
 .../_tools/benchmarks/bundle/test/test.cli.js |   4 +-
 .../_tools/benchmarks/bundle/test/test.js     |   8 +-
 .../benchmarks/bundle/test/test.validate.js   |  12 +-
 .../_tools/benchmarks/html/test/test.js       |   4 +-
 .../benchmarks/html/test/test.validate.js     |  12 +-
 .../bib/citation-reference/test/test.async.js |   2 +-
 .../bib/citation-reference/test/test.js       |   4 +-
 .../bib/citation-reference/test/test.sync.js  |   2 +-
 .../citation-reference/test/test.validate.js  |  12 +-
 .../_tools/browserify/file-list/test/test.js  |   6 +-
 .../_tools/changelog/generate/test/test.js    |   2 +-
 .../changelog/generate/test/test.validate.js  |   8 +-
 .../parse-commits/test/test.filter_files.js   |   2 +-
 .../changelog/parse-commits/test/test.js      |   2 +-
 .../parse-commits/test/test.validate.js       |  14 +-
 .../recommend-version-bump/test/test.js       |  10 +-
 .../test/test.validate.js                     |  18 +--
 .../rules/capitalized-comments/test/test.js   |   2 +-
 .../eslint/rules/doctest-marker/test/test.js  |   2 +-
 .../rules/doctest-quote-props/test/test.js    |   2 +-
 .../_tools/eslint/rules/doctest/test/test.js  |   2 +-
 .../empty-line-before-comment/test/test.js    |   2 +-
 .../eol-open-bracket-spacing/test/test.js     |   2 +-
 .../eslint/rules/first-unit-test/test/test.js |   2 +-
 .../jsdoc-blockquote-indentation/test/test.js |   2 +-
 .../test/test.js                              |   2 +-
 .../test/test.js                              |   2 +-
 .../rules/jsdoc-code-block-style/test/test.js |   2 +-
 .../rules/jsdoc-definition-case/test/test.js  |   2 +-
 .../jsdoc-definition-spacing/test/test.js     |   2 +-
 .../jsdoc-doctest-decimal-point/test/test.js  |   2 +-
 .../rules/jsdoc-doctest-marker/test/test.js   |   2 +-
 .../jsdoc-doctest-quote-props/test/test.js    |   2 +-
 .../eslint/rules/jsdoc-doctest/test/test.js   |   2 +-
 .../rules/jsdoc-emphasis-marker/test/test.js  |   2 +-
 .../test/test.js                              |   2 +-
 .../test/test.js                              |   2 +-
 .../rules/jsdoc-fenced-code-flag/test/test.js |   2 +-
 .../jsdoc-fenced-code-marker/test/test.js     |   2 +-
 .../rules/jsdoc-final-definition/test/test.js |   2 +-
 .../jsdoc-first-heading-level/test/test.js    |   2 +-
 .../jsdoc-hard-break-spaces/test/test.js      |   2 +-
 .../jsdoc-heading-increment/test/test.js      |   2 +-
 .../rules/jsdoc-heading-style/test/test.js    |   2 +-
 .../test/test.js                              |   2 +-
 .../jsdoc-license-header-year/test/test.js    |   2 +-
 .../rules/jsdoc-linebreak-style/test/test.js  |   2 +-
 .../rules/jsdoc-link-title-style/test/test.js |   2 +-
 .../test/test.js                              |   2 +-
 .../test/test.js                              |   2 +-
 .../rules/jsdoc-list-item-indent/test/test.js |   2 +-
 .../jsdoc-list-item-spacing/test/test.js      |   2 +-
 .../rules/jsdoc-main-export/test/test.js      |   2 +-
 .../rules/jsdoc-markdown-remark/test/test.js  |   2 +-
 .../jsdoc-maximum-heading-length/test/test.js |   2 +-
 .../jsdoc-maximum-line-length/test/test.js    |   2 +-
 .../test/test.js                              |   2 +-
 .../test/test.js                              |   2 +-
 .../test/test.js                              |   2 +-
 .../test/test.js                              |   2 +-
 .../test/test.js                              |   2 +-
 .../jsdoc-no-duplicate-headings/test/test.js  |   2 +-
 .../jsdoc-no-duplicate-tags/test/test.js      |   2 +-
 .../jsdoc-no-emphasis-as-heading/test/test.js |   2 +-
 .../rules/jsdoc-no-empty-url/test/test.js     |   2 +-
 .../test/test.js                              |   2 +-
 .../jsdoc-no-heading-indent/test/test.js      |   2 +-
 .../test/test.js                              |   2 +-
 .../jsdoc-no-heading-punctuation/test/test.js |   2 +-
 .../eslint/rules/jsdoc-no-html/test/test.js   |   2 +-
 .../jsdoc-no-inline-padding/test/test.js      |   2 +-
 .../rules/jsdoc-no-literal-urls/test/test.js  |   2 +-
 .../jsdoc-no-missing-blank-lines/test/test.js |   2 +-
 .../test/test.js                              |   2 +-
 .../test/test.js                              |   2 +-
 .../test/test.js                              |   2 +-
 .../jsdoc-no-reference-like-url/test/test.js  |   2 +-
 .../rules/jsdoc-no-shell-dollars/test/test.js |   2 +-
 .../test/test.js                              |   2 +-
 .../test/test.js                              |   2 +-
 .../test/test.js                              |   2 +-
 .../jsdoc-no-table-indentation/test/test.js   |   2 +-
 .../eslint/rules/jsdoc-no-tabs/test/test.js   |   2 +-
 .../test/test.js                              |   2 +-
 .../jsdoc-no-unused-definitions/test/test.js  |   2 +-
 .../test/test.js                              |   2 +-
 .../test/test.js                              |   2 +-
 .../jsdoc-private-annotation/test/test.js     |   2 +-
 .../jsdoc-require-throws-tags/test/test.js    |   2 +-
 .../rules/jsdoc-rule-style/test/test.js       |   2 +-
 .../rules/jsdoc-strong-marker/test/test.js    |   2 +-
 .../jsdoc-table-cell-padding/test/test.js     |   2 +-
 .../jsdoc-table-pipe-alignment/test/test.js   |   2 +-
 .../rules/jsdoc-table-pipes/test/test.js      |   2 +-
 .../eslint/rules/jsdoc-tag-names/test/test.js |   2 +-
 .../eslint/rules/jsdoc-tag-order/test/test.js |   2 +-
 .../rules/jsdoc-tag-spacing/test/test.js      |   2 +-
 .../rules/jsdoc-typedef-typos/test/test.js    |   2 +-
 .../test/test.js                              |   2 +-
 .../line-closing-bracket-spacing/test/test.js |   2 +-
 .../rules/module-exports-last/test/test.js    |   2 +-
 .../rules/namespace-export-all/test/test.js   |   2 +-
 .../rules/namespace-index-order/test/test.js  |   2 +-
 .../eslint/rules/new-cap-array/test/test.js   |   2 +-
 .../eslint/rules/new-cap-error/test/test.js   |   2 +-
 .../eslint/rules/new-cap-regexp/test/test.js  |   2 +-
 .../rules/no-builtin-big-int/test/test.js     |   2 +-
 .../eslint/rules/no-builtin-math/test/test.js |   2 +-
 .../rules/no-dynamic-exports/test/test.js     |   2 +-
 .../rules/no-dynamic-require/test/test.js     |   2 +-
 .../rules/no-empty-comments/test/test.js      |   2 +-
 .../rules/no-immediate-require/test/test.js   |   2 +-
 .../rules/no-internal-require/test/test.js    |   2 +-
 .../no-multiple-empty-lines/test/test.js      |   2 +-
 .../rules/no-nested-require/test/test.js      |   2 +-
 .../eslint/rules/no-new-array/test/test.js    |   2 +-
 .../eslint/rules/no-redeclare/test/test.js    |   2 +-
 .../no-require-absolute-path/test/test.js     |   2 +-
 .../rules/no-require-index/test/test.js       |   2 +-
 .../eslint/rules/no-self-require/test/test.js |   2 +-
 .../rules/no-unassigned-require/test/test.js  |   2 +-
 .../rules/repl-namespace-order/test/test.js   |   2 +-
 .../require-file-extensions/test/test.js      |   2 +-
 .../eslint/rules/require-globals/test/test.js |   2 +-
 .../require-last-path-relative/test/test.js   |   2 +-
 .../rules/require-leading-slash/test/test.js  |   2 +-
 .../eslint/rules/require-order/test/test.js   |   2 +-
 .../eslint/rules/require-spaces/test/test.js  |   2 +-
 .../section-header-empty-lines/test/test.js   |   2 +-
 .../section-headers/test/fixtures/valid.js    |   2 +-
 .../eslint/rules/section-headers/test/test.js |   2 +-
 .../test/test.js                              |   2 +-
 .../@stdlib/_tools/eslint/rules/test/test.js  |   4 +-
 .../uppercase-required-constants/test/test.js |   2 +-
 .../eslint/rules/vars-order/test/test.js      |   2 +-
 .../github/create-issue/test/test.data.js     |   8 +-
 .../github/create-issue/test/test.headers.js  |  10 +-
 .../_tools/github/create-issue/test/test.js   |   2 +-
 .../github/create-issue/test/test.main.js     |   6 +-
 .../github/create-issue/test/test.options.js  |  12 +-
 .../github/create-issue/test/test.query.js    |  12 +-
 .../create-issue/test/test.ratelimit.js       |  16 +--
 .../github/create-issue/test/test.request.js  |  32 ++---
 .../github/create-issue/test/test.validate.js |  26 ++--
 .../github/create-repo/test/test.data.js      |  34 ++---
 .../github/create-repo/test/test.factory.js   |  10 +-
 .../github/create-repo/test/test.headers.js   |  10 +-
 .../_tools/github/create-repo/test/test.js    |   4 +-
 .../github/create-repo/test/test.main.js      |   4 +-
 .../github/create-repo/test/test.options.js   |  12 +-
 .../github/create-repo/test/test.query.js     |   8 +-
 .../github/create-repo/test/test.ratelimit.js |  10 +-
 .../github/create-repo/test/test.request.js   |  32 ++---
 .../github/create-repo/test/test.validate.js  |   6 +-
 .../github/create-token/test/test.data.js     |  14 +-
 .../github/create-token/test/test.headers.js  |  14 +-
 .../_tools/github/create-token/test/test.js   |   2 +-
 .../github/create-token/test/test.main.js     |  10 +-
 .../github/create-token/test/test.options.js  |  12 +-
 .../github/create-token/test/test.query.js    |   8 +-
 .../create-token/test/test.ratelimit.js       |  10 +-
 .../github/create-token/test/test.request.js  |  32 ++---
 .../github/create-token/test/test.validate.js |   6 +-
 .../github/delete-token/test/test.headers.js  |  12 +-
 .../_tools/github/delete-token/test/test.js   |   2 +-
 .../github/delete-token/test/test.main.js     |  12 +-
 .../github/delete-token/test/test.options.js  |  12 +-
 .../github/delete-token/test/test.query.js    |   6 +-
 .../delete-token/test/test.ratelimit.js       |  10 +-
 .../github/delete-token/test/test.request.js  |  18 +--
 .../github/delete-token/test/test.validate.js |   6 +-
 .../dispatch-workflow/test/test.data.js       |   4 +-
 .../dispatch-workflow/test/test.headers.js    |  10 +-
 .../github/dispatch-workflow/test/test.js     |   2 +-
 .../dispatch-workflow/test/test.main.js       |   6 +-
 .../dispatch-workflow/test/test.options.js    |  12 +-
 .../dispatch-workflow/test/test.query.js      |   8 +-
 .../dispatch-workflow/test/test.ratelimit.js  |  16 +--
 .../dispatch-workflow/test/test.request.js    |  18 +--
 .../dispatch-workflow/test/test.validate.js   |  20 +--
 .../github/fetch-file/test/test.factory.js    |  10 +-
 .../_tools/github/fetch-file/test/test.js     |   4 +-
 .../github/fetch-file/test/test.main.js       |   8 +-
 .../github/fetch-file/test/test.options.js    |  12 +-
 .../github/fetch-file/test/test.request.js    |  28 ++--
 .../github/fetch-file/test/test.resolve.js    |  12 +-
 .../github/followers/test/test.factory.js     |   8 +-
 .../_tools/github/followers/test/test.js      |   4 +-
 .../_tools/github/followers/test/test.main.js |  16 +--
 .../github/followers/test/test.validate.js    |   6 +-
 .../github/following/test/test.factory.js     |  18 +--
 .../_tools/github/following/test/test.js      |   4 +-
 .../_tools/github/following/test/test.main.js |  16 +--
 .../github/following/test/test.validate.js    |   6 +-
 .../_tools/github/get/test/test.cache.js      |   6 +-
 .../_tools/github/get/test/test.checklimit.js |   2 +-
 .../_tools/github/get/test/test.factory.js    |  12 +-
 .../_tools/github/get/test/test.flatten.js    |   5 +-
 .../_tools/github/get/test/test.headers.js    |  10 +-
 .../@stdlib/_tools/github/get/test/test.js    |   4 +-
 .../_tools/github/get/test/test.lastpage.js   |   8 +-
 .../_tools/github/get/test/test.main.js       |   6 +-
 .../_tools/github/get/test/test.options.js    |  12 +-
 .../_tools/github/get/test/test.path.js       |   6 +-
 .../_tools/github/get/test/test.ratelimit.js  |  16 +--
 .../_tools/github/get/test/test.request.js    |  32 ++---
 .../_tools/github/get/test/test.resolve.js    | 135 +++++++++---------
 .../_tools/github/get/test/test.total.js      |   4 +-
 .../_tools/github/get/test/test.validate.js   |  31 ++--
 .../github/org-repos/test/test.factory.js     |  10 +-
 .../_tools/github/org-repos/test/test.js      |   4 +-
 .../_tools/github/org-repos/test/test.main.js |   6 +-
 .../github/org-repos/test/test.validate.js    |   6 +-
 .../rank-followers/test/test.factory.js       |  18 +--
 .../_tools/github/rank-followers/test/test.js |   4 +-
 .../github/rank-followers/test/test.main.js   |  16 +--
 .../rank-followers/test/test.pipeline.js      |  36 ++---
 .../rank-followers/test/test.validate.js      |   6 +-
 .../github/rank-users/test/test.analyze.js    |   2 +-
 .../github/rank-users/test/test.ascending.js  |   4 +-
 .../github/rank-users/test/test.descending.js |   4 +-
 .../github/rank-users/test/test.factory.js    |  12 +-
 .../_tools/github/rank-users/test/test.js     |   4 +-
 .../github/rank-users/test/test.main.js       |  12 +-
 .../rank-users/test/test.pluck.ratio.js       |   2 +-
 .../github/rank-users/test/test.pluck.raw.js  |   2 +-
 .../github/rank-users/test/test.shuffle.js    |   2 +-
 .../github/rank-users/test/test.sort.js       |   2 +-
 .../github/rank-users/test/test.validate.js   |   6 +-
 .../github/set-topics/test/test.factory.js    |  12 +-
 .../github/set-topics/test/test.headers.js    |  10 +-
 .../_tools/github/set-topics/test/test.js     |   4 +-
 .../github/set-topics/test/test.main.js       |   6 +-
 .../github/set-topics/test/test.options.js    |  12 +-
 .../github/set-topics/test/test.query.js      |   8 +-
 .../github/set-topics/test/test.ratelimit.js  |  10 +-
 .../github/set-topics/test/test.request.js    |  18 +--
 .../github/set-topics/test/test.validate.js   |   6 +-
 .../github/star-repo/test/test.factory.js     |  12 +-
 .../github/star-repo/test/test.headers.js     |  10 +-
 .../_tools/github/star-repo/test/test.js      |   4 +-
 .../_tools/github/star-repo/test/test.main.js |   6 +-
 .../github/star-repo/test/test.options.js     |  12 +-
 .../github/star-repo/test/test.query.js       |   8 +-
 .../github/star-repo/test/test.ratelimit.js   |  10 +-
 .../github/star-repo/test/test.request.js     |  18 +--
 .../github/star-repo/test/test.validate.js    |   6 +-
 .../github/starred/test/test.factory.js       |  20 +--
 .../_tools/github/starred/test/test.js        |   4 +-
 .../_tools/github/starred/test/test.main.js   |  16 +--
 .../github/starred/test/test.validate.js      |   6 +-
 .../github/subscriptions/test/test.factory.js |  18 +--
 .../_tools/github/subscriptions/test/test.js  |   4 +-
 .../github/subscriptions/test/test.main.js    |  16 +--
 .../subscriptions/test/test.validate.js       |   6 +-
 .../github/user-details/test/test.factory.js  |  14 +-
 .../github/user-details/test/test.get.js      |  17 +--
 .../_tools/github/user-details/test/test.js   |   4 +-
 .../github/user-details/test/test.main.js     |  12 +-
 .../user-details/test/test.updatelimit.js     |   2 +-
 .../github/user-details/test/test.validate.js |   6 +-
 .../github/user-orgs/test/test.factory.js     |  22 +--
 .../_tools/github/user-orgs/test/test.js      |   4 +-
 .../_tools/github/user-orgs/test/test.main.js |  16 +--
 .../github/user-orgs/test/test.validate.js    |   6 +-
 .../user-rate-limit/test/test.factory.js      |  10 +-
 .../github/user-rate-limit/test/test.js       |   4 +-
 .../github/user-rate-limit/test/test.main.js  |   8 +-
 .../user-rate-limit/test/test.validate.js     |   6 +-
 .../github/user-repos/test/test.factory.js    |  22 +--
 .../_tools/github/user-repos/test/test.js     |   4 +-
 .../github/user-repos/test/test.main.js       |  18 +--
 .../github/user-repos/test/test.query.js      |  18 +--
 .../github/user-repos/test/test.validate.js   |   6 +-
 .../github/workflow-runs/test/test.factory.js |   8 +-
 .../_tools/github/workflow-runs/test/test.js  |   4 +-
 .../github/workflow-runs/test/test.main.js    |   6 +-
 .../workflow-runs/test/test.validate.js       |   6 +-
 .../_tools/links/create/test/test.async.js    |   2 +-
 .../@stdlib/_tools/links/create/test/test.js  |   4 +-
 .../_tools/links/create/test/test.sync.js     |   2 +-
 .../_tools/links/create/test/test.validate.js |  16 +--
 .../_tools/links/id2uri/test/test.async.js    |   2 +-
 .../@stdlib/_tools/links/id2uri/test/test.js  |   4 +-
 .../_tools/links/id2uri/test/test.sync.js     |   2 +-
 .../_tools/links/id2uri/test/test.validate.js |   8 +-
 .../_tools/links/uri2id/test/test.async.js    |   2 +-
 .../@stdlib/_tools/links/uri2id/test/test.js  |   4 +-
 .../_tools/links/uri2id/test/test.sync.js     |   2 +-
 .../_tools/links/uri2id/test/test.validate.js |   8 +-
 .../_tools/links/validate/test/test.async.js  |   2 +-
 .../_tools/links/validate/test/test.js        |   4 +-
 .../_tools/links/validate/test/test.sync.js   |   2 +-
 .../links/validate/test/test.validate.js      |   8 +-
 .../_tools/lint/filenames/test/test.async.js  |   6 +-
 .../_tools/lint/filenames/test/test.js        |   4 +-
 .../_tools/lint/filenames/test/test.lint.js   |  20 +--
 .../_tools/lint/filenames/test/test.sync.js   |   8 +-
 .../lint/filenames/test/test.validate.js      |  16 +--
 .../lint/header-filenames/test/test.async.js  |   6 +-
 .../_tools/lint/header-filenames/test/test.js |   4 +-
 .../lint/header-filenames/test/test.lint.js   |  18 +--
 .../lint/header-filenames/test/test.sync.js   |   8 +-
 .../header-filenames/test/test.validate.js    |  12 +-
 .../license-header-glob/test/test.validate.js |  20 +--
 .../namespace-aliases/test/test.validate.js   |  12 +-
 .../img-svg-equation/test/test.escape_html.js |  13 +-
 .../markdown/img-svg-equation/test/test.js    |   7 +-
 .../img-svg-equation/test/test.render.js      |   7 +-
 .../img-svg-equation/test/test.validate.js    |   6 +-
 .../test/test.escape_html.js                  |  13 +-
 .../markdown/inline-svg-equation/test/test.js |   7 +-
 .../inline-svg-equation/test/test.render.js   |   7 +-
 .../inline-svg-equation/test/test.validate.js |   6 +-
 .../import-require-glob/test/test.async.js    |   7 +-
 .../modules/import-require-glob/test/test.js  |   4 +-
 .../import-require-glob/test/test.sync.js     |   5 +-
 .../import-require-glob/test/test.validate.js |  14 +-
 .../modules/import-require/test/test.js       |   2 +-
 .../modules/pkg-deps/test/test.analyze.js     |   2 +-
 .../modules/pkg-deps/test/test.async.js       |   4 +-
 .../pkg-deps/test/test.filter_builtins.js     |   2 +-
 .../pkg-deps/test/test.filter_literals.js     |   2 +-
 .../_tools/modules/pkg-deps/test/test.js      |   4 +-
 .../modules/pkg-deps/test/test.re_relative.js |   6 +-
 .../_tools/modules/pkg-deps/test/test.sync.js |   4 +-
 .../modules/pkg-deps/test/test.to_array.js    |   4 +-
 .../modules/pkg-deps/test/test.validate.js    |  14 +-
 .../modules/pkg-deps/test/test.walk_file.js   |  22 +--
 .../pkg-deps/test/test.walk_file.sync.js      |  16 +--
 .../browser-compatible/test/test.async.js     |  12 +-
 .../pkgs/browser-compatible/test/test.js      |   4 +-
 .../pkgs/browser-compatible/test/test.sync.js |  12 +-
 .../browser-compatible/test/test.validate.js  |  20 +--
 .../pkgs/browser-deps/test/test.async.js      |   2 +-
 .../_tools/pkgs/browser-deps/test/test.js     |   4 +-
 .../pkgs/browser-deps/test/test.sync.js       |   2 +-
 .../pkgs/browser-deps/test/test.validate.js   |  14 +-
 .../browser-entry-points/test/test.async.js   |   2 +-
 .../pkgs/browser-entry-points/test/test.js    |   4 +-
 .../browser-entry-points/test/test.sync.js    |   2 +-
 .../test/test.validate.js                     |  12 +-
 .../@stdlib/_tools/pkgs/dep-list/test/test.js |   8 +-
 .../_tools/pkgs/dep-list/test/test.root.js    |  10 +-
 .../_tools/pkgs/deps/test/test.async.js       |   2 +-
 .../@stdlib/_tools/pkgs/deps/test/test.js     |   4 +-
 .../_tools/pkgs/deps/test/test.sync.js        |   2 +-
 .../_tools/pkgs/deps/test/test.validate.js    |  14 +-
 .../pkgs/entry-points/test/test.async.js      |   2 +-
 .../_tools/pkgs/entry-points/test/test.js     |   4 +-
 .../pkgs/entry-points/test/test.sync.js       |   2 +-
 .../pkgs/entry-points/test/test.validate.js   |  12 +-
 .../_tools/pkgs/find/test/test.async.js       |   8 +-
 .../@stdlib/_tools/pkgs/find/test/test.js     |   4 +-
 .../_tools/pkgs/find/test/test.sync.js        |   8 +-
 .../_tools/pkgs/find/test/test.transform.js   |   2 +-
 .../_tools/pkgs/find/test/test.validate.js    |  18 +--
 .../_tools/pkgs/names/test/test.async.js      |  12 +-
 .../@stdlib/_tools/pkgs/names/test/test.js    |   4 +-
 .../_tools/pkgs/names/test/test.root.js       |  10 +-
 .../_tools/pkgs/names/test/test.sync.js       |  12 +-
 .../_tools/pkgs/names/test/test.transform.js  |   2 +-
 .../_tools/pkgs/namespace-deps/test/test.js   |   8 +-
 .../pkgs/namespace-deps/test/test.root.js     |  10 +-
 .../_tools/pkgs/namespaces/test/test.async.js |  12 +-
 .../_tools/pkgs/namespaces/test/test.js       |   4 +-
 .../_tools/pkgs/namespaces/test/test.sync.js  |  12 +-
 .../pkgs/namespaces/test/test.validate.js     |  20 +--
 .../pkgs/standalones/test/test.async.js       |  12 +-
 .../_tools/pkgs/standalones/test/test.js      |   4 +-
 .../_tools/pkgs/standalones/test/test.sync.js |  12 +-
 .../pkgs/standalones/test/test.validate.js    |  20 +--
 .../_tools/pkgs/toposort/test/test.async.js   |  12 +-
 .../@stdlib/_tools/pkgs/toposort/test/test.js |   4 +-
 .../_tools/pkgs/toposort/test/test.sync.js    |  16 +--
 .../pkgs/toposort/test/test.validate.js       |  20 +--
 .../_tools/pkgs/tree/test/test.async.js       |  12 +-
 .../@stdlib/_tools/pkgs/tree/test/test.js     |   4 +-
 .../_tools/pkgs/tree/test/test.sync.js        |  12 +-
 .../_tools/pkgs/tree/test/test.validate.js    |  20 +--
 .../readme/to-html/test/test.validate.js      |  26 ++--
 .../scaffold/namespace/data/test/test__js.txt |   2 +-
 .../data/test/test__js.txt                    |  12 +-
 .../data/test/test__js.txt                    |  12 +-
 .../random-array-unary/data/test/test__js.txt |  12 +-
 .../data/test/test__js.txt                    |  12 +-
 .../test/fixtures/cli_test.validate.js.txt    |  10 +-
 .../test/fixtures/test.validate.js_1.txt      |  12 +-
 .../test/fixtures/test.validate.js_2.txt      |  22 +--
 .../test/fixtures/test.validate.js_3.txt      |  14 +-
 .../test/fixtures/test.validate.js_4.txt      |  12 +-
 .../scaffold/test-validate-js/test/test.js    |   2 +-
 .../_tools/scaffold/validate-js/test/test.js  |   2 +-
 .../js/lloc-glob/test/test.validate.js        |   6 +-
 .../js/sloc-glob/test/test.validate.js        |   6 +-
 .../js/summarize-glob/test/test.validate.js   |   6 +-
 .../tape-istanbul/test/test.validate.js       |  12 +-
 lib/node_modules/@stdlib/_tools/test/test.js  |   2 +-
 .../tests/browser-build/test/test.validate.js |  18 +--
 .../_tools/tests/bundle/test/test.cli.js      |   4 +-
 .../@stdlib/_tools/tests/bundle/test/test.js  |   8 +-
 .../_tools/tests/bundle/test/test.validate.js |  12 +-
 .../@stdlib/_tools/tests/html/test/test.js    |   2 +-
 .../_tools/tests/html/test/test.validate.js   |  12 +-
 .../uncapitalize-pkg-description/test/test.js |  10 +-
 406 files changed, 1543 insertions(+), 1531 deletions(-)

diff --git a/lib/node_modules/@stdlib/_tools/benchmarks/browser-build/test/test.validate.js b/lib/node_modules/@stdlib/_tools/benchmarks/browser-build/test/test.validate.js
index db2ec8b9e636..39a85a542a76 100644
--- a/lib/node_modules/@stdlib/_tools/benchmarks/browser-build/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/benchmarks/browser-build/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided a `pattern` option which is not
 		err = validate( {}, {
 			'pattern': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `bundle` option which is not
 		err = validate( {}, {
 			'bundle': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided a `mount` option which is not a
 		err = validate( {}, {
 			'mount': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided an `html` option which is not a
 		err = validate( {}, {
 			'html': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -181,7 +181,7 @@ tape( 'the function returns an error if provided a `title` option which is not a
 		err = validate( {}, {
 			'title': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -201,7 +201,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -220,7 +220,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.cli.js b/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.cli.js
index 31670db4c074..991a2ae58783 100644
--- a/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.cli.js
+++ b/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.cli.js
@@ -167,7 +167,7 @@ tape( 'the command-line interface generates a bundle', opts, function test( t )
 				evil( stdout.toString() );
 				t.fail( 'should throw an error' );
 			} catch ( err ) {
-				t.equal( err.message, 'BEEP', 'has expected error message' );
+				t.strictEqual( err.message, 'BEEP', 'has expected error message' );
 			}
 		}
 		t.end();
@@ -200,7 +200,7 @@ tape( 'the command-line interface supports providing a custom glob pattern', opt
 				evil( stdout.toString() );
 				t.fail( 'should throw an error' );
 			} catch ( err ) {
-				t.equal( err.message, 'BEEP', 'has expected error message' );
+				t.strictEqual( err.message, 'BEEP', 'has expected error message' );
 			}
 		}
 		t.end();
diff --git a/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.js b/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.js
index 1be47d849b1a..ff3535757bbc 100644
--- a/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.js
@@ -41,7 +41,7 @@ var FIXTURES = join( __dirname, 'fixtures', 'main' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof bundle, 'function', 'main export is a function' );
+	t.strictEqual( typeof bundle, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -113,7 +113,7 @@ tape( 'the function generates a bundle', function test( t ) {
 				evil( output.toString() );
 				t.fail( 'should throw an error' );
 			} catch ( err ) {
-				t.equal( err.message, 'BEEP', 'has expected error message' );
+				t.strictEqual( err.message, 'BEEP', 'has expected error message' );
 			}
 		}
 		t.end();
@@ -137,7 +137,7 @@ tape( 'the function generates a bundle (custom glob pattern)', function test( t
 				evil( output.toString() );
 				t.fail( 'should throw an error' );
 			} catch ( err ) {
-				t.equal( err.message, 'BEEP', 'has expected error message' );
+				t.strictEqual( err.message, 'BEEP', 'has expected error message' );
 			}
 		}
 		t.end();
@@ -172,7 +172,7 @@ tape( 'the function supports providing an output file path', function test( t )
 			evil( out.toString() );
 			t.fail( 'should throw an error' );
 		} catch ( err ) {
-			t.equal( err.message, 'BEEP', 'has expected error message' );
+			t.strictEqual( err.message, 'BEEP', 'has expected error message' );
 		}
 
 		unlink( opath );
diff --git a/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.validate.js b/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.validate.js
index 80b8bdeed2a4..46ac1c52a011 100644
--- a/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `out` option which is not a
 		err = validate( {}, {
 			'out': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `pattern` option which is not
 		err = validate( {}, {
 			'pattern': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -139,7 +139,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/benchmarks/html/test/test.js b/lib/node_modules/@stdlib/_tools/benchmarks/html/test/test.js
index 29ff7fcc11d7..8c9ac18a031b 100644
--- a/lib/node_modules/@stdlib/_tools/benchmarks/html/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/benchmarks/html/test/test.js
@@ -20,8 +20,8 @@
 
 // MODULES //
 
-var tape = require( 'tape' );
 var join = require( 'path' ).join;
+var tape = require( 'tape' );
 var unlink = require( '@stdlib/fs/unlink' ).sync;
 var readFile = require( '@stdlib/fs/read-file' ).sync;
 var noop = require( '@stdlib/utils/noop' );
@@ -37,7 +37,7 @@ var EXPECTED = readFile( join( __dirname, 'fixtures', 'expected.txt' ) );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof bundle, 'function', 'main export is a function' );
+	t.strictEqual( typeof bundle, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/benchmarks/html/test/test.validate.js b/lib/node_modules/@stdlib/_tools/benchmarks/html/test/test.validate.js
index 093a2fc7f06b..8a388b894d9b 100644
--- a/lib/node_modules/@stdlib/_tools/benchmarks/html/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/benchmarks/html/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `out` option which is not a
 		err = validate( {}, {
 			'out': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `title` option which is not a
 		err = validate( {}, {
 			'title': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -139,7 +139,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.async.js b/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.async.js
index 860b3a5979b7..1acfaa758695 100644
--- a/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.async.js
@@ -29,7 +29,7 @@ var toReference = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof toReference, 'function', 'main export is a function' );
+	t.strictEqual( typeof toReference, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.js b/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.js
index c15270b8d78c..9a5306981478 100644
--- a/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.js
@@ -28,11 +28,11 @@ var toReference = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof toReference, 'function', 'main export is a function' );
+	t.strictEqual( typeof toReference, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously return a reference', function test( t ) {
-	t.equal( typeof toReference.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof toReference.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.sync.js b/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.sync.js
index 2b0e2c183456..b278b5cd384f 100644
--- a/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.sync.js
@@ -28,7 +28,7 @@ var toReference = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof toReference, 'function', 'main export is a function' );
+	t.strictEqual( typeof toReference, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.validate.js b/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.validate.js
index 5c347a6e3b04..7c0150579f8d 100644
--- a/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `database` option which is not a `string`, the function ret
 		err = validate( opts, {
 			'database': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'if provided a `csl` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'csl': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.strictEqual( obj.database, opts.database, 'sets database option' );
 	t.strictEqual( obj.csl, opts.csl, 'sets csl option' );
 
@@ -143,7 +143,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/browserify/file-list/test/test.js b/lib/node_modules/@stdlib/_tools/browserify/file-list/test/test.js
index c26ecba80bdc..238d5c59f23a 100644
--- a/lib/node_modules/@stdlib/_tools/browserify/file-list/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/browserify/file-list/test/test.js
@@ -35,7 +35,7 @@ var bundle = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof bundle, 'function', 'main export is a function' );
+	t.strictEqual( typeof bundle, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -138,7 +138,7 @@ tape( 'the function generates a bundle', function test( t ) {
 				evil( output.toString() );
 				t.fail( 'should throw an error' );
 			} catch ( err ) {
-				t.equal( err.message, 'BEEP', 'has expected message' );
+				t.strictEqual( err.message, 'BEEP', 'has expected message' );
 			}
 		}
 		t.end();
@@ -170,7 +170,7 @@ tape( 'the function supports specifying an output file path', function test( t )
 			evil( out.toString() );
 			t.fail( 'should throw an error' );
 		} catch ( err ) {
-			t.equal( err.message, 'BEEP', 'has expected message' );
+			t.strictEqual( err.message, 'BEEP', 'has expected message' );
 		}
 
 		// Clean-up:
diff --git a/lib/node_modules/@stdlib/_tools/changelog/generate/test/test.js b/lib/node_modules/@stdlib/_tools/changelog/generate/test/test.js
index 2d59f61c72b9..28e8979a1550 100644
--- a/lib/node_modules/@stdlib/_tools/changelog/generate/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/changelog/generate/test/test.js
@@ -29,7 +29,7 @@ var generate = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof generate, 'function', 'main export is a function' );
+	t.strictEqual( typeof generate, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/changelog/generate/test/test.validate.js b/lib/node_modules/@stdlib/_tools/changelog/generate/test/test.validate.js
index d6eb7dc762ed..241ad78045bc 100644
--- a/lib/node_modules/@stdlib/_tools/changelog/generate/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/changelog/generate/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -142,8 +142,8 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.copy, opts.copy, 'sets copy option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.copy, opts.copy, 'sets copy option' );
 	t.end();
 });
 
@@ -158,7 +158,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.filter_files.js b/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.filter_files.js
index e991a40aa81c..0b11b60132af 100644
--- a/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.filter_files.js
+++ b/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.filter_files.js
@@ -28,7 +28,7 @@ var filterFiles = require( './../lib/filter_files.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof filterFiles, 'function', 'main export is a function' );
+	t.strictEqual( typeof filterFiles, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.js b/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.js
index 60a40669be75..067b965a1181 100644
--- a/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.js
@@ -33,7 +33,7 @@ var parseCommits = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof parseCommits, 'function', 'main export is a function' );
+	t.strictEqual( typeof parseCommits, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.validate.js b/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.validate.js
index bf4c5366e594..c1950740bdba 100644
--- a/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'if provided an `issueURL` option which is not a `string`, the function re
 		err = validate( opts, {
 			'prURL': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'if provided a `prURL` option which is not a `string`, the function return
 		err = validate( opts, {
 			'prURL': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -176,7 +176,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.issueURL, opts.issueURL, 'sets issueURL option' );
 	t.strictEqual( obj.prURL, opts.prURL, 'sets prURL option' );
@@ -197,7 +197,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/changelog/recommend-version-bump/test/test.js b/lib/node_modules/@stdlib/_tools/changelog/recommend-version-bump/test/test.js
index 539fe882ff27..ac83edeaa02f 100644
--- a/lib/node_modules/@stdlib/_tools/changelog/recommend-version-bump/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/changelog/recommend-version-bump/test/test.js
@@ -28,13 +28,13 @@ var recommendVersionBump = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof recommendVersionBump, 'function', 'main export is a function' );
+	t.strictEqual( typeof recommendVersionBump, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns `null` for an empty array of commits', function test( t ) {
 	var result = recommendVersionBump( [] );
-	t.equal( result, null, 'returns expected value' );
+	t.strictEqual( result, null, 'returns expected value' );
 	t.end();
 });
 
@@ -50,7 +50,7 @@ tape( 'the function returns `\'patch\'` for commits with only bug fixes', functi
 		}
 	];
 	var result = recommendVersionBump( commits );
-	t.equal( result, 'patch', 'returns expected value' );
+	t.strictEqual( result, 'patch', 'returns expected value' );
 	t.end();
 });
 
@@ -66,7 +66,7 @@ tape( 'the function returns `\'minor\'` for commits with backward-compatible fea
 		}
 	];
 	var result = recommendVersionBump( commits );
-	t.equal( result, 'minor', 'returns expected value' );
+	t.strictEqual( result, 'minor', 'returns expected value' );
 	t.end();
 });
 
@@ -89,6 +89,6 @@ tape( 'the function returns `\'major\'` for commits with breaking changes', func
 		}
 	];
 	var result = recommendVersionBump( commits );
-	t.equal( result, 'major', 'returns expected value' );
+	t.strictEqual( result, 'major', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/doctest/create-annotation-value/test/test.validate.js b/lib/node_modules/@stdlib/_tools/doctest/create-annotation-value/test/test.validate.js
index 187fbeeacdd4..5a9dd0e2b74b 100644
--- a/lib/node_modules/@stdlib/_tools/doctest/create-annotation-value/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/doctest/create-annotation-value/test/test.validate.js
@@ -29,7 +29,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided a `decimal` option which is not
 		err = validate( {}, {
 			'decimal': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `type` option which is not a
 		err = validate( {}, {
 			'type': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function returns an error if provided a `numel` option which is not a
 		err = validate( {}, {
 			'numel': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -153,7 +153,7 @@ tape( 'the function returns an error if provided a `precision` option which is n
 		err = validate( {}, {
 			'precision': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -166,15 +166,15 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'decimal': true
 	};
 	obj = {};
-	t.equal( validate( obj, opts ), null, 'returns null' );
-	t.equal( obj.decimal, true, 'sets decimal option' );
+	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( obj.decimal, true, 'sets decimal option' );
 
 	opts = {
 		'beep': true,
 		'boop': false
 	};
 	obj = {};
-	t.equal( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/capitalized-comments/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/capitalized-comments/test/test.js
index f5192e76ba76..65f336195bae 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/capitalized-comments/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/capitalized-comments/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/doctest-marker/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/doctest-marker/test/test.js
index c37b9c79e172..69105b2f7ced 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/doctest-marker/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/doctest-marker/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/doctest-quote-props/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/doctest-quote-props/test/test.js
index c4c4e8959e9d..35ab24419ac1 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/doctest-quote-props/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/doctest-quote-props/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/doctest/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/doctest/test/test.js
index 7de83ad63bcb..0361559d9739 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/doctest/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/doctest/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/empty-line-before-comment/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/empty-line-before-comment/test/test.js
index 07ac312da736..4df2d23362a7 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/empty-line-before-comment/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/empty-line-before-comment/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/eol-open-bracket-spacing/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/eol-open-bracket-spacing/test/test.js
index 43153651efa8..7448c340e003 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/eol-open-bracket-spacing/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/eol-open-bracket-spacing/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/first-unit-test/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/first-unit-test/test/test.js
index 815d390bc936..ff8bdfab022c 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/first-unit-test/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/first-unit-test/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-blockquote-indentation/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-blockquote-indentation/test/test.js
index cb6455e68ba7..86889f270a68 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-blockquote-indentation/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-blockquote-indentation/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-checkbox-character-style/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-checkbox-character-style/test/test.js
index cd80459c0714..37973bcdb359 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-checkbox-character-style/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-checkbox-character-style/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-checkbox-content-indent/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-checkbox-content-indent/test/test.js
index b3fe41cf55d6..6c1b2d87d52a 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-checkbox-content-indent/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-checkbox-content-indent/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-code-block-style/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-code-block-style/test/test.js
index 753a5c2632a1..0cf9bab71882 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-code-block-style/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-code-block-style/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-definition-case/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-definition-case/test/test.js
index a3a3dc83202c..c81d05c417ae 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-definition-case/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-definition-case/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-definition-spacing/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-definition-spacing/test/test.js
index 45b93e45a106..ea5ace73d861 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-definition-spacing/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-definition-spacing/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest-decimal-point/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest-decimal-point/test/test.js
index 0575ce051f68..dbd4674cb025 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest-decimal-point/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest-decimal-point/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest-marker/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest-marker/test/test.js
index 5f5d095c4839..c1e1e8aed1dc 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest-marker/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest-marker/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest-quote-props/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest-quote-props/test/test.js
index 2c9e6b86d6b8..97597fcfe93f 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest-quote-props/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest-quote-props/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest/test/test.js
index 75241f45c29a..7809936bafd8 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-doctest/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-emphasis-marker/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-emphasis-marker/test/test.js
index 88dacdbc6097..8c96b71ffab2 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-emphasis-marker/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-emphasis-marker/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-empty-line-before-example/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-empty-line-before-example/test/test.js
index 0b374a541fee..a2fca93e458e 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-empty-line-before-example/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-empty-line-before-example/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-example-require-spacing/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-example-require-spacing/test/test.js
index 2fa07c24668f..d4f46bd6004f 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-example-require-spacing/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-example-require-spacing/test/test.js
@@ -35,7 +35,7 @@ var invalid = require( './fixtures/invalid.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-fenced-code-flag/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-fenced-code-flag/test/test.js
index e5ad24e31efb..aaa3415748b4 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-fenced-code-flag/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-fenced-code-flag/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-fenced-code-marker/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-fenced-code-marker/test/test.js
index effc592e5bde..a88184fea1bb 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-fenced-code-marker/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-fenced-code-marker/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-final-definition/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-final-definition/test/test.js
index 7b663c69ec9f..6fbfe0de9108 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-final-definition/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-final-definition/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-first-heading-level/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-first-heading-level/test/test.js
index 3d0c12cfef20..30de82667de4 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-first-heading-level/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-first-heading-level/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-hard-break-spaces/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-hard-break-spaces/test/test.js
index ec899240729a..d3fb6eb816bc 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-hard-break-spaces/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-hard-break-spaces/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-heading-increment/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-heading-increment/test/test.js
index 4d9384835c27..065209d405eb 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-heading-increment/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-heading-increment/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-heading-style/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-heading-style/test/test.js
index cee8e6f34e20..aaba7c4c9ce7 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-heading-style/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-heading-style/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-leading-description-sentence/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-leading-description-sentence/test/test.js
index 33ca614b4434..10924855cbda 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-leading-description-sentence/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-leading-description-sentence/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-license-header-year/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-license-header-year/test/test.js
index cf19df8e66a6..92c4655b2e60 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-license-header-year/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-license-header-year/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-linebreak-style/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-linebreak-style/test/test.js
index 1ba7c7ba5c66..f76ce8d8358a 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-linebreak-style/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-linebreak-style/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-link-title-style/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-link-title-style/test/test.js
index 88669d2a6401..c7ef872019f8 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-link-title-style/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-link-title-style/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-bullet-indent/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-bullet-indent/test/test.js
index 1dbcf7606920..929c65dd2340 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-bullet-indent/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-bullet-indent/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-content-indent/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-content-indent/test/test.js
index 6bde53879753..63c59a611da5 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-content-indent/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-content-indent/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-indent/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-indent/test/test.js
index cdf24857ac4e..9d6bfa5f1f85 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-indent/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-indent/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-spacing/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-spacing/test/test.js
index e0bb7219772c..14db0c1ef3bf 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-spacing/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-list-item-spacing/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-main-export/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-main-export/test/test.js
index c32b221f57c2..ae3174cdad11 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-main-export/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-main-export/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-markdown-remark/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-markdown-remark/test/test.js
index 59b1fd7af1c8..94d45d272a02 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-markdown-remark/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-markdown-remark/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-maximum-heading-length/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-maximum-heading-length/test/test.js
index 1027ee3ddeb6..dac15d87c679 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-maximum-heading-length/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-maximum-heading-length/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-maximum-line-length/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-maximum-line-length/test/test.js
index a104c7b978fe..2cc77f655bb4 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-maximum-line-length/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-maximum-line-length/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-auto-link-without-protocol/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-auto-link-without-protocol/test/test.js
index f108ce886cd9..5ce78bc6f02f 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-auto-link-without-protocol/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-auto-link-without-protocol/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-blockquote-without-marker/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-blockquote-without-marker/test/test.js
index e25d6a39b74a..3662d39adf35 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-blockquote-without-marker/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-blockquote-without-marker/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-consecutive-blank-lines/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-consecutive-blank-lines/test/test.js
index 15abb949439d..622dd39a8f87 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-consecutive-blank-lines/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-consecutive-blank-lines/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-definitions/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-definitions/test/test.js
index 08f0e9d72415..6a69d46908d3 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-definitions/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-definitions/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-headings-in-section/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-headings-in-section/test/test.js
index a6c7c2fed62e..68960d3d4bd4 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-headings-in-section/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-headings-in-section/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-headings/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-headings/test/test.js
index 1908a6e10b5b..59442d17a30c 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-headings/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-headings/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-tags/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-tags/test/test.js
index d7421b413ba2..fe8b513f3ec6 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-tags/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-duplicate-tags/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-emphasis-as-heading/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-emphasis-as-heading/test/test.js
index 2ed2165959c5..518b5334d356 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-emphasis-as-heading/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-emphasis-as-heading/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-empty-url/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-empty-url/test/test.js
index eb7d168ee1bc..e0788a02e927 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-empty-url/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-empty-url/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-content-indent/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-content-indent/test/test.js
index be46a2545f92..7d835b1726ca 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-content-indent/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-content-indent/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-indent/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-indent/test/test.js
index c15e0c14bff1..917123a9c28e 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-indent/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-indent/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-like-paragraph/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-like-paragraph/test/test.js
index 5d635c2ae822..eff840293121 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-like-paragraph/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-like-paragraph/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-punctuation/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-punctuation/test/test.js
index e9474f8c7a96..f0f595ad8a03 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-punctuation/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-heading-punctuation/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-html/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-html/test/test.js
index efdaf81872ca..f73f7b7d50c9 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-html/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-html/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-inline-padding/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-inline-padding/test/test.js
index d5c985b87caf..2c39bc823e03 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-inline-padding/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-inline-padding/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-literal-urls/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-literal-urls/test/test.js
index f56b15f2d6f0..bb2e5bb01a25 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-literal-urls/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-literal-urls/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-missing-blank-lines/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-missing-blank-lines/test/test.js
index 3808e0796a1a..866ca0808227 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-missing-blank-lines/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-missing-blank-lines/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-multiple-blank-lines/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-multiple-blank-lines/test/test.js
index 1b1d260047e3..40ce7778d41d 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-multiple-blank-lines/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-multiple-blank-lines/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-multiple-toplevel-headings/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-multiple-toplevel-headings/test/test.js
index d25d846098e1..2dcb0b901ce1 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-multiple-toplevel-headings/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-multiple-toplevel-headings/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-paragraph-content-indent/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-paragraph-content-indent/test/test.js
index 2fc167c82cba..991631d6dcab 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-paragraph-content-indent/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-paragraph-content-indent/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-reference-like-url/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-reference-like-url/test/test.js
index e786342b7a87..98e2578a46c3 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-reference-like-url/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-reference-like-url/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-shell-dollars/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-shell-dollars/test/test.js
index 637f3bc95cf1..50c1b8d44867 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-shell-dollars/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-shell-dollars/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-shortcut-reference-image/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-shortcut-reference-image/test/test.js
index 334306f5c66e..2fc01b022d55 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-shortcut-reference-image/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-shortcut-reference-image/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-shortcut-reference-link/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-shortcut-reference-link/test/test.js
index 581022c426c7..48b9d36dc4de 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-shortcut-reference-link/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-shortcut-reference-link/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-space-aligned-asterisks/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-space-aligned-asterisks/test/test.js
index fded3f8eb1ed..65065f475832 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-space-aligned-asterisks/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-space-aligned-asterisks/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-table-indentation/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-table-indentation/test/test.js
index 61dcb3e14c8a..bbde1f35df31 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-table-indentation/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-table-indentation/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-tabs/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-tabs/test/test.js
index 2bfca20b83c4..f7ee081deea5 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-tabs/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-tabs/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-undefined-references/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-undefined-references/test/test.js
index 3a28f000bbde..f9b4759c0c92 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-undefined-references/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-undefined-references/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-unused-definitions/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-unused-definitions/test/test.js
index 9aa2f6e2e927..9750ed362004 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-unused-definitions/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-no-unused-definitions/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-ordered-list-marker-style/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-ordered-list-marker-style/test/test.js
index 0e5587ce6076..441707e4a6ce 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-ordered-list-marker-style/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-ordered-list-marker-style/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-ordered-list-marker-value/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-ordered-list-marker-value/test/test.js
index 6bf11229e29d..33450410cf01 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-ordered-list-marker-value/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-ordered-list-marker-value/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-private-annotation/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-private-annotation/test/test.js
index b82b7fe88bbb..b1f63744b3ca 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-private-annotation/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-private-annotation/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-require-throws-tags/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-require-throws-tags/test/test.js
index cb7ee5ccf77f..19ac017279df 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-require-throws-tags/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-require-throws-tags/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-rule-style/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-rule-style/test/test.js
index 1bfc01339bce..1dd24f90dc71 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-rule-style/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-rule-style/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-strong-marker/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-strong-marker/test/test.js
index 213bef150e12..fd8deae705ba 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-strong-marker/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-strong-marker/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-table-cell-padding/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-table-cell-padding/test/test.js
index 9506a601362d..70268e466b1b 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-table-cell-padding/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-table-cell-padding/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-table-pipe-alignment/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-table-pipe-alignment/test/test.js
index 150269be041e..86916de07de0 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-table-pipe-alignment/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-table-pipe-alignment/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-table-pipes/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-table-pipes/test/test.js
index 940e036c21f3..714ec813bd48 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-table-pipes/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-table-pipes/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-tag-names/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-tag-names/test/test.js
index 94777dbbdbc3..283050d53918 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-tag-names/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-tag-names/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-tag-order/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-tag-order/test/test.js
index f785f1c10db4..6150313abfb0 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-tag-order/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-tag-order/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-tag-spacing/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-tag-spacing/test/test.js
index a7a516f92a39..6d167fc474dc 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-tag-spacing/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-tag-spacing/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-typedef-typos/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-typedef-typos/test/test.js
index 2609d1357ffb..65e5392fa03b 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-typedef-typos/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-typedef-typos/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-unordered-list-marker-style/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-unordered-list-marker-style/test/test.js
index af5899373b33..06dc220034ba 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-unordered-list-marker-style/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-unordered-list-marker-style/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/line-closing-bracket-spacing/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/line-closing-bracket-spacing/test/test.js
index 8211342fc34f..bb150bf93781 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/line-closing-bracket-spacing/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/line-closing-bracket-spacing/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/module-exports-last/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/module-exports-last/test/test.js
index e2379c74fa2d..d4855f5a4d3f 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/module-exports-last/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/module-exports-last/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/namespace-export-all/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/namespace-export-all/test/test.js
index e3ef81c0597f..92934c44d9fb 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/namespace-export-all/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/namespace-export-all/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/namespace-index-order/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/namespace-index-order/test/test.js
index 80d4924a02df..19e38d69b276 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/namespace-index-order/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/namespace-index-order/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/new-cap-array/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/new-cap-array/test/test.js
index 19900c8d7b1e..48fc969aec08 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/new-cap-array/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/new-cap-array/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/new-cap-error/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/new-cap-error/test/test.js
index 682ecf79b45d..b1a30508b464 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/new-cap-error/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/new-cap-error/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/new-cap-regexp/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/new-cap-regexp/test/test.js
index 7f9b97d0800b..22cfcb425769 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/new-cap-regexp/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/new-cap-regexp/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-builtin-big-int/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-builtin-big-int/test/test.js
index bc3305141a44..1bd0d761ceac 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-builtin-big-int/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-builtin-big-int/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-builtin-math/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-builtin-math/test/test.js
index 45cca787e7ee..0dc3dfdf432d 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-builtin-math/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-builtin-math/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-dynamic-exports/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-dynamic-exports/test/test.js
index e33e7d31aa3c..69cbab65bd65 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-dynamic-exports/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-dynamic-exports/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-dynamic-require/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-dynamic-require/test/test.js
index 9895f6363250..89073b059ec1 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-dynamic-require/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-dynamic-require/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-empty-comments/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-empty-comments/test/test.js
index c3f66970be93..bff084266a06 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-empty-comments/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-empty-comments/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-immediate-require/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-immediate-require/test/test.js
index 6fa0ff9b9c86..d8263a67a555 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-immediate-require/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-immediate-require/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-internal-require/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-internal-require/test/test.js
index 8103a2980b75..45ad111add57 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-internal-require/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-internal-require/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-multiple-empty-lines/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-multiple-empty-lines/test/test.js
index 788bc54023d9..4f49e394d59f 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-multiple-empty-lines/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-multiple-empty-lines/test/test.js
@@ -35,7 +35,7 @@ var invalid = require( './fixtures/invalid.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-nested-require/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-nested-require/test/test.js
index 01c36a1e9f1a..9f00eca0349a 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-nested-require/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-nested-require/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-new-array/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-new-array/test/test.js
index 782627ec4e00..63dbf720e554 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-new-array/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-new-array/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-redeclare/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-redeclare/test/test.js
index e01f0494cd9c..39979dca0771 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-redeclare/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-redeclare/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-require-absolute-path/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-require-absolute-path/test/test.js
index 1ec39aabe6f1..5277ceab2d52 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-require-absolute-path/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-require-absolute-path/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-require-index/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-require-index/test/test.js
index 40db30b4f326..304b8866dd0f 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-require-index/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-require-index/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-self-require/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-self-require/test/test.js
index 491f51e34371..7662a59f2473 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-self-require/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-self-require/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/no-unassigned-require/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/no-unassigned-require/test/test.js
index 9af8e191bd72..32c1ce34f74d 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/no-unassigned-require/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/no-unassigned-require/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/repl-namespace-order/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/repl-namespace-order/test/test.js
index c49ab9f18ac1..c37ad2442feb 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/repl-namespace-order/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/repl-namespace-order/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/require-file-extensions/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/require-file-extensions/test/test.js
index 45800acce9cc..55d8a353a8f9 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/require-file-extensions/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/require-file-extensions/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/require-globals/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/require-globals/test/test.js
index cc839a2294d9..717fb64d3bcf 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/require-globals/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/require-globals/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/require-last-path-relative/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/require-last-path-relative/test/test.js
index 0238b74ac225..368e66904086 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/require-last-path-relative/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/require-last-path-relative/test/test.js
@@ -35,7 +35,7 @@ var invalid = require( './fixtures/invalid.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/require-leading-slash/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/require-leading-slash/test/test.js
index 1496c232ff6b..93bb66cb0545 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/require-leading-slash/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/require-leading-slash/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/require-order/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/require-order/test/test.js
index 36898db9819d..37601401e1a4 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/require-order/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/require-order/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/require-spaces/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/require-spaces/test/test.js
index fec99060439e..04d1bbdde245 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/require-spaces/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/require-spaces/test/test.js
@@ -35,7 +35,7 @@ var invalid = require( './fixtures/invalid.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/section-header-empty-lines/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/section-header-empty-lines/test/test.js
index c84378e87699..df2ea741384b 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/section-header-empty-lines/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/section-header-empty-lines/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/section-headers/test/fixtures/valid.js b/lib/node_modules/@stdlib/_tools/eslint/rules/section-headers/test/fixtures/valid.js
index 3bc001679100..77d6590114be 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/section-headers/test/fixtures/valid.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/section-headers/test/fixtures/valid.js
@@ -99,7 +99,7 @@ test = {
 		'',
 		'tape( \'main export is an object\', function test( t ) {',
 		'  t.ok( true, __filename );',
-		'  t.equal( typeof rule, \'object\', \'main export is an object\' );',
+		'  t.strictEqual( typeof rule, \'object\', \'main export is an object\' );',
 		'  t.end();',
 		'});'
 	].join( '\n' )
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/section-headers/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/section-headers/test/test.js
index 44c69b791f0a..ed43bd533b4f 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/section-headers/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/section-headers/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/ternary-condition-parentheses/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/ternary-condition-parentheses/test/test.js
index 36daee2a5c75..2054814eecaa 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/ternary-condition-parentheses/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/ternary-condition-parentheses/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/test/test.js
index 8ef854042fa4..bd38c2a7a8b0 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/test/test.js
@@ -29,12 +29,12 @@ var ns = require( './../lib' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ns, 'object', 'main export is an object' );
+	t.strictEqual( typeof ns, 'object', 'main export is an object' );
 	t.end();
 });
 
 tape( 'the exported object contains ESLint rules', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/uppercase-required-constants/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/uppercase-required-constants/test/test.js
index cd0ecc95ebf6..efeb281b6601 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/uppercase-required-constants/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/uppercase-required-constants/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/vars-order/test/test.js b/lib/node_modules/@stdlib/_tools/eslint/rules/vars-order/test/test.js
index 8285de24019c..68d3b431275f 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/vars-order/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/vars-order/test/test.js
@@ -36,7 +36,7 @@ var unvalidated = require( './fixtures/unvalidated.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rule, 'object', 'main export is an object' );
+	t.strictEqual( typeof rule, 'object', 'main export is an object' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.data.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.data.js
index fb87ee00bef7..608d0c4e1ddd 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.data.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.data.js
@@ -37,12 +37,12 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof data, 'function', 'main export is a function' );
+	t.strictEqual( typeof data, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.equal( typeof data( 'Big bug', setup() ), 'string', 'returns a string' );
+	t.strictEqual( typeof data( 'Big bug', setup() ), 'string', 'returns a string' );
 	t.end();
 });
 
@@ -68,7 +68,7 @@ tape( 'the function sets the `body` field', function test( t ) {
 	out = data( 'Big bug', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.body, opts.body, 'sets the `body` field' );
+	t.strictEqual( out.body, opts.body, 'sets the `body` field' );
 	t.end();
 });
 
@@ -96,7 +96,7 @@ tape( 'the function sets the `milestone` field', function test( t ) {
 	out = data( 'Big bug', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.milestone, opts.milestone, 'sets the `milestone` field' );
+	t.strictEqual( out.milestone, opts.milestone, 'sets the `milestone` field' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.headers.js
index 6acdfc76efa9..23914b75c73e 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.headers.js
@@ -39,33 +39,33 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof headers, 'function', 'main export is a function' );
+	t.strictEqual( typeof headers, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'if provided a `useragent` option, the function sets the `User-Agent` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
+	t.strictEqual( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
 	t.end();
 });
 
 tape( 'if provided an `accept` option, the function sets the `Accept` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
+	t.strictEqual( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
 	t.end();
 });
 
 tape( 'if provided a `token` option, the function sets the `Authorization` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'Authorization' ], 'token ' +opts.token, 'sets the `Authorization` header' );
+	t.strictEqual( h[ 'Authorization' ], 'token ' +opts.token, 'sets the `Authorization` header' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.js
index fedf3275007a..fd5d48be7595 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.js
@@ -28,6 +28,6 @@ var createIssue = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof createIssue, 'function', 'main export is a function' );
+	t.strictEqual( typeof createIssue, 'function', 'main export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.main.js
index 312d14464e61..73f14b365856 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.main.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof createIssue, 'function', 'main export is a function' );
+	t.strictEqual( typeof createIssue, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -147,8 +147,8 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function done( error ) {
-		t.equal( error instanceof Error, true, 'error instance' );
-		t.equal( error.message, 'beep', 'returns expected value' );
+		t.strictEqual( error instanceof Error, true, 'error instance' );
+		t.strictEqual( error.message, 'beep', 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.options.js
index a017a551c776..119ee7e2928c 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.options.js
@@ -44,40 +44,40 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof options, 'function', 'main export is a function' );
+	t.strictEqual( typeof options, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request method to `POST`', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.method, 'POST', 'method set to `POST`' );
+	t.strictEqual( out.method, 'POST', 'method set to `POST`' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request protocol', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
+	t.strictEqual( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint hostname', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.hostname, opts.hostname, 'sets the endpoint hostname' );
+	t.strictEqual( out.hostname, opts.hostname, 'sets the endpoint hostname' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint port', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.port, opts.port, 'sets the endpoint port' );
+	t.strictEqual( out.port, opts.port, 'sets the endpoint port' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.query.js
index ad467f02dbe1..3276fae42546 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.query.js
@@ -43,7 +43,7 @@ var response = {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof query, 'function', 'export is a function' );
+	t.strictEqual( typeof query, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -92,7 +92,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -119,7 +119,7 @@ tape( 'the function returns response data to a provided callback', function test
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -147,7 +147,7 @@ tape( 'the function returns rate limit info to a provided callback', function te
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -176,7 +176,7 @@ tape( 'the function returns rate limit info to a provided callback (error)', fun
 
 	function done( error, data, info ) {
 		t.ok( error, 'returns an error' );
-		t.equal( data, null, 'no data' );
+		t.strictEqual( data, null, 'no data' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.ratelimit.js
index 867edfab1fc9..eecf98077f9b 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.ratelimit.js
@@ -40,33 +40,33 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ratelimit, 'function', 'main export is a function' );
+	t.strictEqual( typeof ratelimit, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `limit` property', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( hasOwnProp( info, 'limit' ), true, 'has property' );
-	t.equal( info.limit, 5000, 'equals 5000' );
+	t.strictEqual( hasOwnProp( info, 'limit' ), true, 'has property' );
+	t.strictEqual( info.limit, 5000, 'equals 5000' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `remaining` property', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( hasOwnProp( info, 'remaining' ), true, 'has property' );
-	t.equal( info.remaining, 4984, 'equals 4984' );
+	t.strictEqual( hasOwnProp( info, 'remaining' ), true, 'has property' );
+	t.strictEqual( info.remaining, 4984, 'equals 4984' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `reset` property', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( hasOwnProp( info, 'reset' ), true, 'has property' );
-	t.equal( info.reset, 1372700873, 'equals 1372700873' );
+	t.strictEqual( hasOwnProp( info, 'reset' ), true, 'has property' );
+	t.strictEqual( info.reset, 1372700873, 'equals 1372700873' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.request.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.request.js
index ee2fb921b2f4..f3de46ffc618 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.request.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.request.js
@@ -37,7 +37,7 @@ var data = require( './fixtures/results.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof request, 'function', 'main export is a function' );
+	t.strictEqual( typeof request, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -58,9 +58,9 @@ tape( 'if unable to query an endpoint, an error is returned to a provided callba
 	request( opts, string2buffer( '{"body":"beep"}' ), clbk );
 
 	function clbk( error ) {
-		t.equal( typeof error, 'object', 'error is an object' );
-		t.equal( error.status, 500, '500 status' );
-		t.equal( error.message, 'Request error: beep', 'message contains error message' );
+		t.strictEqual( typeof error, 'object', 'error is an object' );
+		t.strictEqual( error.status, 500, '500 status' );
+		t.strictEqual( error.message, 'Request error: beep', 'message contains error message' );
 		t.end();
 	}
 });
@@ -82,10 +82,10 @@ tape( 'if an endpoint returns a status code other than 201, an error containing
 	request( opts, string2buffer( '{"body":"beep"}' ), clbk );
 
 	function clbk( error, response, body ) {
-		t.equal( error.status, 404, 'equal status codes' );
-		t.equal( error.message, 'bad request', 'equal messages' );
-		t.equal( typeof response, 'object', 'second argument is an object' );
-		t.equal( typeof body, 'string', 'third argument is a string' );
+		t.strictEqual( error.status, 404, 'equal status codes' );
+		t.strictEqual( error.message, 'bad request', 'equal messages' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof body, 'string', 'third argument is a string' );
 		t.end();
 	}
 });
@@ -112,10 +112,10 @@ tape( 'if an endpoint returns an invalid JSON response, an error with a status c
 	}
 
 	function clbk( error, response, body ) {
-		t.equal( error.status, 502, 'equal status codes' );
-		t.equal( typeof error.message, 'string', 'error message' );
-		t.equal( typeof response, 'object', 'second argument is an object' );
-		t.equal( typeof body, 'string', 'third argument is a string' );
+		t.strictEqual( error.status, 502, 'equal status codes' );
+		t.strictEqual( typeof error.message, 'string', 'error message' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof body, 'string', 'third argument is a string' );
 		t.end();
 	}
 });
@@ -140,8 +140,8 @@ tape( 'if a query is successful, a JSON object is returned to a provided callbac
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.equal( typeof response, 'object', 'second argument is an object' );
-			t.equal( typeof body, 'object', 'returns an object' );
+			t.strictEqual( typeof response, 'object', 'second argument is an object' );
+			t.strictEqual( typeof body, 'object', 'returns an object' );
 			t.deepEqual( body, data, 'returns expected value' );
 		}
 		t.end();
@@ -168,8 +168,8 @@ tape( 'the function supports HTTPS', function test( t ) {
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.equal( typeof response, 'object', 'second argument is an object' );
-			t.equal( typeof body, 'object', 'returns an object' );
+			t.strictEqual( typeof response, 'object', 'second argument is an object' );
+			t.strictEqual( typeof body, 'object', 'returns an object' );
 			t.deepEqual( body, data, 'returns expected value' );
 		}
 		t.end();
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.validate.js
index 5140fab47709..9c77322a7ba6 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'if an options argument is not an object, the function returns a type erro
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `protocol` option which is not a primitive string, the func
 			'protocol': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'if provided a `protocol` option which is not either `https` or `http`, th
 			'protocol': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof Error, true, 'returns an error when provided ' + values[i] );
+		t.strictEqual( err instanceof Error, true, 'returns an error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'if provided a `hostname` option which is not a primitive string, the func
 			'hostname': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -162,7 +162,7 @@ tape( 'if provided a `port` option which is not a nonnegative integer, the funct
 			'port': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -190,7 +190,7 @@ tape( 'if provided a `body` option which is not a primitive string, the function
 			'body': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -220,7 +220,7 @@ tape( 'if provided a `milestone` option which is not a positive integer, the fun
 			'milestone': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -248,7 +248,7 @@ tape( 'if provided a `title` option which is not a primitive string, the functio
 			'title': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -276,7 +276,7 @@ tape( 'if provided a `token` option which is not a primitive string, the functio
 			'token': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -305,7 +305,7 @@ tape( 'if provided a `labels` option which is not an array of primitive strings,
 			'labels': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -334,7 +334,7 @@ tape( 'if provided a `assignees` option which is not an array of primitive strin
 			'assignees': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -362,7 +362,7 @@ tape( 'if provided a `useragent` option which is not a primitive string, the fun
 			'useragent': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.data.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.data.js
index a33f907a90d7..fe8e75921db4 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.data.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.data.js
@@ -44,12 +44,12 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof data, 'function', 'main export is a function' );
+	t.strictEqual( typeof data, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.equal( typeof data( 'sum_series', setup() ), 'string', 'returns a string' );
+	t.strictEqual( typeof data( 'sum_series', setup() ), 'string', 'returns a string' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function sets the `name` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.name, 'erf', 'sets the `name` field' );
+	t.strictEqual( out.name, 'erf', 'sets the `name` field' );
 	t.end();
 });
 
@@ -73,7 +73,7 @@ tape( 'the function sets the `description` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.description, opts.desc, 'sets the `description` field' );
+	t.strictEqual( out.description, opts.desc, 'sets the `description` field' );
 	t.end();
 });
 
@@ -85,7 +85,7 @@ tape( 'the function sets the `homepage` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.homepage, opts.homepage, 'sets the `homepage` field' );
+	t.strictEqual( out.homepage, opts.homepage, 'sets the `homepage` field' );
 	t.end();
 });
 
@@ -99,7 +99,7 @@ tape( 'the function sets the `team_id` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.team_id, opts.team, 'sets the `team_id` field' );
+	t.strictEqual( out.team_id, opts.team, 'sets the `team_id` field' );
 	t.end();
 });
 
@@ -113,7 +113,7 @@ tape( 'the function sets the `gitignore_template` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.gitignore_template, opts.gitignore, 'sets the `gitignore_template` field' );
+	t.strictEqual( out.gitignore_template, opts.gitignore, 'sets the `gitignore_template` field' );
 	t.end();
 });
 
@@ -127,7 +127,7 @@ tape( 'the function sets the `license_template` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.license_template, opts.license, 'sets the `license_template` field' );
+	t.strictEqual( out.license_template, opts.license, 'sets the `license_template` field' );
 	t.end();
 });
 
@@ -141,7 +141,7 @@ tape( 'the function sets the `private` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.private, opts.private, 'sets the `private` field' );
+	t.strictEqual( out.private, opts.private, 'sets the `private` field' );
 	t.end();
 });
 
@@ -155,7 +155,7 @@ tape( 'the function sets the `has_issues` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.has_issues, opts.issues, 'sets the `has_issues` field' );
+	t.strictEqual( out.has_issues, opts.issues, 'sets the `has_issues` field' );
 	t.end();
 });
 
@@ -169,7 +169,7 @@ tape( 'the function sets the `has_projects` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.has_projects, opts.projects, 'sets the `has_projects` field' );
+	t.strictEqual( out.has_projects, opts.projects, 'sets the `has_projects` field' );
 	t.end();
 });
 
@@ -183,7 +183,7 @@ tape( 'the function sets the `has_wiki` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.has_wiki, opts.wiki, 'sets the `has_wiki` field' );
+	t.strictEqual( out.has_wiki, opts.wiki, 'sets the `has_wiki` field' );
 	t.end();
 });
 
@@ -197,7 +197,7 @@ tape( 'the function sets the `has_downloads` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.has_downloads, opts.downloads, 'sets the `has_downloads` field' );
+	t.strictEqual( out.has_downloads, opts.downloads, 'sets the `has_downloads` field' );
 	t.end();
 });
 
@@ -211,7 +211,7 @@ tape( 'the function sets the `auto_init` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.auto_init, opts.init, 'sets the `auto_init` field' );
+	t.strictEqual( out.auto_init, opts.init, 'sets the `auto_init` field' );
 	t.end();
 });
 
@@ -225,7 +225,7 @@ tape( 'the function sets the `allow_squash_merge` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.allow_squash_merge, opts.allowSquashMerge, 'sets the `allow_squash_merge` field' );
+	t.strictEqual( out.allow_squash_merge, opts.allowSquashMerge, 'sets the `allow_squash_merge` field' );
 	t.end();
 });
 
@@ -239,7 +239,7 @@ tape( 'the function sets the `allow_merge_commit` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.allow_merge_commit, opts.allowMergeCommit, 'sets the `allow_merge_commit` field' );
+	t.strictEqual( out.allow_merge_commit, opts.allowMergeCommit, 'sets the `allow_merge_commit` field' );
 	t.end();
 });
 
@@ -253,6 +253,6 @@ tape( 'the function sets the `allow_rebase_merge` field', function test( t ) {
 	out = data( 'erf', opts );
 	out = JSON.parse( out );
 
-	t.equal( out.allow_rebase_merge, opts.allowRebaseMerge, 'sets the `allow_rebase_merge` field' );
+	t.strictEqual( out.allow_rebase_merge, opts.allowRebaseMerge, 'sets the `allow_rebase_merge` field' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.factory.js
index 12ee26506d76..83c4e7dd88dc 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.factory.js
@@ -38,7 +38,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -87,7 +87,7 @@ tape( 'the function throws if provided a callback argument which is not a functi
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -113,7 +113,7 @@ tape( 'if a `port` option is not specified and the protocol is `https`, the defa
 		return null;
 	}
 	function query( name, opts ) {
-		t.equal( opts.port, 443, 'sets the default port to `443` for HTTPS' );
+		t.strictEqual( opts.port, 443, 'sets the default port to `443` for HTTPS' );
 		t.end();
 	}
 });
@@ -140,7 +140,7 @@ tape( 'if a `port` option is not specified and the protocol is `http`, the defau
 		return null;
 	}
 	function query( name, opts ) {
-		t.equal( opts.port, 80, 'sets the default port to `80` for HTTP' );
+		t.strictEqual( opts.port, 80, 'sets the default port to `80` for HTTP' );
 		t.end();
 	}
 });
@@ -198,7 +198,7 @@ tape( 'the function returns a function which returns an error to a provided call
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.headers.js
index 4aeaf7ed4efb..9a1820b7f112 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.headers.js
@@ -39,33 +39,33 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof headers, 'function', 'main export is a function' );
+	t.strictEqual( typeof headers, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'if provided a `useragent` option, the function sets the `User-Agent` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
+	t.strictEqual( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
 	t.end();
 });
 
 tape( 'if provided an `accept` option, the function sets the `Accept` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
+	t.strictEqual( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
 	t.end();
 });
 
 tape( 'if provided a `token` option, the function sets the `Authorization` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'Authorization' ], 'token ' +opts.token, 'sets the `Authorization` header' );
+	t.strictEqual( h[ 'Authorization' ], 'token ' +opts.token, 'sets the `Authorization` header' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.js
index a1aa59e6776b..9a5d726df8e1 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.js
@@ -28,11 +28,11 @@ var createRepo = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof createRepo, 'function', 'main export is a function' );
+	t.strictEqual( typeof createRepo, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a factory method', function test( t ) {
-	t.equal( typeof createRepo.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof createRepo.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.main.js
index 2c12413c78a4..d5cadb7db18e 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.main.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof create, 'function', 'export is a function' );
+	t.strictEqual( typeof create, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -150,7 +150,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.options.js
index 0ebc4aa824b4..88ee51955fcd 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.options.js
@@ -44,40 +44,40 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof options, 'function', 'main export is a function' );
+	t.strictEqual( typeof options, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request method to `POST`', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.method, 'POST', 'method set to `POST`' );
+	t.strictEqual( out.method, 'POST', 'method set to `POST`' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request protocol', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
+	t.strictEqual( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint hostname', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.hostname, opts.hostname, 'sets the endpoint hostname' );
+	t.strictEqual( out.hostname, opts.hostname, 'sets the endpoint hostname' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint port', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.port, opts.port, 'sets the endpoint port' );
+	t.strictEqual( out.port, opts.port, 'sets the endpoint port' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.query.js
index 15e94e138c47..d925e84a410f 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.query.js
@@ -43,7 +43,7 @@ var response = {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof query, 'function', 'export is a function' );
+	t.strictEqual( typeof query, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -92,7 +92,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -212,7 +212,7 @@ tape( 'function returns rate limit info to a provided callback (error)', functio
 
 	function done( error, data, info ) {
 		t.ok( error, 'returns an error' );
-		t.equal( data, null, 'no data' );
+		t.strictEqual( data, null, 'no data' );
 
 		t.deepEqual( info, expected, 'deep equal' );
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.ratelimit.js
index 065d481497da..7b604422ded7 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.ratelimit.js
@@ -40,33 +40,33 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ratelimit, 'function', 'main export is a function' );
+	t.strictEqual( typeof ratelimit, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `limit` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'limit' ), 'has a `limit` property' );
-	t.equal( info.limit, 5000, 'equals 5000' );
+	t.strictEqual( info.limit, 5000, 'equals 5000' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `remaining` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'remaining' ), 'has a `remaining` property' );
-	t.equal( info.remaining, 4984, 'equals 4984' );
+	t.strictEqual( info.remaining, 4984, 'equals 4984' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `reset` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'reset' ), 'has a `reset` property' );
-	t.equal( info.reset, 1372700873, 'equals 1372700873' );
+	t.strictEqual( info.reset, 1372700873, 'equals 1372700873' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.request.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.request.js
index fbbe6a328fb3..5a02d32da63c 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.request.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.request.js
@@ -36,7 +36,7 @@ var data = require( './fixtures/results.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof request, 'function', 'main export is a function' );
+	t.strictEqual( typeof request, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -57,9 +57,9 @@ tape( 'if unable to query an endpoint, an error is returned to a provided callba
 	request( opts, '{"name":"beep"}', clbk );
 
 	function clbk( error ) {
-		t.equal( typeof error, 'object', 'error is an object' );
-		t.equal( error.status, 500, '500 status' );
-		t.equal( error.message, 'Request error: beep', 'message contains error message' );
+		t.strictEqual( typeof error, 'object', 'error is an object' );
+		t.strictEqual( error.status, 500, '500 status' );
+		t.strictEqual( error.message, 'Request error: beep', 'message contains error message' );
 		t.end();
 	}
 });
@@ -81,12 +81,12 @@ tape( 'if an endpoint returns a status code other than 201, an error containing
 	request( opts, '{"name":"beep"}', clbk );
 
 	function clbk( error, response, body ) {
-		t.equal( error.status, 404, 'equal status codes' );
-		t.equal( error.message, 'bad request', 'equal messages' );
+		t.strictEqual( error.status, 404, 'equal status codes' );
+		t.strictEqual( error.message, 'bad request', 'equal messages' );
 
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'string', 'third argument is a string' );
+		t.strictEqual( typeof body, 'string', 'third argument is a string' );
 
 		t.end();
 	}
@@ -114,12 +114,12 @@ tape( 'if an endpoint returns an invalid JSON response, an error with a status c
 	}
 
 	function clbk( error, response, body ) {
-		t.equal( error.status, 502, 'equal status codes' );
-		t.equal( typeof error.message, 'string', 'error message' );
+		t.strictEqual( error.status, 502, 'equal status codes' );
+		t.strictEqual( typeof error.message, 'string', 'error message' );
 
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'string', 'third argument is a string' );
+		t.strictEqual( typeof body, 'string', 'third argument is a string' );
 
 		t.end();
 	}
@@ -147,9 +147,9 @@ tape( 'if a query is successful, a JSON object is returned to a provided callbac
 			t.end();
 			return;
 		}
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'object', 'returns an object' );
+		t.strictEqual( typeof body, 'object', 'returns an object' );
 		t.deepEqual( body, data, 'deep equal' );
 
 		t.end();
@@ -178,9 +178,9 @@ tape( 'HTTPS is supported', function test( t ) {
 			t.end();
 			return;
 		}
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'object', 'returns an object' );
+		t.strictEqual( typeof body, 'object', 'returns an object' );
 
 		t.deepEqual( body, data, 'deep equal' );
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.validate.js
index 438dbc01b6df..a093341ab051 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -535,7 +535,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets all options' );
 
 	t.end();
@@ -551,7 +551,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.data.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.data.js
index e4636c26456f..7e92b50931e8 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.data.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.data.js
@@ -38,12 +38,12 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof data, 'function', 'main export is a function' );
+	t.strictEqual( typeof data, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.equal( typeof data( setup() ), 'string', 'returns a string' );
+	t.strictEqual( typeof data( setup() ), 'string', 'returns a string' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'the function sets the `note` field', function test( t ) {
 	out = data( opts );
 	out = JSON.parse( out );
 
-	t.equal( out.note, opts.note, 'sets the `note` field' );
+	t.strictEqual( out.note, opts.note, 'sets the `note` field' );
 	t.end();
 });
 
@@ -81,7 +81,7 @@ tape( 'the function sets the `note_url` field', function test( t ) {
 	out = data( opts );
 	out = JSON.parse( out );
 
-	t.equal( out.note_url, opts.note_url, 'sets the `note_url` field' );
+	t.strictEqual( out.note_url, opts.note_url, 'sets the `note_url` field' );
 	t.end();
 });
 
@@ -95,7 +95,7 @@ tape( 'the function sets the `client_id` field', function test( t ) {
 	out = data( opts );
 	out = JSON.parse( out );
 
-	t.equal( out.client_id, opts.client_id, 'sets the `client_id` field' );
+	t.strictEqual( out.client_id, opts.client_id, 'sets the `client_id` field' );
 	t.end();
 });
 
@@ -109,7 +109,7 @@ tape( 'the function sets the `client_secret` field', function test( t ) {
 	out = data( opts );
 	out = JSON.parse( out );
 
-	t.equal( out.client_secret, opts.client_secret, 'sets the `client_secret` field' );
+	t.strictEqual( out.client_secret, opts.client_secret, 'sets the `client_secret` field' );
 	t.end();
 });
 
@@ -123,6 +123,6 @@ tape( 'the function sets the `fingerprint` field', function test( t ) {
 	out = data( opts );
 	out = JSON.parse( out );
 
-	t.equal( out.fingerprint, opts.fingerprint, 'sets the `fingerprint` field' );
+	t.strictEqual( out.fingerprint, opts.fingerprint, 'sets the `fingerprint` field' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.headers.js
index ab410a106821..07c26f966e53 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.headers.js
@@ -39,12 +39,12 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof headers, 'function', 'main export is a function' );
+	t.strictEqual( typeof headers, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'if provided a `useragent` option, the function sets the `User-Agent` head
 
 	h = headers( opts );
 
-	t.equal( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
+	t.strictEqual( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
 	t.end();
 });
 
@@ -70,7 +70,7 @@ tape( 'if provided an `accept` option, the function sets the `Accept` header', f
 
 	h = headers( opts );
 
-	t.equal( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
+	t.strictEqual( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
 	t.end();
 });
 
@@ -84,7 +84,7 @@ tape( 'the function sets the `Authorization` header', function test( t ) {
 
 	expected = 'Basic ' + new Buffer( opts.username+':'+opts.password ).toString( 'base64' );
 
-	t.equal( h[ 'Authorization' ], expected, 'sets the `Authorization` header' );
+	t.strictEqual( h[ 'Authorization' ], expected, 'sets the `Authorization` header' );
 	t.end();
 });
 
@@ -97,12 +97,12 @@ tape( 'if provided an `otp` option, the function sets the `X-GitHub-OTP` header'
 
 	h = headers( opts );
 
-	t.equal( h[ 'X-GitHub-OTP' ], opts.otp, 'sets the `X-GitHub-OTP` header' );
+	t.strictEqual( h[ 'X-GitHub-OTP' ], opts.otp, 'sets the `X-GitHub-OTP` header' );
 	t.end();
 });
 
 tape( 'the function sets the `Content-Type` header to `application/json`', function test( t ) {
 	var h = headers( setup() );
-	t.equal( h[ 'Content-Type' ], 'application/json', 'sets the `Content-Type`' );
+	t.strictEqual( h[ 'Content-Type' ], 'application/json', 'sets the `Content-Type`' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.js
index 72be4c1795aa..bebff0ed930d 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.js
@@ -28,6 +28,6 @@ var createToken = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof createToken, 'function', 'main export is a function' );
+	t.strictEqual( typeof createToken, 'function', 'main export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.main.js
index b15228d39a85..1da9621220a1 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.main.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof create, 'function', 'export is a function' );
+	t.strictEqual( typeof create, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -122,7 +122,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -147,7 +147,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -235,9 +235,9 @@ tape( 'function returns rate limit info to a provided callback (error)', functio
 
 	function done( error, data, info ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 
-		t.equal( data, null, 'data is null' );
+		t.strictEqual( data, null, 'data is null' );
 
 		t.deepEqual( info, expected, 'deep equal' );
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.options.js
index e55f9b968d5a..ba3845cab823 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.options.js
@@ -46,40 +46,40 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof options, 'function', 'main export is a function' );
+	t.strictEqual( typeof options, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request method to `POST`', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.method, 'POST', 'method set to `POST`' );
+	t.strictEqual( out.method, 'POST', 'method set to `POST`' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request protocol', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
+	t.strictEqual( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint hostname', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.hostname, opts.hostname, 'sets the endpoint hostname' );
+	t.strictEqual( out.hostname, opts.hostname, 'sets the endpoint hostname' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint port', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.port, opts.port, 'sets the endpoint port' );
+	t.strictEqual( out.port, opts.port, 'sets the endpoint port' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.query.js
index e48d81ee4a8f..73a29b4d985c 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.query.js
@@ -43,7 +43,7 @@ var response = {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof query, 'function', 'export is a function' );
+	t.strictEqual( typeof query, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -92,7 +92,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -180,7 +180,7 @@ tape( 'function returns rate limit info to a provided callback (error)', functio
 
 	function done( error, data, info ) {
 		t.ok( error, 'returns an error' );
-		t.equal( data, null, 'no data' );
+		t.strictEqual( data, null, 'no data' );
 
 		t.deepEqual( info, expected, 'deep equal' );
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.ratelimit.js
index 065d481497da..7b604422ded7 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.ratelimit.js
@@ -40,33 +40,33 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ratelimit, 'function', 'main export is a function' );
+	t.strictEqual( typeof ratelimit, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `limit` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'limit' ), 'has a `limit` property' );
-	t.equal( info.limit, 5000, 'equals 5000' );
+	t.strictEqual( info.limit, 5000, 'equals 5000' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `remaining` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'remaining' ), 'has a `remaining` property' );
-	t.equal( info.remaining, 4984, 'equals 4984' );
+	t.strictEqual( info.remaining, 4984, 'equals 4984' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `reset` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'reset' ), 'has a `reset` property' );
-	t.equal( info.reset, 1372700873, 'equals 1372700873' );
+	t.strictEqual( info.reset, 1372700873, 'equals 1372700873' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.request.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.request.js
index c5addef2da6f..a39c95b25562 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.request.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.request.js
@@ -36,7 +36,7 @@ var data = require( './fixtures/results.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof request, 'function', 'main export is a function' );
+	t.strictEqual( typeof request, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -57,9 +57,9 @@ tape( 'if unable to query an endpoint, an error is returned to a provided callba
 	request( opts, '{"scopes":["public_repo"],"note":"beep"}', clbk );
 
 	function clbk( error ) {
-		t.equal( typeof error, 'object', 'error is an object' );
-		t.equal( error.status, 500, '500 status' );
-		t.equal( error.message, 'Request error: beep', 'message contains error message' );
+		t.strictEqual( typeof error, 'object', 'error is an object' );
+		t.strictEqual( error.status, 500, '500 status' );
+		t.strictEqual( error.message, 'Request error: beep', 'message contains error message' );
 		t.end();
 	}
 });
@@ -81,12 +81,12 @@ tape( 'if an endpoint returns a status code other than 201, an error containing
 	request( opts, '{"scopes":["public_repo"],"note":"beep"}', clbk );
 
 	function clbk( error, response, body ) {
-		t.equal( error.status, 404, 'equal status codes' );
-		t.equal( error.message, 'bad request', 'equal messages' );
+		t.strictEqual( error.status, 404, 'equal status codes' );
+		t.strictEqual( error.message, 'bad request', 'equal messages' );
 
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'string', 'third argument is a string' );
+		t.strictEqual( typeof body, 'string', 'third argument is a string' );
 
 		t.end();
 	}
@@ -114,12 +114,12 @@ tape( 'if an endpoint returns an invalid JSON response, an error with a status c
 	}
 
 	function clbk( error, response, body ) {
-		t.equal( error.status, 502, 'equal status codes' );
-		t.equal( typeof error.message, 'string', 'error message' );
+		t.strictEqual( error.status, 502, 'equal status codes' );
+		t.strictEqual( typeof error.message, 'string', 'error message' );
 
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'string', 'third argument is a string' );
+		t.strictEqual( typeof body, 'string', 'third argument is a string' );
 
 		t.end();
 	}
@@ -147,9 +147,9 @@ tape( 'if a query is successful, a JSON object is returned to a provided callbac
 			t.end();
 			return;
 		}
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'object', 'returns an object' );
+		t.strictEqual( typeof body, 'object', 'returns an object' );
 		t.deepEqual( body, data, 'deep equal' );
 
 		t.end();
@@ -178,9 +178,9 @@ tape( 'HTTPS is supported', function test( t ) {
 			t.end();
 			return;
 		}
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'object', 'returns an object' );
+		t.strictEqual( typeof body, 'object', 'returns an object' );
 
 		t.deepEqual( body, data, 'deep equal' );
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.validate.js
index 070137eb7fa3..38837c6a942b 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -409,7 +409,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets all options' );
 
 	t.end();
@@ -428,7 +428,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.headers.js
index 996c8d872a44..c6edc2d9319e 100644
--- a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.headers.js
@@ -39,12 +39,12 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof headers, 'function', 'main export is a function' );
+	t.strictEqual( typeof headers, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'if provided a `useragent` option, the function sets the `User-Agent` head
 
 	h = headers( opts );
 
-	t.equal( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
+	t.strictEqual( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
 	t.end();
 });
 
@@ -70,7 +70,7 @@ tape( 'if provided an `accept` option, the function sets the `Accept` header', f
 
 	h = headers( opts );
 
-	t.equal( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
+	t.strictEqual( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
 	t.end();
 });
 
@@ -84,7 +84,7 @@ tape( 'the function sets the `Authorization` header', function test( t ) {
 
 	expected = 'Basic ' + new Buffer( opts.username+':'+opts.password ).toString( 'base64' );
 
-	t.equal( h[ 'Authorization' ], expected, 'sets the `Authorization` header' );
+	t.strictEqual( h[ 'Authorization' ], expected, 'sets the `Authorization` header' );
 	t.end();
 });
 
@@ -97,6 +97,6 @@ tape( 'if provided an `otp` option, the function sets the `X-GitHub-OTP` header'
 
 	h = headers( opts );
 
-	t.equal( h[ 'X-GitHub-OTP' ], opts.otp, 'sets the `X-GitHub-OTP` header' );
+	t.strictEqual( h[ 'X-GitHub-OTP' ], opts.otp, 'sets the `X-GitHub-OTP` header' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.js b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.js
index dac3a2dfcb8f..c16fb867b333 100644
--- a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.js
@@ -28,6 +28,6 @@ var deleteToken = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof deleteToken, 'function', 'main export is a function' );
+	t.strictEqual( typeof deleteToken, 'function', 'main export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.main.js
index 80a76e87f8fa..fe48ebcc875b 100644
--- a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.main.js
@@ -28,15 +28,15 @@ var del = require( './../lib/main.js' );
 
 // FIXTURES //
 
-var getOpts = require( './fixtures/opts' );
-var info = require( './fixtures/info' );
+var getOpts = require( './fixtures/opts.js' );
+var info = require( './fixtures/info.json' );
 
 
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof del, 'function', 'export is a function' );
+	t.strictEqual( typeof del, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -150,7 +150,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -175,7 +175,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -233,7 +233,7 @@ tape( 'function returns rate limit info to a provided callback (error)', functio
 
 	function done( error, info ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 
 		t.deepEqual( info, expected, 'deep equal' );
 
diff --git a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.options.js
index 07db7c28cb88..593eb517258f 100644
--- a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.options.js
@@ -46,40 +46,40 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof options, 'function', 'main export is a function' );
+	t.strictEqual( typeof options, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request method to `DELETE`', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.method, 'DELETE', 'method set to `DELETE`' );
+	t.strictEqual( out.method, 'DELETE', 'method set to `DELETE`' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request protocol', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
+	t.strictEqual( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint hostname', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.hostname, opts.hostname, 'sets the endpoint hostname' );
+	t.strictEqual( out.hostname, opts.hostname, 'sets the endpoint hostname' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint port', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.port, opts.port, 'sets the endpoint port' );
+	t.strictEqual( out.port, opts.port, 'sets the endpoint port' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.query.js
index 1d65154bfd93..fe12041254ff 100644
--- a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.query.js
@@ -43,7 +43,7 @@ var tokenID = 1;
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof query, 'function', 'export is a function' );
+	t.strictEqual( typeof query, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -92,7 +92,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.ratelimit.js
index 065d481497da..7b604422ded7 100644
--- a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.ratelimit.js
@@ -40,33 +40,33 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ratelimit, 'function', 'main export is a function' );
+	t.strictEqual( typeof ratelimit, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `limit` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'limit' ), 'has a `limit` property' );
-	t.equal( info.limit, 5000, 'equals 5000' );
+	t.strictEqual( info.limit, 5000, 'equals 5000' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `remaining` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'remaining' ), 'has a `remaining` property' );
-	t.equal( info.remaining, 4984, 'equals 4984' );
+	t.strictEqual( info.remaining, 4984, 'equals 4984' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `reset` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'reset' ), 'has a `reset` property' );
-	t.equal( info.reset, 1372700873, 'equals 1372700873' );
+	t.strictEqual( info.reset, 1372700873, 'equals 1372700873' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.request.js b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.request.js
index 0bbe299c05ce..13a46640a93c 100644
--- a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.request.js
+++ b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.request.js
@@ -35,7 +35,7 @@ var http = require( './fixtures/http.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof request, 'function', 'main export is a function' );
+	t.strictEqual( typeof request, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -56,9 +56,9 @@ tape( 'if unable to query an endpoint, an error is returned to a provided callba
 	request( opts, clbk );
 
 	function clbk( error ) {
-		t.equal( typeof error, 'object', 'error is an object' );
-		t.equal( error.status, 500, '500 status' );
-		t.equal( error.message, 'Request error: beep', 'message contains error message' );
+		t.strictEqual( typeof error, 'object', 'error is an object' );
+		t.strictEqual( error.status, 500, '500 status' );
+		t.strictEqual( error.message, 'Request error: beep', 'message contains error message' );
 		t.end();
 	}
 });
@@ -80,12 +80,12 @@ tape( 'if an endpoint returns a status code other than 204, an error containing
 	request( opts, clbk );
 
 	function clbk( error, response, body ) {
-		t.equal( error.status, 404, 'equal status codes' );
-		t.equal( error.message, 'bad request', 'equal messages' );
+		t.strictEqual( error.status, 404, 'equal status codes' );
+		t.strictEqual( error.message, 'bad request', 'equal messages' );
 
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'string', 'third argument is a string' );
+		t.strictEqual( typeof body, 'string', 'third argument is a string' );
 
 		t.end();
 	}
@@ -113,7 +113,7 @@ tape( 'HTTPS is supported', function test( t ) {
 			t.end();
 			return;
 		}
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.validate.js
index 32e9b0010c77..13861587c9b7 100644
--- a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -192,7 +192,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets all options' );
 
 	t.end();
@@ -209,7 +209,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.data.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.data.js
index 90a6176925e7..011720afc101 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.data.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.data.js
@@ -37,12 +37,12 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof data, 'function', 'main export is a function' );
+	t.strictEqual( typeof data, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.equal( typeof data( setup() ), 'string', 'returns a string' );
+	t.strictEqual( typeof data( setup() ), 'string', 'returns a string' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.headers.js
index fa0c52d3835b..f01ccb8dba2b 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.headers.js
@@ -39,33 +39,33 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof headers, 'function', 'main export is a function' );
+	t.strictEqual( typeof headers, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'if provided a `useragent` option, the function sets the `User-Agent` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
+	t.strictEqual( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
 	t.end();
 });
 
 tape( 'if provided an `accept` option, the function sets the `Accept` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
+	t.strictEqual( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
 	t.end();
 });
 
 tape( 'if provided a `token` option, the function sets the `Authorization` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'Authorization' ], 'token ' +opts.token, 'sets the `Authorization` header' );
+	t.strictEqual( h[ 'Authorization' ], 'token ' +opts.token, 'sets the `Authorization` header' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.js
index 7502b76c490c..03c987c5b073 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.js
@@ -28,6 +28,6 @@ var dispatch = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof dispatch, 'function', 'main export is a function' );
+	t.strictEqual( typeof dispatch, 'function', 'main export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.main.js
index c5b929c42e61..9d26d16077a1 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.main.js
@@ -36,7 +36,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof dispatch, 'function', 'main export is a function' );
+	t.strictEqual( typeof dispatch, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -146,8 +146,8 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function done( error ) {
-		t.equal( error instanceof Error, true, 'error instance' );
-		t.equal( error.message, 'beep', 'returns expected value' );
+		t.strictEqual( error instanceof Error, true, 'error instance' );
+		t.strictEqual( error.message, 'beep', 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.options.js
index 293ab954fc21..0680d6b40a02 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.options.js
@@ -44,40 +44,40 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof options, 'function', 'main export is a function' );
+	t.strictEqual( typeof options, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request method to `POST`', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.method, 'POST', 'method set to `POST`' );
+	t.strictEqual( out.method, 'POST', 'method set to `POST`' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request protocol', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
+	t.strictEqual( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint hostname', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.hostname, opts.hostname, 'sets the endpoint hostname' );
+	t.strictEqual( out.hostname, opts.hostname, 'sets the endpoint hostname' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint port', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.port, opts.port, 'sets the endpoint port' );
+	t.strictEqual( out.port, opts.port, 'sets the endpoint port' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.query.js
index e05e20920288..9ebad176e94b 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.query.js
@@ -42,7 +42,7 @@ var response = {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof query, 'function', 'export is a function' );
+	t.strictEqual( typeof query, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -66,7 +66,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -91,7 +91,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -118,7 +118,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.ratelimit.js
index 4795f5ca50d0..bbcc90900aa6 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.ratelimit.js
@@ -40,33 +40,33 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ratelimit, 'function', 'main export is a function' );
+	t.strictEqual( typeof ratelimit, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `limit` property', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( hasOwnProp( info, 'limit' ), true, 'has property' );
-	t.equal( info.limit, 5000, 'equals 5000' );
+	t.strictEqual( hasOwnProp( info, 'limit' ), true, 'has property' );
+	t.strictEqual( info.limit, 5000, 'equals 5000' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `remaining` property', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( hasOwnProp( info, 'remaining' ), true, 'has property' );
-	t.equal( info.remaining, 4984, 'equals 4984' );
+	t.strictEqual( hasOwnProp( info, 'remaining' ), true, 'has property' );
+	t.strictEqual( info.remaining, 4984, 'equals 4984' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `reset` property', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( hasOwnProp( info, 'reset' ), true, 'has property' );
-	t.equal( info.reset, 1372700873, 'equals 1372700873' );
+	t.strictEqual( hasOwnProp( info, 'reset' ), true, 'has property' );
+	t.strictEqual( info.reset, 1372700873, 'equals 1372700873' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.request.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.request.js
index 2147f92f2210..33b77ab0bec5 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.request.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.request.js
@@ -36,7 +36,7 @@ var http = require( './fixtures/http.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof request, 'function', 'main export is a function' );
+	t.strictEqual( typeof request, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -57,9 +57,9 @@ tape( 'if unable to query an endpoint, an error is returned to a provided callba
 	request( opts, string2buffer( '{"body":"beep"}' ), clbk );
 
 	function clbk( error ) {
-		t.equal( typeof error, 'object', 'error is an object' );
-		t.equal( error.status, 500, '500 status' );
-		t.equal( error.message, 'Request error: beep', 'message contains error message' );
+		t.strictEqual( typeof error, 'object', 'error is an object' );
+		t.strictEqual( error.status, 500, '500 status' );
+		t.strictEqual( error.message, 'Request error: beep', 'message contains error message' );
 		t.end();
 	}
 });
@@ -81,10 +81,10 @@ tape( 'if an endpoint returns a status code other than 204, an error containing
 	request( opts, string2buffer( '{"body":"beep"}' ), clbk );
 
 	function clbk( error, response, body ) {
-		t.equal( error.status, 404, 'equal status codes' );
-		t.equal( error.message, 'bad request', 'equal messages' );
-		t.equal( typeof response, 'object', 'second argument is an object' );
-		t.equal( typeof body, 'string', 'third argument is a string' );
+		t.strictEqual( error.status, 404, 'equal status codes' );
+		t.strictEqual( error.message, 'bad request', 'equal messages' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof body, 'string', 'third argument is a string' );
 		t.end();
 	}
 });
@@ -109,7 +109,7 @@ tape( 'the function supports HTTPS', function test( t ) {
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.equal( typeof response, 'object', 'second argument is an object' );
+			t.strictEqual( typeof response, 'object', 'second argument is an object' );
 		}
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.validate.js
index 7b7af37181e0..69f2595d5bca 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'if an options argument is not an object, the function returns a type erro
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `protocol` option which is not a primitive string, the func
 			'protocol': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'if provided a `protocol` option which is not either `https` or `http`, th
 			'protocol': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof Error, true, 'returns an error when provided ' + values[i] );
+		t.strictEqual( err instanceof Error, true, 'returns an error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'if provided a `hostname` option which is not a primitive string, the func
 			'hostname': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -162,7 +162,7 @@ tape( 'if provided a `port` option which is not a nonnegative integer, the funct
 			'port': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -190,7 +190,7 @@ tape( 'if provided a `ref` option which is not a primitive string, the function
 			'ref': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -218,7 +218,7 @@ tape( 'if provided a `token` option which is not a primitive string, the functio
 			'token': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -246,7 +246,7 @@ tape( 'if provided a `inputs` option which is not a plain object, the function r
 			'inputs': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -274,7 +274,7 @@ tape( 'if provided a `useragent` option which is not a primitive string, the fun
 			'useragent': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.factory.js
index 816a1f5b4ea1..fbab8e4ba790 100644
--- a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.factory.js
@@ -36,7 +36,7 @@ var repos = require( './fixtures/repos.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -125,7 +125,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( 'README.md', repos, noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( 'README.md', repos, noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -151,8 +151,8 @@ tape( 'function returns a function which returns an error to a provided callback
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -179,7 +179,7 @@ tape( 'function returns a function which returns a repo hash containing file con
 	}
 
 	function done( error, results ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( results, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.js b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.js
index cfe6738b8c66..277af506e1b2 100644
--- a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.js
@@ -28,11 +28,11 @@ var fetchFile = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof fetchFile, 'function', 'main export is a function' );
+	t.strictEqual( typeof fetchFile, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof fetchFile.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof fetchFile.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.main.js
index 28e6e796fd5c..99a39ad292ce 100644
--- a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.main.js
@@ -35,7 +35,7 @@ var repos = require( './fixtures/repos.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof fetchFile, 'function', 'export is a function' );
+	t.strictEqual( typeof fetchFile, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -61,8 +61,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -89,7 +89,7 @@ tape( 'functions returns a repo hash containing file contents to a provided call
 	}
 
 	function done( error, results ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( results, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.options.js
index 743d11cdd0a7..c4865dcd3754 100644
--- a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.options.js
@@ -41,39 +41,39 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof options, 'function', 'main export is a function' );
+	t.strictEqual( typeof options, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request method to `GET`', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.method, 'GET', 'method set to `GET`' );
+	t.strictEqual( out.method, 'GET', 'method set to `GET`' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request protocol', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
+	t.strictEqual( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint hostname', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.hostname, opts.hostname, 'sets the endpoint hostname' );
+	t.strictEqual( out.hostname, opts.hostname, 'sets the endpoint hostname' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint port', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.port, opts.port, 'sets the endpoint port' );
+	t.strictEqual( out.port, opts.port, 'sets the endpoint port' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.request.js b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.request.js
index e5c41ed93cf7..579322a12931 100644
--- a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.request.js
+++ b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.request.js
@@ -36,7 +36,7 @@ var http = require( './fixtures/http.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof request, 'function', 'main export is a function' );
+	t.strictEqual( typeof request, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -57,9 +57,9 @@ tape( 'if unable to query an endpoint, an error is returned to a provided callba
 	request( opts, clbk );
 
 	function clbk( error ) {
-		t.equal( typeof error, 'object', 'error is an object' );
-		t.equal( error.status, 500, '500 status' );
-		t.equal( error.message, 'Request error: beep', 'message contains error message' );
+		t.strictEqual( typeof error, 'object', 'error is an object' );
+		t.strictEqual( error.status, 500, '500 status' );
+		t.strictEqual( error.message, 'Request error: beep', 'message contains error message' );
 		t.end();
 	}
 });
@@ -81,12 +81,12 @@ tape( 'if an endpoint returns a status code other than 200, an error containing
 	request( opts, clbk );
 
 	function clbk( error, response, body ) {
-		t.equal( error.status, 404, 'equal status codes' );
-		t.equal( error.message, 'bad request', 'equal messages' );
+		t.strictEqual( error.status, 404, 'equal status codes' );
+		t.strictEqual( error.message, 'bad request', 'equal messages' );
 
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'string', 'third argument is a string' );
+		t.strictEqual( typeof body, 'string', 'third argument is a string' );
 
 		t.end();
 	}
@@ -114,11 +114,11 @@ tape( 'if a query is successful, the response body is returned to a provided cal
 			t.end();
 			return;
 		}
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'string', 'body is a string' );
+		t.strictEqual( typeof body, 'string', 'body is a string' );
 
-		t.equal( body, 'beep', 'body equals beep' );
+		t.strictEqual( body, 'beep', 'body equals beep' );
 
 		t.end();
 	}
@@ -146,11 +146,11 @@ tape( 'HTTPS is supported', function test( t ) {
 			t.end();
 			return;
 		}
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'string', 'body is a string' );
+		t.strictEqual( typeof body, 'string', 'body is a string' );
 
-		t.equal( body, 'beep', 'body equals beep' );
+		t.strictEqual( body, 'beep', 'body equals beep' );
 
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.resolve.js b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.resolve.js
index 9138ef2b9ba1..880bb0802dca 100644
--- a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.resolve.js
+++ b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.resolve.js
@@ -37,7 +37,7 @@ var repos = require( './fixtures/repos.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof resolve, 'function', 'export is a function' );
+	t.strictEqual( typeof resolve, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -63,8 +63,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 500, 'equal status' );
-		t.equal( error.message, 'bad request', 'equal message' );
+		t.strictEqual( error.status, 500, 'equal status' );
+		t.strictEqual( error.message, 'bad request', 'equal message' );
 		t.end();
 	}
 });
@@ -91,8 +91,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 500, 'equal status' );
-		t.equal( error.message, 'bad request', 'equal message' );
+		t.strictEqual( error.status, 500, 'equal status' );
+		t.strictEqual( error.message, 'bad request', 'equal message' );
 		t.end();
 	}
 });
@@ -119,7 +119,7 @@ tape( 'the function returns a JSON object upon attempting to resolve a file from
 		if ( error ) {
 			t.ok( false, error.message );
 		} else {
-			t.equal( typeof results, 'object', 'returns an object' );
+			t.strictEqual( typeof results, 'object', 'returns an object' );
 		}
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/followers/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/followers/test/test.factory.js
index 2af4f7bfa650..65432485cb2f 100644
--- a/lib/node_modules/@stdlib/_tools/github/followers/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/followers/test/test.factory.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -97,7 +97,7 @@ tape( 'function throws if not provided either a username or token', function tes
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -129,8 +129,8 @@ tape( 'function returns a function which returns an error to a provided callback
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/followers/test/test.js b/lib/node_modules/@stdlib/_tools/github/followers/test/test.js
index 16c1542e7552..3b9146f8847f 100644
--- a/lib/node_modules/@stdlib/_tools/github/followers/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/followers/test/test.js
@@ -28,11 +28,11 @@ var followers = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof followers, 'function', 'main export is a function' );
+	t.strictEqual( typeof followers, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof followers.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof followers.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/followers/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/followers/test/test.main.js
index 54a101149d67..dfb67b2124d3 100644
--- a/lib/node_modules/@stdlib/_tools/github/followers/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/followers/test/test.main.js
@@ -36,7 +36,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof get, 'function', 'export is a function' );
+	t.strictEqual( typeof get, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -64,8 +64,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -94,7 +94,7 @@ tape( 'functions returns response data to a provided callback', function test( t
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -124,7 +124,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -156,7 +156,7 @@ tape( 'function supports providing only a `username` option (no authentication)'
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -188,7 +188,7 @@ tape( 'function supports providing only a `token` option (get the authenticated
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -221,7 +221,7 @@ tape( 'function supports providing both `token` and `username` options to get an
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/followers/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/followers/test/test.validate.js
index 7e9e6d67a9d5..d01a55d4fcc6 100644
--- a/lib/node_modules/@stdlib/_tools/github/followers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/followers/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -138,7 +138,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'username': 'beepboop',
 		'useragent': 'beeper-booper'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/following/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/following/test/test.factory.js
index f76c4555a085..6086cec13916 100644
--- a/lib/node_modules/@stdlib/_tools/github/following/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/following/test/test.factory.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -97,7 +97,7 @@ tape( 'function throws if not provided either a username or token', function tes
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -129,8 +129,8 @@ tape( 'function returns a function which returns an error to a provided callback
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -163,7 +163,7 @@ tape( 'function returns a function which returns response data to a provided cal
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -197,7 +197,7 @@ tape( 'function returns a function which returns rate limit info to a provided c
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -233,7 +233,7 @@ tape( 'function returns a function which supports providing only a `username` op
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -269,7 +269,7 @@ tape( 'function returns a function which supports providing only a `token` optio
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -306,7 +306,7 @@ tape( 'function returns a function which supports providing both `token` and `us
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/following/test/test.js b/lib/node_modules/@stdlib/_tools/github/following/test/test.js
index c7ebde3e039f..1014e434ab40 100644
--- a/lib/node_modules/@stdlib/_tools/github/following/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/following/test/test.js
@@ -28,11 +28,11 @@ var following = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof following, 'function', 'main export is a function' );
+	t.strictEqual( typeof following, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof following.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof following.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/following/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/following/test/test.main.js
index db9011a615ec..e5c16ae192f0 100644
--- a/lib/node_modules/@stdlib/_tools/github/following/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/following/test/test.main.js
@@ -36,7 +36,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof get, 'function', 'export is a function' );
+	t.strictEqual( typeof get, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -64,8 +64,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -94,7 +94,7 @@ tape( 'functions returns response data to a provided callback', function test( t
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -124,7 +124,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -156,7 +156,7 @@ tape( 'function supports providing only a `username` option (no authentication)'
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -188,7 +188,7 @@ tape( 'function supports providing only a `token` option (get who the authentica
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -221,7 +221,7 @@ tape( 'function supports providing both `token` and `username` options to get wh
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/following/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/following/test/test.validate.js
index 7e9e6d67a9d5..d01a55d4fcc6 100644
--- a/lib/node_modules/@stdlib/_tools/github/following/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/following/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -138,7 +138,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'username': 'beepboop',
 		'useragent': 'beeper-booper'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.cache.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.cache.js
index 8f43cbde7369..e015b573c12d 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.cache.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.cache.js
@@ -29,13 +29,13 @@ var create = require( './../lib/cache.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof create, 'function', 'main export is a function' );
+	t.strictEqual( typeof create, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a cache of a specified size', function test( t ) {
 	var cache = create( 10 );
-	t.equal( isArray( cache ), true, 'returns an array' );
-	t.equal( cache.length, 10, 'has length 10' );
+	t.strictEqual( isArray( cache ), true, 'returns an array' );
+	t.strictEqual( cache.length, 10, 'has length 10' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.checklimit.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.checklimit.js
index b1f008302cc7..54e6c1fa39a1 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.checklimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.checklimit.js
@@ -41,7 +41,7 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof checklimit, 'function', 'main export is a function' );
+	t.strictEqual( typeof checklimit, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.factory.js
index 6f72e2928f8f..75876ee52f81 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.factory.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'main export is a function' );
+	t.strictEqual( typeof factory, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -129,7 +129,7 @@ tape( 'the function throws if provided a callback argument which is not a functi
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -150,7 +150,7 @@ tape( 'if a `port` option is not specified and the protocol is `https`, the defa
 	fcn();
 
 	function resolve( opts ) {
-		t.equal( opts.port, 443, 'sets the default port to `443` for HTTPS' );
+		t.strictEqual( opts.port, 443, 'sets the default port to `443` for HTTPS' );
 		t.end();
 	}
 });
@@ -172,7 +172,7 @@ tape( 'if a `port` option is not specified and the protocol is `http`, the defau
 	fcn();
 
 	function resolve( opts ) {
-		t.equal( opts.port, 80, 'sets the default port to `80` for HTTP' );
+		t.strictEqual( opts.port, 80, 'sets the default port to `80` for HTTP' );
 		t.end();
 	}
 });
@@ -198,8 +198,8 @@ tape( 'the function returns a function which returns an error to a provided call
 	}
 
 	function done( error ) {
-		t.equal( error instanceof Error, true, 'error instance' );
-		t.equal( error.message, 'beep', 'returns expected value' );
+		t.strictEqual( error instanceof Error, true, 'error instance' );
+		t.strictEqual( error.message, 'beep', 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.flatten.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.flatten.js
index 3df3276eda52..0d78dd27d916 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.flatten.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.flatten.js
@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var filled = require( '@stdlib/array/base/filled' );
 var flatten = require( './../lib/flatten.js' );
 
 
@@ -28,7 +29,7 @@ var flatten = require( './../lib/flatten.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof flatten, 'function', 'main export is a function' );
+	t.strictEqual( typeof flatten, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +52,7 @@ tape( 'the function flattens an array which includes missing values', function t
 	var actual;
 	var arr;
 
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = [ 1, 2 ];
 	arr[ 2 ] = [ 5, 6 ];
 
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.headers.js
index 714d1f710c18..890fcee7b969 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.headers.js
@@ -39,33 +39,33 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof headers, 'function', 'main export is a function' );
+	t.strictEqual( typeof headers, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'if provided a `useragent` option, the function sets the `User-Agent` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
+	t.strictEqual( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
 	t.end();
 });
 
 tape( 'if provided an `accept` option, the function sets the `Accept` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
+	t.strictEqual( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
 	t.end();
 });
 
 tape( 'if provided a `token` option, the function sets the `Authorization` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'Authorization' ], 'token ' +opts.token, 'sets the `Authorization` header' );
+	t.strictEqual( h[ 'Authorization' ], 'token ' +opts.token, 'sets the `Authorization` header' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.js
index 0d8831773711..04d672f9015a 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.js
@@ -28,11 +28,11 @@ var get = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof get, 'function', 'main export is a function' );
+	t.strictEqual( typeof get, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a factory method', function test( t ) {
-	t.equal( typeof get.factory, 'function', 'has method' );
+	t.strictEqual( typeof get.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.lastpage.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.lastpage.js
index d146ea61b060..e5eddfc63c5b 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.lastpage.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.lastpage.js
@@ -28,24 +28,24 @@ var lastPage = require( './../lib/lastpage.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof lastPage, 'function', 'main export is a function' );
+	t.strictEqual( typeof lastPage, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'if provided a last page option equal to "last", the function returns the last linked page', function test( t ) {
 	var last = lastPage( 'last', 6 );
-	t.equal( last, 6, 'returns expected value' );
+	t.strictEqual( last, 6, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a last page option equal to or exceeding the last linked page, the function returns the last linked page', function test( t ) {
 	var last = lastPage( 10, 6 );
-	t.equal( last, 6, 'returns expected value' );
+	t.strictEqual( last, 6, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a last page option less than the last linked page, the function returns the last page option value', function test( t ) {
 	var last = lastPage( 4, 6 );
-	t.equal( last, 4, 'returns expected value' );
+	t.strictEqual( last, 4, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.main.js
index 1574b6cf6635..fa3c9e91d47a 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.main.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof get, 'function', 'main export is a function' );
+	t.strictEqual( typeof get, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -151,8 +151,8 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function done( error ) {
-		t.equal( error instanceof Error, true, 'error instance' );
-		t.equal( error.message, 'beep', 'returns expected value' );
+		t.strictEqual( error instanceof Error, true, 'error instance' );
+		t.strictEqual( error.message, 'beep', 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.options.js
index fd8ba0571204..974b8ceb7dce 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.options.js
@@ -44,40 +44,40 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof options, 'function', 'main export is a function' );
+	t.strictEqual( typeof options, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request method to `GET`', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.method, 'GET', 'method set to `GET`' );
+	t.strictEqual( out.method, 'GET', 'method set to `GET`' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request protocol', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
+	t.strictEqual( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint hostname', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.hostname, opts.hostname, 'sets the endpoint hostname' );
+	t.strictEqual( out.hostname, opts.hostname, 'sets the endpoint hostname' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint port', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.port, opts.port, 'sets the endpoint port' );
+	t.strictEqual( out.port, opts.port, 'sets the endpoint port' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.path.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.path.js
index 77358483cfc5..0fd98153ce8d 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.path.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.path.js
@@ -40,7 +40,7 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof path, 'function', 'main export is a function' );
+	t.strictEqual( typeof path, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns a resource path', function test( t ) {
 	expected = '/user/repos?page=2&per_page=30';
 	actual = path( setup() );
 
-	t.equal( actual, expected, 'returns a resource path' );
+	t.strictEqual( actual, expected, 'returns a resource path' );
 	t.end();
 });
 
@@ -67,6 +67,6 @@ tape( 'the function returns a resource path (query string)', function test( t )
 
 	actual = path( opts );
 
-	t.equal( actual, expected, 'returns a resource path' );
+	t.strictEqual( actual, expected, 'returns a resource path' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.ratelimit.js
index 41b8ac070c05..1cfad1e1b077 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.ratelimit.js
@@ -40,33 +40,33 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ratelimit, 'function', 'main export is a function' );
+	t.strictEqual( typeof ratelimit, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `limit` property', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( hasOwnProp( info, 'limit' ), true, 'has property' );
-	t.equal( info.limit, 5000, 'equals 5000' );
+	t.strictEqual( hasOwnProp( info, 'limit' ), true, 'has property' );
+	t.strictEqual( info.limit, 5000, 'equals 5000' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `remaining` property', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( hasOwnProp( info, 'remaining' ), true, 'has property' );
-	t.equal( info.remaining, 4984, 'equals 4984' );
+	t.strictEqual( hasOwnProp( info, 'remaining' ), true, 'has property' );
+	t.strictEqual( info.remaining, 4984, 'equals 4984' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `reset` property', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( hasOwnProp( info, 'reset' ), true, 'has property' );
-	t.equal( info.reset, 1372700873, 'equals 1372700873' );
+	t.strictEqual( hasOwnProp( info, 'reset' ), true, 'has property' );
+	t.strictEqual( info.reset, 1372700873, 'equals 1372700873' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.request.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.request.js
index b1f06545965c..8b940c0a9d23 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.request.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.request.js
@@ -36,7 +36,7 @@ var data = require( './fixtures/results.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof request, 'function', 'main export is a function' );
+	t.strictEqual( typeof request, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -57,9 +57,9 @@ tape( 'if unable to query an endpoint, an error is returned to a provided callba
 	request( opts, clbk );
 
 	function clbk( error ) {
-		t.equal( typeof error, 'object', 'error is an object' );
-		t.equal( error.status, 500, '500 status' );
-		t.equal( error.message, 'Request error: beep', 'message contains error message' );
+		t.strictEqual( typeof error, 'object', 'error is an object' );
+		t.strictEqual( error.status, 500, '500 status' );
+		t.strictEqual( error.message, 'Request error: beep', 'message contains error message' );
 		t.end();
 	}
 });
@@ -81,10 +81,10 @@ tape( 'if an endpoint returns a status code other than 200, an error containing
 	request( opts, clbk );
 
 	function clbk( error, response, body ) {
-		t.equal( error.status, 404, 'equal status codes' );
-		t.equal( error.message, 'bad request', 'equal messages' );
-		t.equal( typeof response, 'object', 'second argument is an object' );
-		t.equal( typeof body, 'string', 'third argument is a string' );
+		t.strictEqual( error.status, 404, 'equal status codes' );
+		t.strictEqual( error.message, 'bad request', 'equal messages' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof body, 'string', 'third argument is a string' );
 		t.end();
 	}
 });
@@ -111,10 +111,10 @@ tape( 'if an endpoint returns an invalid JSON response, an error with a status c
 	}
 
 	function clbk( error, response, body ) {
-		t.equal( error.status, 502, 'equal status codes' );
-		t.equal( typeof error.message, 'string', 'error message' );
-		t.equal( typeof response, 'object', 'second argument is an object' );
-		t.equal( typeof body, 'string', 'third argument is a string' );
+		t.strictEqual( error.status, 502, 'equal status codes' );
+		t.strictEqual( typeof error.message, 'string', 'error message' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof body, 'string', 'third argument is a string' );
 		t.end();
 	}
 });
@@ -139,8 +139,8 @@ tape( 'if a query is successful, a JSON object is returned to a provided callbac
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.equal( typeof response, 'object', 'second argument is an object' );
-			t.equal( typeof body, 'object', 'returns an object' );
+			t.strictEqual( typeof response, 'object', 'second argument is an object' );
+			t.strictEqual( typeof body, 'object', 'returns an object' );
 			t.deepEqual( body, data, 'returns expected value' );
 		}
 		t.end();
@@ -167,8 +167,8 @@ tape( 'the function supports HTTPS', function test( t ) {
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.equal( typeof response, 'object', 'second argument is an object' );
-			t.equal( typeof body, 'object', 'returns an object' );
+			t.strictEqual( typeof response, 'object', 'second argument is an object' );
+			t.strictEqual( typeof body, 'object', 'returns an object' );
 			t.deepEqual( body, data, 'returns expected value' );
 		}
 		t.end();
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.resolve.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.resolve.js
index 6e31003c881c..c471dfb40ce2 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.resolve.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.resolve.js
@@ -23,6 +23,7 @@
 var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
 var round = require( '@stdlib/math/base/special/round' );
+var filled = require( '@stdlib/array/base/filled' );
 var isnan = require( '@stdlib/assert/is-nan' ).isPrimitive;
 var resolve = require( './../lib/resolve.js' );
 
@@ -135,7 +136,7 @@ function request( error, headers, body ) {
 function multirequest( args ) {
 	var reqs;
 	var i;
-	reqs = new Array( args.length );
+	reqs = filled( void 0, args.length );
 	for ( i = 0; i < reqs.length; i++ ) {
 		reqs[ i ] = request.apply( null, args[i] );
 	}
@@ -153,7 +154,7 @@ function multirequest( args ) {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof resolve, 'function', 'main export is a function' );
+	t.strictEqual( typeof resolve, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -173,8 +174,8 @@ tape( 'if an initial request encounters an application error, the error is retur
 	resolve( options(), done );
 
 	function done( error ) {
-		t.equal( error.status, 500, '500 status' );
-		t.equal( error.message, err.message, 'equal message' );
+		t.strictEqual( error.status, 500, '500 status' );
+		t.strictEqual( error.message, err.message, 'equal message' );
 		t.end();
 	}
 });
@@ -189,7 +190,7 @@ tape( 'if a paginated request encounters an application error (e.g., network goe
 	args = [];
 
 	// First request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link1;
@@ -202,14 +203,14 @@ tape( 'if a paginated request encounters an application error (e.g., network goe
 	args.push( arr );
 
 	// Second request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = new Error( 'ENOTFOUND' );
 	arr[ 1 ] = null;
 	arr[ 2 ] = null;
 	args.push( arr );
 
 	// Third request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link3;
@@ -235,13 +236,13 @@ tape( 'if a paginated request encounters an application error (e.g., network goe
 	resolve( opts, done );
 
 	function done( error, data, info ) {
-		t.equal( error.status, 500, '500 status' );
-		t.equal( error.message, args[1][0].message, 'equal message' );
+		t.strictEqual( error.status, 500, '500 status' );
+		t.strictEqual( error.message, args[1][0].message, 'equal message' );
 
-		t.equal( data, null, 'no response data' );
+		t.strictEqual( data, null, 'no response data' );
 
 		t.ok( info, 'has ratelimit info' );
-		t.equal( info.remaining, +args[2][1][ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
+		t.strictEqual( info.remaining, +args[2][1][ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
 
 		t.end();
 	}
@@ -268,13 +269,13 @@ tape( 'for some downstream errors, the error is returned to the provided callbac
 	resolve( options(), done );
 
 	function done( error, data, info ) {
-		t.equal( error.status, err.status, 'equal status' );
-		t.equal( error.message, err.message, 'equal message' );
+		t.strictEqual( error.status, err.status, 'equal status' );
+		t.strictEqual( error.message, err.message, 'equal message' );
 
-		t.equal( data, null, 'no response data' );
+		t.strictEqual( data, null, 'no response data' );
 
 		t.ok( info, 'has rate limit info' );
-		t.equal( info.remaining, +h[ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
+		t.strictEqual( info.remaining, +h[ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
 
 		t.end();
 	}
@@ -300,15 +301,15 @@ tape( 'for some downstream errors, rate limit information may not be available',
 	resolve( options(), done );
 
 	function done( error, data, info ) {
-		t.equal( error.status, err.status, 'equal status' );
-		t.equal( error.message, err.message, 'equal message' );
+		t.strictEqual( error.status, err.status, 'equal status' );
+		t.strictEqual( error.message, err.message, 'equal message' );
 
-		t.equal( data, null, 'no response data' );
+		t.strictEqual( data, null, 'no response data' );
 
 		t.ok( info, 'has rate limit info arg' );
-		t.equal( isnan( info.remaining ), true, 'remaining is NaN' );
-		t.equal( isnan( info.reset ), true, 'reset is NaN' );
-		t.equal( isnan( info.limit ), true, 'limit is NaN' );
+		t.strictEqual( isnan( info.remaining ), true, 'remaining is NaN' );
+		t.strictEqual( isnan( info.reset ), true, 'reset is NaN' );
+		t.strictEqual( isnan( info.limit ), true, 'limit is NaN' );
 
 		t.end();
 	}
@@ -335,13 +336,13 @@ tape( 'the function supports basic (non-paginated) requests (e.g., https://api.g
 	resolve( options(), done );
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'error is null' );
+		t.strictEqual( error, null, 'error is null' );
 
 		t.deepEqual( data, body, 'equal response data' );
 
-		t.equal( info.remaining, +h[ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
-		t.equal( info.reset, +h[ 'x-ratelimit-reset' ], 'equal rate limit reset' );
-		t.equal( info.limit, +h[ 'x-ratelimit-limit' ], 'equal rate limit limit' );
+		t.strictEqual( info.remaining, +h[ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
+		t.strictEqual( info.reset, +h[ 'x-ratelimit-reset' ], 'equal rate limit reset' );
+		t.strictEqual( info.limit, +h[ 'x-ratelimit-limit' ], 'equal rate limit limit' );
 
 		t.end();
 	}
@@ -369,10 +370,10 @@ tape( 'if a request is successful, the function returns rate limit information',
 	resolve( options(), done );
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'error is null' );
-		t.equal( info.remaining, +h[ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
-		t.equal( info.reset, +h[ 'x-ratelimit-reset' ], 'equal rate limit reset' );
-		t.equal( info.limit, +h[ 'x-ratelimit-limit' ], 'equal rate limit limit' );
+		t.strictEqual( error, null, 'error is null' );
+		t.strictEqual( info.remaining, +h[ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
+		t.strictEqual( info.reset, +h[ 'x-ratelimit-reset' ], 'equal rate limit reset' );
+		t.strictEqual( info.limit, +h[ 'x-ratelimit-limit' ], 'equal rate limit limit' );
 
 		t.end();
 	}
@@ -395,7 +396,7 @@ tape( 'the function returns paginated results as a flat object array', function
 	];
 
 	// First request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link1;
@@ -404,7 +405,7 @@ tape( 'the function returns paginated results as a flat object array', function
 	args.push( arr );
 
 	// Second request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link2;
@@ -413,7 +414,7 @@ tape( 'the function returns paginated results as a flat object array', function
 	args.push( arr );
 
 	// Third request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link3;
@@ -433,7 +434,7 @@ tape( 'the function returns paginated results as a flat object array', function
 	resolve( opts, done );
 
 	function done( error, data ) {
-		t.equal( error, null, 'error is null' );
+		t.strictEqual( error, null, 'error is null' );
 		t.deepEqual( data, expected, 'expected response data' );
 		t.end();
 	}
@@ -459,7 +460,7 @@ tape( 'the function supports resolving multiple pages', function test( t ) {
 	];
 
 	// First request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link1;
@@ -468,7 +469,7 @@ tape( 'the function supports resolving multiple pages', function test( t ) {
 	args.push( arr );
 
 	// Second request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link2;
@@ -488,14 +489,14 @@ tape( 'the function supports resolving multiple pages', function test( t ) {
 	resolve( opts, done );
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'error is null' );
+		t.strictEqual( error, null, 'error is null' );
 
 		t.deepEqual( data, expected, 'expected response data' );
 
 		t.ok( info, 'has ratelimit info' );
-		t.equal( info.remaining, +args[1][1][ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
-		t.equal( info.reset, +args[0][1][ 'x-ratelimit-reset' ], 'equal rate limit reset' );
-		t.equal( info.limit, +args[0][1][ 'x-ratelimit-limit' ], 'equal rate limit limit' );
+		t.strictEqual( info.remaining, +args[1][1][ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
+		t.strictEqual( info.reset, +args[0][1][ 'x-ratelimit-reset' ], 'equal rate limit reset' );
+		t.strictEqual( info.limit, +args[0][1][ 'x-ratelimit-limit' ], 'equal rate limit limit' );
 
 		t.end();
 	}
@@ -524,7 +525,7 @@ tape( 'the function supports resolving all pages', function test( t ) {
 	];
 
 	// First request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link1;
@@ -533,7 +534,7 @@ tape( 'the function supports resolving all pages', function test( t ) {
 	args.push( arr );
 
 	// Second request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link2;
@@ -542,7 +543,7 @@ tape( 'the function supports resolving all pages', function test( t ) {
 	args.push( arr );
 
 	// Third request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link3;
@@ -562,14 +563,14 @@ tape( 'the function supports resolving all pages', function test( t ) {
 	resolve( opts, done );
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'error is null' );
+		t.strictEqual( error, null, 'error is null' );
 
 		t.deepEqual( data, expected, 'expected response data' );
 
 		t.ok( info, 'has ratelimit info' );
-		t.equal( info.remaining, +args[2][1][ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
-		t.equal( info.reset, +args[0][1][ 'x-ratelimit-reset' ], 'equal rate limit reset' );
-		t.equal( info.limit, +args[0][1][ 'x-ratelimit-limit' ], 'equal rate limit limit' );
+		t.strictEqual( info.remaining, +args[2][1][ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
+		t.strictEqual( info.reset, +args[0][1][ 'x-ratelimit-reset' ], 'equal rate limit reset' );
+		t.strictEqual( info.limit, +args[0][1][ 'x-ratelimit-limit' ], 'equal rate limit limit' );
 
 		t.end();
 	}
@@ -595,7 +596,7 @@ tape( 'the function supports resolving an arbitrary subset of pages', function t
 	];
 
 	// First request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link2;
@@ -604,7 +605,7 @@ tape( 'the function supports resolving an arbitrary subset of pages', function t
 	args.push( arr );
 
 	// Second request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link3;
@@ -625,14 +626,14 @@ tape( 'the function supports resolving an arbitrary subset of pages', function t
 	resolve( opts, done );
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'error is null' );
+		t.strictEqual( error, null, 'error is null' );
 
 		t.deepEqual( data, expected, 'expected response data' );
 
 		t.ok( info, 'has ratelimit info' );
-		t.equal( info.remaining, +args[1][1][ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
-		t.equal( info.reset, +args[0][1][ 'x-ratelimit-reset' ], 'equal rate limit reset' );
-		t.equal( info.limit, +args[0][1][ 'x-ratelimit-limit' ], 'equal rate limit limit' );
+		t.strictEqual( info.remaining, +args[1][1][ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
+		t.strictEqual( info.reset, +args[0][1][ 'x-ratelimit-reset' ], 'equal rate limit reset' );
+		t.strictEqual( info.limit, +args[0][1][ 'x-ratelimit-limit' ], 'equal rate limit limit' );
 
 		t.end();
 	}
@@ -661,7 +662,7 @@ tape( 'if provided a `last_page` option exceeding the total number of available
 	];
 
 	// First request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link1;
@@ -670,7 +671,7 @@ tape( 'if provided a `last_page` option exceeding the total number of available
 	args.push( arr );
 
 	// Second request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link2;
@@ -679,7 +680,7 @@ tape( 'if provided a `last_page` option exceeding the total number of available
 	args.push( arr );
 
 	// Third request call:
-	arr = new Array( 3 );
+	arr = filled( void 0, 3 );
 	arr[ 0 ] = null;
 	arr[ 1 ] = headers();
 	arr[ 1 ].link = link3;
@@ -699,14 +700,14 @@ tape( 'if provided a `last_page` option exceeding the total number of available
 	resolve( opts, done );
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'error is null' );
+		t.strictEqual( error, null, 'error is null' );
 
 		t.deepEqual( data, expected, 'expected response data' );
 
 		t.ok( info, 'has ratelimit info' );
-		t.equal( info.remaining, +args[2][1][ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
-		t.equal( info.reset, +args[0][1][ 'x-ratelimit-reset' ], 'equal rate limit reset' );
-		t.equal( info.limit, +args[0][1][ 'x-ratelimit-limit' ], 'equal rate limit limit' );
+		t.strictEqual( info.remaining, +args[2][1][ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
+		t.strictEqual( info.reset, +args[0][1][ 'x-ratelimit-reset' ], 'equal rate limit reset' );
+		t.strictEqual( info.limit, +args[0][1][ 'x-ratelimit-limit' ], 'equal rate limit limit' );
 
 		t.end();
 	}
@@ -739,13 +740,13 @@ tape( 'the function handles the case where a user wants multiple pages, but only
 	resolve( opts, done );
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'error is null' );
+		t.strictEqual( error, null, 'error is null' );
 
 		t.deepEqual( data, body, 'equal response data' );
 
-		t.equal( info.remaining, +h[ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
-		t.equal( info.reset, +h[ 'x-ratelimit-reset' ], 'equal rate limit reset' );
-		t.equal( info.limit, +h[ 'x-ratelimit-limit' ], 'equal rate limit limit' );
+		t.strictEqual( info.remaining, +h[ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
+		t.strictEqual( info.reset, +h[ 'x-ratelimit-reset' ], 'equal rate limit reset' );
+		t.strictEqual( info.limit, +h[ 'x-ratelimit-limit' ], 'equal rate limit limit' );
 
 		t.end();
 	}
@@ -787,13 +788,13 @@ tape( 'the function handles the case where a user wants multiple pages, but only
 	resolve( opts, done );
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'error is null' );
+		t.strictEqual( error, null, 'error is null' );
 
 		t.deepEqual( data, body, 'equal response data' );
 
-		t.equal( info.remaining, +h[ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
-		t.equal( info.reset, +h[ 'x-ratelimit-reset' ], 'equal rate limit reset' );
-		t.equal( info.limit, +h[ 'x-ratelimit-limit' ], 'equal rate limit limit' );
+		t.strictEqual( info.remaining, +h[ 'x-ratelimit-remaining' ], 'equal rate limit remaining' );
+		t.strictEqual( info.reset, +h[ 'x-ratelimit-reset' ], 'equal rate limit reset' );
+		t.strictEqual( info.limit, +h[ 'x-ratelimit-limit' ], 'equal rate limit limit' );
 
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.total.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.total.js
index 219de60280f7..0c7c6060b296 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.total.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.total.js
@@ -28,12 +28,12 @@ var getTotal = require( './../lib/total.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof getTotal, 'function', 'main export is a function' );
+	t.strictEqual( typeof getTotal, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'provided a first and last page number, the function returns the total number of pages to resolve', function test( t ) {
 	var total = getTotal( 2, 9 );
-	t.equal( total, 8, 'returns expected value' );
+	t.strictEqual( total, 8, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.validate.js
index 0fc9fee26e24..ee71637a8e23 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.validate.js
@@ -26,8 +26,9 @@ var validate = require( './../lib/validate.js' );
 
 // TESTS //
 
-tape( 'main export a validation function', function test( t ) {
-	t.equal( typeof validate, 'function', 'main export is a function' );
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -50,7 +51,7 @@ tape( 'if an options argument is not an object, the function returns a type erro
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -78,7 +79,7 @@ tape( 'if provided a `protocol` option which is not a primitive string, the func
 			'protocol': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -103,7 +104,7 @@ tape( 'if provided a `protocol` option which is not either `https` or `http`, th
 			'protocol': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof Error, true, 'returns an error when provided ' + values[i] );
+		t.strictEqual( err instanceof Error, true, 'returns an error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -131,7 +132,7 @@ tape( 'if provided a `hostname` option which is not a primitive string, the func
 			'hostname': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -161,7 +162,7 @@ tape( 'if provided a `port` option which is not a nonnegative integer, the funct
 			'port': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -189,7 +190,7 @@ tape( 'if provided a `pathname` option which is not a primitive string, the func
 			'pathname': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -219,7 +220,7 @@ tape( 'if provided a `page` option which is not a positive integer, the function
 			'page': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -249,7 +250,7 @@ tape( 'if provided a `last_page` option which is not a positive integer, the fun
 			'last_page': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -279,7 +280,7 @@ tape( 'if provided a `per_page` option which is not a positive integer, the func
 			'per_page': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -307,7 +308,7 @@ tape( 'if provided a `query` option which is not a primitive string, the functio
 			'query': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -335,7 +336,7 @@ tape( 'if provided a `token` option which is not a primitive string, the functio
 			'token': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -363,7 +364,7 @@ tape( 'if provided an `accept` option which is not a primitive string, the funct
 			'accept': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
@@ -391,7 +392,7 @@ tape( 'if provided a `useragent` option which is not a primitive string, the fun
 			'useragent': values[ i ]
 		};
 		err = validate( {}, opts );
-		t.equal( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns type error when provided ' + values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.factory.js
index 5d61e64d9281..bab40a31ba8e 100644
--- a/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.factory.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -95,7 +95,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -127,8 +127,8 @@ tape( 'function returns a function which returns an error to a provided callback
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -303,7 +303,7 @@ tape( 'function returns a function which supports specifying the type of reposit
 	fcn();
 
 	function get( opts, clbk ) {
-		t.equal( opts.query, 'type=forks', 'equal type' );
+		t.strictEqual( opts.query, 'type=forks', 'equal type' );
 		return function get() {
 			setTimeout( onTimeout, 0 );
 			function onTimeout() {
diff --git a/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.js b/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.js
index 0d997a8de05c..7267e65d1dfc 100644
--- a/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.js
@@ -28,11 +28,11 @@ var repos = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof repos, 'function', 'main export is a function' );
+	t.strictEqual( typeof repos, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof repos.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof repos.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.main.js
index 168e0455bd4b..801c5f346d90 100644
--- a/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.main.js
@@ -36,7 +36,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof get, 'function', 'export is a function' );
+	t.strictEqual( typeof get, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -64,8 +64,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.validate.js
index e3f70eb0ef73..ed1ce9408991 100644
--- a/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -173,7 +173,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'type': 'forks',
 		'useragent': 'beeper-booper'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
@@ -188,7 +188,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.factory.js
index 1a7599143f31..f01173cbb8e3 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.factory.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -97,7 +97,7 @@ tape( 'function throws if not provided either a username or token', function tes
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -125,8 +125,8 @@ tape( 'function returns a function which returns an error to a provided callback
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -155,7 +155,7 @@ tape( 'function returns a function which returns analysis results to a provided
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -185,7 +185,7 @@ tape( 'function returns a function which returns rate limit info to a provided c
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -217,7 +217,7 @@ tape( 'function returns a function which supports providing only a `username` op
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -249,7 +249,7 @@ tape( 'function returns a function which supports providing only a `token` optio
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -282,7 +282,7 @@ tape( 'function returns a function which supports providing both `token` and `us
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.js b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.js
index 8e05976f95ce..3e66d5cac979 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.js
@@ -28,11 +28,11 @@ var rank = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rank, 'function', 'main export is a function' );
+	t.strictEqual( typeof rank, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof rank.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof rank.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.main.js
index 75a467eff437..f579dd79fd9d 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.main.js
@@ -36,7 +36,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rank, 'function', 'export is a function' );
+	t.strictEqual( typeof rank, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -64,8 +64,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -94,7 +94,7 @@ tape( 'function returns analysis results to a provided callback', function test(
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -124,7 +124,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -156,7 +156,7 @@ tape( 'function supports providing only a `username` option (no authentication)'
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -188,7 +188,7 @@ tape( 'function supports providing only a `token` option (analyze the authentica
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -221,7 +221,7 @@ tape( 'function supports providing both `token` and `username` options to analyz
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.pipeline.js b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.pipeline.js
index 3a8512b3996d..583395e3acf2 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.pipeline.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.pipeline.js
@@ -48,7 +48,7 @@ var results = require( './fixtures/results.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pipeline, 'function', 'main export is a function' );
+	t.strictEqual( typeof pipeline, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -76,8 +76,8 @@ tape( 'if an error is encountered while fetching a user\'s followers, the functi
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -110,10 +110,10 @@ tape( 'if an error is encountered while fetching a user\'s followers, the functi
 	}
 
 	function done( error, data, info ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 
-		t.equal( data, null, 'data is null' );
+		t.strictEqual( data, null, 'data is null' );
 
 		t.deepEqual( info, expected, 'returns rate limit info' );
 		t.end();
@@ -151,8 +151,8 @@ tape( 'if an error is encountered while fetching a user details, the function re
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -190,8 +190,8 @@ tape( 'if an error is encountered while fetching a user details (e.g., rate limi
 	}
 
 	function done( error ) {
-		t.equal( error.status, 429, 'equal status' );
-		t.equal( typeof error.message, 'string', 'returns an error message' );
+		t.strictEqual( error.status, 429, 'equal status' );
+		t.strictEqual( typeof error.message, 'string', 'returns an error message' );
 		t.end();
 	}
 });
@@ -231,10 +231,10 @@ tape( 'if an error is encountered while fetching a user details, the function re
 	}
 
 	function done( error, data, info ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 
-		t.equal( data, null, 'data is null' );
+		t.strictEqual( data, null, 'data is null' );
 
 		t.deepEqual( info, expected, 'returns rate limit info' );
 
@@ -280,8 +280,8 @@ tape( 'if an error is encountered while analyzing user details, the function ret
 	}
 
 	function done( error ) {
-		t.equal( error.status, 502, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 502, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -328,10 +328,10 @@ tape( 'if an error is encountered while fetching a user details, the function re
 	}
 
 	function done( error, data, info ) {
-		t.equal( error.status, 502, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 502, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 
-		t.equal( data, null, 'data is null' );
+		t.strictEqual( data, null, 'data is null' );
 
 		t.deepEqual( info, expected, 'returns rate limit info' );
 
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.validate.js
index fa378c05f1bf..fdcc7873477d 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -164,7 +164,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'useragent': 'beeper-booper',
 		'method': 'followers'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
@@ -178,7 +178,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.analyze.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.analyze.js
index 412e6099ac77..5faddc1eca4a 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.analyze.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.analyze.js
@@ -42,7 +42,7 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof analyze, 'function', 'main export is a function' );
+	t.strictEqual( typeof analyze, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.ascending.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.ascending.js
index 048892ceae26..40d3119b337a 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.ascending.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.ascending.js
@@ -28,7 +28,7 @@ var ascending = require( './../lib/ascending.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ascending, 'function', 'main export is a function' );
+	t.strictEqual( typeof ascending, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -49,6 +49,6 @@ tape( 'the function returns a positive number if a[1]>b[1]', function test( t )
 tape( 'the function returns zero if a[1]==b[1]', function test( t ) {
 	var a = [ null, 1 ];
 	var b = [ null, 1 ];
-	t.equal( ascending( a, b ), 0, 'equals 0' );
+	t.strictEqual( ascending( a, b ), 0, 'equals 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.descending.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.descending.js
index 55b8e6588008..92b34de9d811 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.descending.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.descending.js
@@ -28,7 +28,7 @@ var descending = require( './../lib/descending.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof descending, 'function', 'main export is a function' );
+	t.strictEqual( typeof descending, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -49,6 +49,6 @@ tape( 'the function returns a positive number if a[1]<b[1]', function test( t )
 tape( 'the function returns zero if a[1]==b[1]', function test( t ) {
 	var a = [ null, 1 ];
 	var b = [ null, 1 ];
-	t.equal( descending( a, b ), 0, 'equals 0' );
+	t.strictEqual( descending( a, b ), 0, 'equals 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.factory.js
index 477c5bb063da..dad93053ecdc 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.factory.js
@@ -46,7 +46,7 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -95,7 +95,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -123,8 +123,8 @@ tape( 'function returns a function which returns an error to a provided callback
 	}
 
 	function done( error ) {
-		t.equal( error.status, 502, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 502, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -153,7 +153,7 @@ tape( 'function returns a function which returns analysis results to a provided
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -183,7 +183,7 @@ tape( 'function returns a function which returns rate limit info to a provided c
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.js
index 8e05976f95ce..3e66d5cac979 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.js
@@ -28,11 +28,11 @@ var rank = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rank, 'function', 'main export is a function' );
+	t.strictEqual( typeof rank, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof rank.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof rank.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.main.js
index d04b527ebf1e..15647832a13d 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.main.js
@@ -45,7 +45,7 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof rank, 'function', 'export is a function' );
+	t.strictEqual( typeof rank, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -73,8 +73,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -103,7 +103,7 @@ tape( 'function returns analysis results to a provided callback', function test(
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -133,7 +133,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -161,7 +161,7 @@ tape( 'function options are optional', function test( t ) {
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.pluck.ratio.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.pluck.ratio.js
index 0258c3ee7153..cbb7c3819ebc 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.pluck.ratio.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.pluck.ratio.js
@@ -28,7 +28,7 @@ var pluck = require( './../lib/pluck.ratio.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pluck, 'function', 'main export is a function' );
+	t.strictEqual( typeof pluck, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.pluck.raw.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.pluck.raw.js
index cc51dcc93ddd..97e15e1e6059 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.pluck.raw.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.pluck.raw.js
@@ -28,7 +28,7 @@ var pluck = require( './../lib/pluck.raw.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pluck, 'function', 'main export is a function' );
+	t.strictEqual( typeof pluck, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.shuffle.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.shuffle.js
index 23724d76304e..ac81e37398da 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.shuffle.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.shuffle.js
@@ -28,7 +28,7 @@ var shuffle = require( './../lib/shuffle.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof shuffle, 'function', 'main export is a function' );
+	t.strictEqual( typeof shuffle, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.sort.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.sort.js
index 0b0b5f998e46..8ee5d51f4fc7 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.sort.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.sort.js
@@ -28,7 +28,7 @@ var sort = require( './../lib/sort.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof sort, 'function', 'main export is a function' );
+	t.strictEqual( typeof sort, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.validate.js
index ee1882e1a9c4..3d4575e064de 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -161,7 +161,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'useragent': 'beeper-booper',
 		'method': 'followers'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
@@ -175,7 +175,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.factory.js
index f468479d0d32..7f74707f92b6 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.factory.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -86,7 +86,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -112,7 +112,7 @@ tape( 'if a `port` option is not specified and the protocol is `https`, the defa
 		return null;
 	}
 	function query( slug, topics, opts ) {
-		t.equal( opts.port, 443, 'sets the default port to `443` for HTTPS' );
+		t.strictEqual( opts.port, 443, 'sets the default port to `443` for HTTPS' );
 		t.end();
 	}
 });
@@ -139,7 +139,7 @@ tape( 'if a `port` option is not specified and the protocol is `http`, the defau
 		return null;
 	}
 	function query( slug, topics, opts ) {
-		t.equal( opts.port, 80, 'sets the default port to `80` for HTTP' );
+		t.strictEqual( opts.port, 80, 'sets the default port to `80` for HTTP' );
 		t.end();
 	}
 });
@@ -227,7 +227,7 @@ tape( 'function returns a function which returns an error to a provided callback
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -256,7 +256,7 @@ tape( 'function returns a function which returns rate limit info to a provided c
 	}
 
 	function done( error, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.headers.js
index ec249a47365e..c593f2485ff2 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.headers.js
@@ -39,32 +39,32 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof headers, 'function', 'main export is a function' );
+	t.strictEqual( typeof headers, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'if provided a `useragent` option, the function sets the `User-Agent` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
+	t.strictEqual( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
 	t.end();
 });
 
 tape( 'if provided an `accept` option, the function sets the `Accept` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
+	t.strictEqual( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
 	t.end();
 });
 
 tape( 'if provided a `token` option, the function sets the `Authorization` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'Authorization' ], 'token ' +opts.token, 'sets the `Authorization` header' );
+	t.strictEqual( h[ 'Authorization' ], 'token ' +opts.token, 'sets the `Authorization` header' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.js
index 53fef9876bf4..29aabfe1df19 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.js
@@ -28,11 +28,11 @@ var setTopics = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof setTopics, 'function', 'main export is a function' );
+	t.strictEqual( typeof setTopics, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof setTopics.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof setTopics.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.main.js
index f1f1a0e88315..98d4d3b25333 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.main.js
@@ -36,7 +36,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof setTopics, 'function', 'export is a function' );
+	t.strictEqual( typeof setTopics, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -206,7 +206,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -235,7 +235,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.options.js
index a85a3c644f31..520d2d6af252 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.options.js
@@ -44,40 +44,40 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof options, 'function', 'main export is a function' );
+	t.strictEqual( typeof options, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request method to `PUT`', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.method, 'PUT', 'method set to `PUT`' );
+	t.strictEqual( out.method, 'PUT', 'method set to `PUT`' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request protocol', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
+	t.strictEqual( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint hostname', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.hostname, opts.hostname, 'sets the endpoint hostname' );
+	t.strictEqual( out.hostname, opts.hostname, 'sets the endpoint hostname' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint port', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.port, opts.port, 'sets the endpoint port' );
+	t.strictEqual( out.port, opts.port, 'sets the endpoint port' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.query.js
index c0e3215dc92a..e6a9af5ff773 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.query.js
@@ -42,7 +42,7 @@ var response = {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof query, 'function', 'export is a function' );
+	t.strictEqual( typeof query, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -66,7 +66,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -91,7 +91,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -118,7 +118,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.ratelimit.js
index 065d481497da..7b604422ded7 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.ratelimit.js
@@ -40,33 +40,33 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ratelimit, 'function', 'main export is a function' );
+	t.strictEqual( typeof ratelimit, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `limit` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'limit' ), 'has a `limit` property' );
-	t.equal( info.limit, 5000, 'equals 5000' );
+	t.strictEqual( info.limit, 5000, 'equals 5000' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `remaining` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'remaining' ), 'has a `remaining` property' );
-	t.equal( info.remaining, 4984, 'equals 4984' );
+	t.strictEqual( info.remaining, 4984, 'equals 4984' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `reset` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'reset' ), 'has a `reset` property' );
-	t.equal( info.reset, 1372700873, 'equals 1372700873' );
+	t.strictEqual( info.reset, 1372700873, 'equals 1372700873' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.request.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.request.js
index d027d3f1c0b5..e5b2585b4d2a 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.request.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.request.js
@@ -35,7 +35,7 @@ var http = require( './fixtures/http.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof request, 'function', 'main export is a function' );
+	t.strictEqual( typeof request, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -56,9 +56,9 @@ tape( 'if unable to query an endpoint, an error is returned to a provided callba
 	request( opts, [], clbk );
 
 	function clbk( error ) {
-		t.equal( typeof error, 'object', 'error is an object' );
-		t.equal( error.status, 500, '500 status' );
-		t.equal( error.message, 'Request error: beep', 'message contains error message' );
+		t.strictEqual( typeof error, 'object', 'error is an object' );
+		t.strictEqual( error.status, 500, '500 status' );
+		t.strictEqual( error.message, 'Request error: beep', 'message contains error message' );
 		t.end();
 	}
 });
@@ -80,12 +80,12 @@ tape( 'if an endpoint returns a status code other than 204, an error containing
 	request( opts, [], clbk );
 
 	function clbk( error, response, body ) {
-		t.equal( error.status, 404, 'equal status codes' );
-		t.equal( error.message, 'bad request', 'equal messages' );
+		t.strictEqual( error.status, 404, 'equal status codes' );
+		t.strictEqual( error.message, 'bad request', 'equal messages' );
 
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'string', 'third argument is a string' );
+		t.strictEqual( typeof body, 'string', 'third argument is a string' );
 
 		t.end();
 	}
@@ -113,7 +113,7 @@ tape( 'HTTPS is supported', function test( t ) {
 			t.end();
 			return;
 		}
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.validate.js
index 24838bec6fa6..92abc7e470ce 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -125,7 +125,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets all options' );
 
 	t.end();
@@ -141,7 +141,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.factory.js
index 3a173529f997..35074e16ee27 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.factory.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -86,7 +86,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -112,7 +112,7 @@ tape( 'if a `port` option is not specified and the protocol is `https`, the defa
 		return null;
 	}
 	function query( slug, opts ) {
-		t.equal( opts.port, 443, 'sets the default port to `443` for HTTPS' );
+		t.strictEqual( opts.port, 443, 'sets the default port to `443` for HTTPS' );
 		t.end();
 	}
 });
@@ -139,7 +139,7 @@ tape( 'if a `port` option is not specified and the protocol is `http`, the defau
 		return null;
 	}
 	function query( slug, opts ) {
-		t.equal( opts.port, 80, 'sets the default port to `80` for HTTP' );
+		t.strictEqual( opts.port, 80, 'sets the default port to `80` for HTTP' );
 		t.end();
 	}
 });
@@ -227,7 +227,7 @@ tape( 'function returns a function which returns an error to a provided callback
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -256,7 +256,7 @@ tape( 'function returns a function which returns rate limit info to a provided c
 	}
 
 	function done( error, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.headers.js
index 2ead18d011c4..e63dc6cb0316 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.headers.js
@@ -39,33 +39,33 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof headers, 'function', 'main export is a function' );
+	t.strictEqual( typeof headers, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'if provided a `useragent` option, the function sets the `User-Agent` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
+	t.strictEqual( h[ 'User-Agent' ], opts.useragent, 'sets the `User-Agent` header' );
 	t.end();
 });
 
 tape( 'if provided an `accept` option, the function sets the `Accept` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
+	t.strictEqual( h[ 'Accept' ], opts.accept, 'sets the `Accept` header' );
 	t.end();
 });
 
 tape( 'if provided a `token` option, the function sets the `Authorization` header', function test( t ) {
 	var opts = setup();
 	var h = headers( opts );
-	t.equal( h[ 'Authorization' ], 'token ' +opts.token, 'sets the `Authorization` header' );
+	t.strictEqual( h[ 'Authorization' ], 'token ' +opts.token, 'sets the `Authorization` header' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.js
index 47285bbff1d2..b2b8020ea98e 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.js
@@ -28,11 +28,11 @@ var star = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof star, 'function', 'main export is a function' );
+	t.strictEqual( typeof star, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof star.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof star.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.main.js
index f6bbc630e44a..0fd7fb94e9c4 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.main.js
@@ -36,7 +36,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof star, 'function', 'export is a function' );
+	t.strictEqual( typeof star, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -176,7 +176,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -205,7 +205,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.options.js
index 1a53a086bb80..13b164af2999 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.options.js
@@ -44,40 +44,40 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof options, 'function', 'main export is a function' );
+	t.strictEqual( typeof options, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request method to `PUT`', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.method, 'PUT', 'method set to `PUT`' );
+	t.strictEqual( out.method, 'PUT', 'method set to `PUT`' );
 	t.end();
 });
 
 tape( 'the function sets the HTTP request protocol', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
+	t.strictEqual( out.protocol, opts.protocol+':', 'request protocol set protocol option' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint hostname', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.hostname, opts.hostname, 'sets the endpoint hostname' );
+	t.strictEqual( out.hostname, opts.hostname, 'sets the endpoint hostname' );
 	t.end();
 });
 
 tape( 'the function sets the endpoint port', function test( t ) {
 	var opts = setup();
 	var out = options( opts );
-	t.equal( out.port, opts.port, 'sets the endpoint port' );
+	t.strictEqual( out.port, opts.port, 'sets the endpoint port' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.query.js
index 8c76ccab0cfe..e683a4d8a921 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.query.js
@@ -42,7 +42,7 @@ var response = {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof query, 'function', 'export is a function' );
+	t.strictEqual( typeof query, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -66,7 +66,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -91,7 +91,7 @@ tape( 'function returns an error to a provided callback if an error is encounter
 
 	function done( error ) {
 		t.ok( error instanceof Error, 'error instance' );
-		t.equal( error.message, 'beep' );
+		t.strictEqual( error.message, 'beep' );
 		t.end();
 	}
 });
@@ -118,7 +118,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.ratelimit.js
index 065d481497da..7b604422ded7 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.ratelimit.js
@@ -40,33 +40,33 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ratelimit, 'function', 'main export is a function' );
+	t.strictEqual( typeof ratelimit, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.equal( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns an object' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `limit` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'limit' ), 'has a `limit` property' );
-	t.equal( info.limit, 5000, 'equals 5000' );
+	t.strictEqual( info.limit, 5000, 'equals 5000' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `remaining` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'remaining' ), 'has a `remaining` property' );
-	t.equal( info.remaining, 4984, 'equals 4984' );
+	t.strictEqual( info.remaining, 4984, 'equals 4984' );
 	t.end();
 });
 
 tape( 'the function returns an object with a `reset` property', function test( t ) {
 	var info = ratelimit( setup() );
 	t.ok( hasOwnProp( info, 'reset' ), 'has a `reset` property' );
-	t.equal( info.reset, 1372700873, 'equals 1372700873' );
+	t.strictEqual( info.reset, 1372700873, 'equals 1372700873' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.request.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.request.js
index 0bbe299c05ce..13a46640a93c 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.request.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.request.js
@@ -35,7 +35,7 @@ var http = require( './fixtures/http.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof request, 'function', 'main export is a function' );
+	t.strictEqual( typeof request, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -56,9 +56,9 @@ tape( 'if unable to query an endpoint, an error is returned to a provided callba
 	request( opts, clbk );
 
 	function clbk( error ) {
-		t.equal( typeof error, 'object', 'error is an object' );
-		t.equal( error.status, 500, '500 status' );
-		t.equal( error.message, 'Request error: beep', 'message contains error message' );
+		t.strictEqual( typeof error, 'object', 'error is an object' );
+		t.strictEqual( error.status, 500, '500 status' );
+		t.strictEqual( error.message, 'Request error: beep', 'message contains error message' );
 		t.end();
 	}
 });
@@ -80,12 +80,12 @@ tape( 'if an endpoint returns a status code other than 204, an error containing
 	request( opts, clbk );
 
 	function clbk( error, response, body ) {
-		t.equal( error.status, 404, 'equal status codes' );
-		t.equal( error.message, 'bad request', 'equal messages' );
+		t.strictEqual( error.status, 404, 'equal status codes' );
+		t.strictEqual( error.message, 'bad request', 'equal messages' );
 
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.equal( typeof body, 'string', 'third argument is a string' );
+		t.strictEqual( typeof body, 'string', 'third argument is a string' );
 
 		t.end();
 	}
@@ -113,7 +113,7 @@ tape( 'HTTPS is supported', function test( t ) {
 			t.end();
 			return;
 		}
-		t.equal( typeof response, 'object', 'second argument is an object' );
+		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.validate.js
index 24838bec6fa6..92abc7e470ce 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -125,7 +125,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets all options' );
 
 	t.end();
@@ -141,7 +141,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/starred/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/starred/test/test.factory.js
index ecbc4a929f5c..8fea0f698295 100644
--- a/lib/node_modules/@stdlib/_tools/github/starred/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/starred/test/test.factory.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -97,7 +97,7 @@ tape( 'function throws if not provided either a username or token', function tes
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -129,8 +129,8 @@ tape( 'function returns a function which returns an error to a provided callback
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -163,7 +163,7 @@ tape( 'function returns a function which returns response data to a provided cal
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -197,7 +197,7 @@ tape( 'function returns a function which returns rate limit info to a provided c
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -233,7 +233,7 @@ tape( 'function returns a function which supports providing only a `username` op
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -269,7 +269,7 @@ tape( 'function returns a function which supports providing only a `token` optio
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -306,7 +306,7 @@ tape( 'function returns a function which supports providing both `token` and `us
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -334,7 +334,7 @@ tape( 'function returns a function which supports specifying a sort method and d
 	fcn();
 
 	function get( opts ) {
-		t.equal( opts.query, expected, 'correctly compiles query string' );
+		t.strictEqual( opts.query, expected, 'correctly compiles query string' );
 		return function get() {
 			t.end();
 		};
diff --git a/lib/node_modules/@stdlib/_tools/github/starred/test/test.js b/lib/node_modules/@stdlib/_tools/github/starred/test/test.js
index f12f95cd6107..67eb461b1868 100644
--- a/lib/node_modules/@stdlib/_tools/github/starred/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/starred/test/test.js
@@ -28,11 +28,11 @@ var starred = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof starred, 'function', 'main export is a function' );
+	t.strictEqual( typeof starred, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof starred.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof starred.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/starred/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/starred/test/test.main.js
index 761b2251c1b0..5d3193109e74 100644
--- a/lib/node_modules/@stdlib/_tools/github/starred/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/starred/test/test.main.js
@@ -36,7 +36,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof get, 'function', 'export is a function' );
+	t.strictEqual( typeof get, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -64,8 +64,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -94,7 +94,7 @@ tape( 'functions returns response data to a provided callback', function test( t
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -124,7 +124,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -156,7 +156,7 @@ tape( 'function supports providing only a `username` option (no authentication)'
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -188,7 +188,7 @@ tape( 'function supports providing only a `token` option (get the authenticated
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -221,7 +221,7 @@ tape( 'function supports providing both `token` and `username` options to get an
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/starred/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/starred/test/test.validate.js
index c06b8f367c76..0791c2c4e3fd 100644
--- a/lib/node_modules/@stdlib/_tools/github/starred/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/starred/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -190,7 +190,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'sort': 'updated',
 		'direction': 'asc'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
@@ -204,7 +204,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.factory.js
index 208077bbb68b..943cb3d9434f 100644
--- a/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.factory.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -97,7 +97,7 @@ tape( 'function throws if not provided either a username or token', function tes
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -129,8 +129,8 @@ tape( 'function returns a function which returns an error to a provided callback
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -163,7 +163,7 @@ tape( 'function returns a function which returns response data to a provided cal
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -197,7 +197,7 @@ tape( 'function returns a function which returns rate limit info to a provided c
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -233,7 +233,7 @@ tape( 'function returns a function which supports providing only a `username` op
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -269,7 +269,7 @@ tape( 'function returns a function which supports providing only a `token` optio
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -306,7 +306,7 @@ tape( 'function returns a function which supports providing both `token` and `us
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.js b/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.js
index 7c7a2d7ca28a..04bf88b4015b 100644
--- a/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.js
@@ -28,11 +28,11 @@ var subscriptions = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof subscriptions, 'function', 'main export is a function' );
+	t.strictEqual( typeof subscriptions, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof subscriptions.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof subscriptions.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.main.js
index fd676cad5a32..2c6ae06b7ab5 100644
--- a/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.main.js
@@ -36,7 +36,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof get, 'function', 'export is a function' );
+	t.strictEqual( typeof get, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -64,8 +64,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -94,7 +94,7 @@ tape( 'functions returns response data to a provided callback', function test( t
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -124,7 +124,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -156,7 +156,7 @@ tape( 'function supports providing only a `username` option (no authentication)'
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -188,7 +188,7 @@ tape( 'function supports providing only a `token` option (get the authenticated
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -221,7 +221,7 @@ tape( 'function supports providing both `token` and `username` options to get an
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.validate.js
index 7e9e6d67a9d5..d01a55d4fcc6 100644
--- a/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -138,7 +138,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'username': 'beepboop',
 		'useragent': 'beeper-booper'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.factory.js
index aa1c589595ca..ab9067546db9 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.factory.js
@@ -49,7 +49,7 @@ var results = {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -109,7 +109,7 @@ tape( 'function throws if not provided usernames', function test( t ) {
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -137,8 +137,8 @@ tape( 'function returns a function which returns an error to a provided callback
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -167,7 +167,7 @@ tape( 'function returns a function which returns a username hash containing user
 	}
 
 	function done( error, results ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( results, expected, 'deep equal' );
 		t.end();
 	}
@@ -197,7 +197,7 @@ tape( 'function returns a function which returns rate limit info to a provided c
 	}
 
 	function done( error, results, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -229,7 +229,7 @@ tape( 'function returns a function which supports requesting user details withou
 	}
 
 	function done( error, results ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( results, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.get.js b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.get.js
index f1b20b38299e..d8d184fed10c 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.get.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.get.js
@@ -23,6 +23,7 @@
 var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
 var copy = require( '@stdlib/utils/copy' );
+var filled = require( '@stdlib/array/base/filled' );
 var round = require( '@stdlib/math/base/special/round' );
 var get = require( './../lib/get.js' );
 
@@ -38,7 +39,7 @@ var getOpts = require( './fixtures/opts.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof get, 'function', 'export is a function' );
+	t.strictEqual( typeof get, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -64,8 +65,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 500, 'equal status' );
-		t.equal( error.message, 'bad request', 'equal message' );
+		t.strictEqual( error.status, 500, 'equal status' );
+		t.strictEqual( error.message, 'bad request', 'equal message' );
 		t.end();
 	}
 });
@@ -94,8 +95,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 500, 'equal status' );
-		t.equal( error.message, 'bad request', 'equal message' );
+		t.strictEqual( error.status, 500, 'equal status' );
+		t.strictEqual( error.message, 'bad request', 'equal message' );
 		t.end();
 	}
 });
@@ -122,7 +123,7 @@ tape( 'the function returns a JSON object upon attempting to resolve all specifi
 		if ( error ) {
 			t.ok( false, error.message );
 		} else {
-			t.equal( typeof data, 'object', 'returns an object' );
+			t.strictEqual( typeof data, 'object', 'returns an object' );
 		}
 		t.end();
 	}
@@ -404,7 +405,7 @@ tape( 'the function handles out-of-order responses to return the most up-to-date
 		'unknown_username'
 	];
 
-	info = new Array( 3 );
+	info = filled( void 0, 3 );
 	info[ 0 ] = {
 		'limit': 5000,
 		'remaining': 4995,
@@ -477,7 +478,7 @@ tape( 'the function handles out-of-order responses to return the most up-to-date
 		'unknown_username'
 	];
 
-	info = new Array( 3 );
+	info = filled( void 0, 3 );
 	info[ 0 ] = {
 		'limit': 5000,
 		'remaining': 4995,
diff --git a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.js b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.js
index db08a559a84d..f5d5cb58cb98 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.js
@@ -28,11 +28,11 @@ var userinfo = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof userinfo, 'function', 'main export is a function' );
+	t.strictEqual( typeof userinfo, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof userinfo.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof userinfo.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.main.js
index e11fa46b461e..18820c0a8e6c 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.main.js
@@ -48,7 +48,7 @@ var results = {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof userinfo, 'function', 'export is a function' );
+	t.strictEqual( typeof userinfo, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -76,8 +76,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -106,7 +106,7 @@ tape( 'functions returns a username hash containing user details to a provided c
 	}
 
 	function done( error, results ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( results, expected, 'deep equal' );
 		t.end();
 	}
@@ -136,7 +136,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, results, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -168,7 +168,7 @@ tape( 'function supports requesting user details without authentication (no toke
 	}
 
 	function done( error, results ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( results, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.updatelimit.js b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.updatelimit.js
index 21eebec4dcf8..4ff7ed699546 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.updatelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.updatelimit.js
@@ -40,7 +40,7 @@ function setup() {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof updatelimit, 'function', 'main export is a function' );
+	t.strictEqual( typeof updatelimit, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.validate.js
index e094f3af0b28..cbb91395dd89 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -149,7 +149,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'token': 'abcdefg',
 		'useragent': 'beeper-booper'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
@@ -164,7 +164,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.factory.js
index f94cb6fb84fe..ecac65cac20e 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.factory.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -97,7 +97,7 @@ tape( 'function throws if not provided either a username or token', function tes
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -129,8 +129,8 @@ tape( 'function returns a function which returns an error to a provided callback
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -163,7 +163,7 @@ tape( 'function returns a function which returns response data to a provided cal
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -197,7 +197,7 @@ tape( 'function returns a function which returns rate limit info to a provided c
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -233,7 +233,7 @@ tape( 'function returns a function which supports providing only a `username` op
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -269,7 +269,7 @@ tape( 'function returns a function which supports providing only a `token` optio
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -306,7 +306,7 @@ tape( 'function returns a function which supports providing both `token` and `us
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -333,7 +333,7 @@ tape( 'function returns a function which supports specifying the state of member
 	fcn();
 
 	function get( opts, clbk ) {
-		t.equal( opts.query, 'state=pending', 'equal state' );
+		t.strictEqual( opts.query, 'state=pending', 'equal state' );
 		return function get() {
 			setTimeout( onTimeout, 0 );
 			function onTimeout() {
@@ -343,7 +343,7 @@ tape( 'function returns a function which supports specifying the state of member
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.js b/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.js
index 617a2d59ca00..1c3c2b7729df 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.js
@@ -28,11 +28,11 @@ var orgs = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof orgs, 'function', 'main export is a function' );
+	t.strictEqual( typeof orgs, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof orgs.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof orgs.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.main.js
index 1e7986767cb4..59fd315a5cd2 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.main.js
@@ -36,7 +36,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof get, 'function', 'export is a function' );
+	t.strictEqual( typeof get, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -64,8 +64,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -94,7 +94,7 @@ tape( 'functions returns response data to a provided callback', function test( t
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -124,7 +124,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -156,7 +156,7 @@ tape( 'function supports providing only a `username` option (no authentication)'
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -188,7 +188,7 @@ tape( 'function supports providing only a `token` option (get the authenticated
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -221,7 +221,7 @@ tape( 'function supports providing both `token` and `username` options to get an
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.validate.js
index c71b6958b9b5..b125a7a2e94a 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -164,7 +164,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'useragent': 'beeper-booper',
 		'state': 'active'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
@@ -178,7 +178,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.factory.js
index a70c297ce161..6e60248eb653 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.factory.js
@@ -37,7 +37,7 @@ var raw = require( './fixtures/raw.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -97,7 +97,7 @@ tape( 'function throws if not provided a token', function test( t ) {
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -129,8 +129,8 @@ tape( 'function returns a function which returns an error to a provided callback
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -163,7 +163,7 @@ tape( 'function returns a function which returns a rate limit status to a provid
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.js b/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.js
index 8966f204498a..99e2d9ce3aa5 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.js
@@ -28,11 +28,11 @@ var ratelimit = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ratelimit, 'function', 'main export is a function' );
+	t.strictEqual( typeof ratelimit, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof ratelimit.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof ratelimit.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.main.js
index 7430eaafd996..0d0b2ca260dd 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.main.js
@@ -35,7 +35,7 @@ var results = require( './fixtures/results.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof get, 'function', 'export is a function' );
+	t.strictEqual( typeof get, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -63,8 +63,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -93,7 +93,7 @@ tape( 'functions returns a rate limit status to a provided callback', function t
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.validate.js
index a7de6fa5bdf7..7c79a8a399be 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -119,7 +119,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'token': 'abcdefg',
 		'useragent': 'beeper-booper'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.factory.js
index 739338f09c30..f00a34c76581 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.factory.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -97,7 +97,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -129,8 +129,8 @@ tape( 'function returns a function which returns an error to a provided callback
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -163,7 +163,7 @@ tape( 'function returns a function which returns response data to a provided cal
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -197,7 +197,7 @@ tape( 'function returns a function which returns rate limit info to a provided c
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -233,7 +233,7 @@ tape( 'function returns a function which supports providing only a `username` op
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -269,7 +269,7 @@ tape( 'function returns a function which supports providing only a `token` optio
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -306,7 +306,7 @@ tape( 'function returns a function which supports providing both `token` and `us
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -335,7 +335,7 @@ tape( 'function returns a function which supports specifying various query param
 	fcn();
 
 	function get( opts, clbk ) {
-		t.equal( opts.query, 'type=owner&sort=created&direction=asc', 'supports query parameters' );
+		t.strictEqual( opts.query, 'type=owner&sort=created&direction=asc', 'supports query parameters' );
 		return function get() {
 			setTimeout( onTimeout, 0 );
 			function onTimeout() {
@@ -345,7 +345,7 @@ tape( 'function returns a function which supports specifying various query param
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.js b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.js
index 0d997a8de05c..7267e65d1dfc 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.js
@@ -28,11 +28,11 @@ var repos = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof repos, 'function', 'main export is a function' );
+	t.strictEqual( typeof repos, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof repos.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof repos.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.main.js
index 458ad705ecad..17d03f375152 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.main.js
@@ -36,7 +36,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof get, 'function', 'export is a function' );
+	t.strictEqual( typeof get, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -64,8 +64,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
@@ -94,7 +94,7 @@ tape( 'functions returns response data to a provided callback', function test( t
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -124,7 +124,7 @@ tape( 'function returns rate limit info to a provided callback', function test(
 	}
 
 	function done( error, data, info ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
@@ -157,7 +157,7 @@ tape( 'function supports providing only a `username` option (no authentication)'
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -190,7 +190,7 @@ tape( 'function supports providing only a `token` option (get the authenticated
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -223,7 +223,7 @@ tape( 'function supports providing both `token` and `username` options (increase
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
@@ -259,7 +259,7 @@ tape( 'function supports specifying various query parameters', function test( t
 	}
 
 	function done( error, data ) {
-		t.equal( error, null, 'does not return an error' );
+		t.strictEqual( error, null, 'does not return an error' );
 		t.deepEqual( data, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.query.js
index 713dbddd6c66..e31c5d0183c2 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.query.js
@@ -28,7 +28,7 @@ var query = require( './../lib/query.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof query, 'function', 'main export is a function' );
+	t.strictEqual( typeof query, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -36,7 +36,7 @@ tape( 'the function supports inlining a `type` param', function test( t ) {
 	var qs = query({
 		'type': 'all'
 	});
-	t.equal( qs, 'type=all', 'inlines type param' );
+	t.strictEqual( qs, 'type=all', 'inlines type param' );
 	t.end();
 });
 
@@ -44,7 +44,7 @@ tape( 'the function supports inlining a `sort` param', function test( t ) {
 	var qs = query({
 		'sort': 'full_name'
 	});
-	t.equal( qs, 'sort=full_name', 'inlines sort param' );
+	t.strictEqual( qs, 'sort=full_name', 'inlines sort param' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'the function supports inlining a `direction` param', function test( t ) {
 	var qs = query({
 		'direction': 'desc'
 	});
-	t.equal( qs, 'direction=desc', 'inlines direction param' );
+	t.strictEqual( qs, 'direction=desc', 'inlines direction param' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'the function supports inlining a `visibility` param', function test( t )
 	var qs = query({
 		'visibility': 'public'
 	});
-	t.equal( qs, 'visibility=public', 'inlines visibility param' );
+	t.strictEqual( qs, 'visibility=public', 'inlines visibility param' );
 	t.end();
 });
 
@@ -68,7 +68,7 @@ tape( 'the function supports inlining an `affiliation` param', function test( t
 	var qs = query({
 		'affiliation': 'owner'
 	});
-	t.equal( qs, 'affiliation=owner', 'inlines affiliation param' );
+	t.strictEqual( qs, 'affiliation=owner', 'inlines affiliation param' );
 	t.end();
 });
 
@@ -83,7 +83,7 @@ tape( 'if provided a `type` option, the function ignores `visibility` and `affil
 	};
 	qs = query( opts );
 
-	t.equal( qs, 'type=all', 'ignores visibility and affiliation options' );
+	t.strictEqual( qs, 'type=all', 'ignores visibility and affiliation options' );
 	t.end();
 });
 
@@ -100,7 +100,7 @@ tape( 'the function returns a query string', function test( t ) {
 	qs = query( opts );
 
 	expected = 'type=all&sort=full_name&direction=desc';
-	t.equal( qs, expected, 'returns '+expected );
+	t.strictEqual( qs, expected, 'returns '+expected );
 
 	opts = {
 		'visibility': 'private',
@@ -111,7 +111,7 @@ tape( 'the function returns a query string', function test( t ) {
 	qs = query( opts );
 
 	expected = 'visibility=private&affiliation=collaborator&sort=full_name&direction=desc';
-	t.equal( qs, expected, 'returns '+expected );
+	t.strictEqual( qs, expected, 'returns '+expected );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.validate.js
index cce333955f5c..a642bb5f2951 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -268,7 +268,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'visibility': 'all',
 		'affiliation': 'owner,collaborator,organization_member'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
@@ -282,7 +282,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.factory.js
index a434b3b262e7..8bfbb9f2248c 100644
--- a/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.factory.js
@@ -37,7 +37,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof factory, 'function', 'export is a function' );
+	t.strictEqual( typeof factory, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -95,7 +95,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.equal( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -127,8 +127,8 @@ tape( 'function returns a function which returns an error to a provided callback
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.js b/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.js
index 5bc2c81fad6b..00c9717a2833 100644
--- a/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.js
@@ -28,11 +28,11 @@ var workflowRuns = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof workflowRuns, 'function', 'main export is a function' );
+	t.strictEqual( typeof workflowRuns, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'module exports a factory method', function test( t ) {
-	t.equal( typeof workflowRuns.factory, 'function', 'export includes a factory method' );
+	t.strictEqual( typeof workflowRuns.factory, 'function', 'export includes a factory method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.main.js b/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.main.js
index de8790c58b36..ddd0bee56a1f 100644
--- a/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.main.js
@@ -36,7 +36,7 @@ var info = require( './fixtures/info.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof get, 'function', 'export is a function' );
+	t.strictEqual( typeof get, 'function', 'export is a function' );
 	t.end();
 });
 
@@ -64,8 +64,8 @@ tape( 'function returns an error to a provided callback if an error is encounter
 	}
 
 	function done( error ) {
-		t.equal( error.status, 404, 'equal status' );
-		t.equal( error.message, 'beep', 'equal message' );
+		t.strictEqual( error.status, 404, 'equal status' );
+		t.strictEqual( error.message, 'beep', 'equal message' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.validate.js
index 7b291a0cd128..875587ecad65 100644
--- a/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -147,7 +147,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'type': 'forks',
 		'useragent': 'beeper-booper'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
@@ -162,7 +162,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/create/test/test.async.js b/lib/node_modules/@stdlib/_tools/links/create/test/test.async.js
index eae5f101efda..1c27c821999d 100644
--- a/lib/node_modules/@stdlib/_tools/links/create/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/links/create/test/test.async.js
@@ -38,7 +38,7 @@ var EXPECTED2 = require( './fixtures/expected2.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof create, 'function', 'main export is a function' );
+	t.strictEqual( typeof create, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/links/create/test/test.js b/lib/node_modules/@stdlib/_tools/links/create/test/test.js
index 6aec815659c3..f65408fb0f49 100644
--- a/lib/node_modules/@stdlib/_tools/links/create/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/links/create/test/test.js
@@ -28,11 +28,11 @@ var create = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof create, 'function', 'main export is a function' );
+	t.strictEqual( typeof create, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a function to create a link entry in the link database synchronously', function test( t ) {
-	t.equal( typeof create.sync, 'function', 'attached method for synchronously creating a link entry in the link database' );
+	t.strictEqual( typeof create.sync, 'function', 'attached method for synchronously creating a link entry in the link database' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/create/test/test.sync.js b/lib/node_modules/@stdlib/_tools/links/create/test/test.sync.js
index ff7622b5a3f6..5d999f9db866 100644
--- a/lib/node_modules/@stdlib/_tools/links/create/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/links/create/test/test.sync.js
@@ -37,7 +37,7 @@ var EXPECTED2 = require( './fixtures/expected2.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof create, 'function', 'main export is a function' );
+	t.strictEqual( typeof create, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/links/create/test/test.validate.js b/lib/node_modules/@stdlib/_tools/links/create/test/test.validate.js
index 9a937186fa94..eff55bdbeb0e 100644
--- a/lib/node_modules/@stdlib/_tools/links/create/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/links/create/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -115,7 +115,7 @@ tape( 'the function returns an error if provided a `uri` option which is not a s
 			'id': 'stdlib',
 			'description': 'A standard library for JavaScript and Node.js.'
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the function returns an error if provided a `id` option which is not a st
 			'id': values[ i ],
 			'description': 'A standard library for JavaScript and Node.js.'
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -167,7 +167,7 @@ tape( 'the function returns an error if provided a `description` option which is
 			'id': 'stdlib',
 			'description': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -194,7 +194,7 @@ tape( 'the function returns an error if provided a `database` option which is no
 			'description': 'A standard library for JavaScript and Node.js.',
 			'database': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -222,7 +222,7 @@ tape( 'the function returns an error if provided a `keywords` option which is no
 			'description': 'A standard library for JavaScript and Node.js.',
 			'keywords': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -241,7 +241,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -268,7 +268,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'only sets mandatory options' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.async.js b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.async.js
index 5b8adc703a55..2fa6cb476396 100644
--- a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.async.js
@@ -30,7 +30,7 @@ var id2uri = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof id2uri, 'function', 'main export is a function' );
+	t.strictEqual( typeof id2uri, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.js b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.js
index c75e439bb554..2686cf68f871 100644
--- a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.js
@@ -28,11 +28,11 @@ var id2uri = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof id2uri, 'function', 'main export is a function' );
+	t.strictEqual( typeof id2uri, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a function to return the URI corresponding to a provided id synchronously', function test( t ) {
-	t.equal( typeof id2uri.sync, 'function', 'attached method for synchronously returning the corresponding URI' );
+	t.strictEqual( typeof id2uri.sync, 'function', 'attached method for synchronously returning the corresponding URI' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.sync.js b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.sync.js
index 6b9ae6050e17..3a13bebd8c1f 100644
--- a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.sync.js
@@ -29,7 +29,7 @@ var id2uri = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof id2uri, 'function', 'main export is a function' );
+	t.strictEqual( typeof id2uri, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.validate.js b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.validate.js
index 14ecc89702b5..6c3886d76000 100644
--- a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -74,7 +74,7 @@ tape( 'the function returns an error if provided a `database` option which is no
 		err = validate( {}, {
 			'database': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -108,7 +108,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.async.js b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.async.js
index f96264368ac2..501ad115a823 100644
--- a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.async.js
@@ -30,7 +30,7 @@ var uri2id = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof uri2id, 'function', 'main export is a function' );
+	t.strictEqual( typeof uri2id, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.js b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.js
index c71232abad40..aafb73f2a4a2 100644
--- a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.js
@@ -28,11 +28,11 @@ var uri2id = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof uri2id, 'function', 'main export is a function' );
+	t.strictEqual( typeof uri2id, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a function to return the id corresponding to a provided URI synchronously', function test( t ) {
-	t.equal( typeof uri2id.sync, 'function', 'attached method for synchronously returning the corresponding id' );
+	t.strictEqual( typeof uri2id.sync, 'function', 'attached method for synchronously returning the corresponding id' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.sync.js b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.sync.js
index a70402776b44..8be719262bea 100644
--- a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.sync.js
@@ -29,7 +29,7 @@ var uri2id = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof uri2id, 'function', 'main export is a function' );
+	t.strictEqual( typeof uri2id, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.validate.js b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.validate.js
index 14ecc89702b5..6c3886d76000 100644
--- a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -74,7 +74,7 @@ tape( 'the function returns an error if provided a `database` option which is no
 		err = validate( {}, {
 			'database': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -108,7 +108,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/validate/test/test.async.js b/lib/node_modules/@stdlib/_tools/links/validate/test/test.async.js
index ab73c595e9bf..c15758746a38 100644
--- a/lib/node_modules/@stdlib/_tools/links/validate/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/links/validate/test/test.async.js
@@ -36,7 +36,7 @@ var EXPECTED = require( './fixtures/expected.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validateLinks, 'function', 'main export is a function' );
+	t.strictEqual( typeof validateLinks, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/links/validate/test/test.js b/lib/node_modules/@stdlib/_tools/links/validate/test/test.js
index 3a11a51c81c7..27013135e936 100644
--- a/lib/node_modules/@stdlib/_tools/links/validate/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/links/validate/test/test.js
@@ -28,11 +28,11 @@ var validateLinks = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validateLinks, 'function', 'main export is a function' );
+	t.strictEqual( typeof validateLinks, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a function to validate an array of link objects synchronously', function test( t ) {
-	t.equal( typeof validateLinks.sync, 'function', 'attached method for synchronously validating an array of link objects' );
+	t.strictEqual( typeof validateLinks.sync, 'function', 'attached method for synchronously validating an array of link objects' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/validate/test/test.sync.js b/lib/node_modules/@stdlib/_tools/links/validate/test/test.sync.js
index 2378dcd176fa..d02fe392cfc9 100644
--- a/lib/node_modules/@stdlib/_tools/links/validate/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/links/validate/test/test.sync.js
@@ -35,7 +35,7 @@ var EXPECTED = require( './fixtures/expected.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validateLinks, 'function', 'main export is a function' );
+	t.strictEqual( typeof validateLinks, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/links/validate/test/test.validate.js b/lib/node_modules/@stdlib/_tools/links/validate/test/test.validate.js
index aaa2de55e540..49da082ccad6 100644
--- a/lib/node_modules/@stdlib/_tools/links/validate/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/links/validate/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -74,7 +74,7 @@ tape( 'the function returns an error if provided a `database` option which is no
 		err = validate( {}, {
 			'database': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -108,7 +108,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.async.js b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.async.js
index bf269a8b9c51..18b819eb61d5 100644
--- a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.async.js
@@ -33,7 +33,7 @@ var lint = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof lint, 'function', 'main export is a function' );
+	t.strictEqual( typeof lint, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -135,7 +135,7 @@ tape( 'the function returns an empty array if all filenames are valid', function
 			t.ok( false, error.message );
 		}
 		bool = ( isArray( names ) && names.length === 0 );
-		t.equal( bool, true, 'returns an empty array' );
+		t.strictEqual( bool, true, 'returns an empty array' );
 		t.end();
 	}
 });
@@ -152,7 +152,7 @@ tape( 'the function returns an object array if filenames are not valid', functio
 			t.ok( false, error.message );
 		}
 		bool = isObjectArray( names );
-		t.equal( bool, true, 'returns an object array' );
+		t.strictEqual( bool, true, 'returns an object array' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.js b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.js
index 83c001bcb400..1ac4b12dddbc 100644
--- a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.js
@@ -28,11 +28,11 @@ var lint = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof lint, 'function', 'main export is a function' );
+	t.strictEqual( typeof lint, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously lint filenames', function test( t ) {
-	t.equal( typeof lint.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof lint.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.lint.js b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.lint.js
index 62dd92cb72db..33b26ff2af59 100644
--- a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.lint.js
+++ b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.lint.js
@@ -29,7 +29,7 @@ var lint = require( './../lib/lint.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof lint, 'function', 'main export is a function' );
+	t.strictEqual( typeof lint, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -44,7 +44,7 @@ tape( 'the function requires `Makefile` to be spelled exactly', function test( t
 	];
 	names = lint( values );
 
-	t.equal( names.length, values.length, 'returns error messages' );
+	t.strictEqual( names.length, values.length, 'returns error messages' );
 	t.end();
 });
 
@@ -59,7 +59,7 @@ tape( 'the function requires `LICENSE` to be spelled exactly', function test( t
 	];
 	names = lint( values );
 
-	t.equal( names.length, values.length, 'returns error messages' );
+	t.strictEqual( names.length, values.length, 'returns error messages' );
 	t.end();
 });
 
@@ -74,7 +74,7 @@ tape( 'the function requires `DESCRIPTION` to be spelled exactly', function test
 	];
 	names = lint( values );
 
-	t.equal( names.length, values.length, 'returns error messages' );
+	t.strictEqual( names.length, values.length, 'returns error messages' );
 	t.end();
 });
 
@@ -89,7 +89,7 @@ tape( 'the function requires `REQUIRE` to be spelled exactly', function test( t
 	];
 	names = lint( values );
 
-	t.equal( names.length, values.length, 'returns error messages' );
+	t.strictEqual( names.length, values.length, 'returns error messages' );
 	t.end();
 });
 
@@ -104,7 +104,7 @@ tape( 'the function enforces allowed extensions', function test( t ) {
 	];
 	names = lint( values );
 
-	t.equal( names.length, values.length, 'returns error messages' );
+	t.strictEqual( names.length, values.length, 'returns error messages' );
 	t.end();
 });
 
@@ -119,7 +119,7 @@ tape( 'the function requires files other than special cases and Markdown to be l
 	];
 	names = lint( values );
 
-	t.equal( names.length, values.length, 'returns error messages' );
+	t.strictEqual( names.length, values.length, 'returns error messages' );
 	t.end();
 });
 
@@ -134,7 +134,7 @@ tape( 'the function enforces allowed characters', function test( t ) {
 	];
 	names = lint( values );
 
-	t.equal( names.length, values.length, 'returns error messages' );
+	t.strictEqual( names.length, values.length, 'returns error messages' );
 	t.end();
 });
 
@@ -156,7 +156,7 @@ tape( 'the function returns an empty array if all filenames are valid', function
 	];
 	names = lint( values );
 
-	t.equal( isArray( names ), true, 'returns an array' );
-	t.equal( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns an array' );
+	t.strictEqual( names.length, 0, 'returns an empty array' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.sync.js b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.sync.js
index 11bd2f417f68..f3adc2a053e8 100644
--- a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.sync.js
@@ -32,7 +32,7 @@ var lint = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof lint, 'function', 'main export is a function' );
+	t.strictEqual( typeof lint, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns an empty array if unable to resolve files', function
 	names = lint();
 	bool = ( isArray( names ) && names.length === 0 );
 
-	t.equal( bool, true, 'returns an empty array' );
+	t.strictEqual( bool, true, 'returns an empty array' );
 	t.end();
 
 	function glob() {
@@ -80,7 +80,7 @@ tape( 'the function returns an empty array if all filenames are valid', function
 	names = lint( opts );
 
 	bool = ( isArray( names ) && names.length === 0 );
-	t.equal( bool, true, 'returns an empty array' );
+	t.strictEqual( bool, true, 'returns an empty array' );
 	t.end();
 });
 
@@ -93,7 +93,7 @@ tape( 'the function returns an object array if filenames are not valid', functio
 	};
 	names = lint( opts );
 
-	t.equal( isObjectArray( names ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( names ), true, 'returns an object array' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.validate.js b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.validate.js
index 5d1b4ab1607d..dd420e4d9a2f 100644
--- a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'if provided a `pattern` option which is not a `string`, the function retu
 		err = validate( opts, {
 			'pattern': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -123,9 +123,9 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
-	t.equal( obj.pattern, opts.pattern, 'sets pattern option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.async.js b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.async.js
index 418b4423c344..3a45d30b1f4e 100644
--- a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.async.js
@@ -33,7 +33,7 @@ var lint = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof lint, 'function', 'main export is a function' );
+	t.strictEqual( typeof lint, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -134,7 +134,7 @@ tape( 'the function returns an empty array if all header filenames are valid', f
 			t.ok( false, error.message );
 		}
 		bool = ( isArray( names ) && names.length === 0 );
-		t.equal( bool, true, 'returns an empty array' );
+		t.strictEqual( bool, true, 'returns an empty array' );
 		t.end();
 	}
 });
@@ -150,7 +150,7 @@ tape( 'the function returns an object array if header filenames are not valid',
 			t.ok( false, error.message );
 		}
 		bool = isObjectArray( names );
-		t.equal( bool, true, 'returns an object array' );
+		t.strictEqual( bool, true, 'returns an object array' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.js b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.js
index ce739d3b461d..cef47089ef7a 100644
--- a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.js
@@ -28,11 +28,11 @@ var lint = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof lint, 'function', 'main export is a function' );
+	t.strictEqual( typeof lint, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously lint header filenames', function test( t ) {
-	t.equal( typeof lint.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof lint.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.lint.js b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.lint.js
index 097a609281f6..7aba63eeb2bf 100644
--- a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.lint.js
+++ b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.lint.js
@@ -31,7 +31,7 @@ var lint = require( './../lib/lint.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof lint, 'function', 'main export is a function' );
+	t.strictEqual( typeof lint, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -46,8 +46,8 @@ tape( 'the function enforces that all header base filenames differ from C standa
 	];
 	names = lint( values );
 
-	t.equal( isObjectArray( names ), true, 'returns an object array' );
-	t.equal( names.length, values.length, 'has expected length' );
+	t.strictEqual( isObjectArray( names ), true, 'returns an object array' );
+	t.strictEqual( names.length, values.length, 'has expected length' );
 	t.end();
 });
 
@@ -62,8 +62,8 @@ tape( 'the function enforces that all header base filenames differ from C++ stan
 	];
 	names = lint( values );
 
-	t.equal( isObjectArray( names ), true, 'returns an object array' );
-	t.equal( names.length, values.length, 'has expected length' );
+	t.strictEqual( isObjectArray( names ), true, 'returns an object array' );
+	t.strictEqual( names.length, values.length, 'has expected length' );
 	t.end();
 });
 
@@ -88,8 +88,8 @@ tape( 'the function enforces that all header base filenames are valid', function
 	}
 	names = lint( values );
 
-	t.equal( isObjectArray( names ), true, 'returns an object array' );
-	t.equal( names.length, values.length, 'has expected length' );
+	t.strictEqual( isObjectArray( names ), true, 'returns an object array' );
+	t.strictEqual( names.length, values.length, 'has expected length' );
 	t.end();
 });
 
@@ -114,7 +114,7 @@ tape( 'the function returns an empty array if all header base filenames are vali
 	}
 	names = lint( values );
 
-	t.equal( isArray( names ), true, 'returns an array' );
-	t.equal( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns an array' );
+	t.strictEqual( names.length, 0, 'returns an empty array' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.sync.js b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.sync.js
index b080b047fc2a..0e8fa93fcd2e 100644
--- a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.sync.js
@@ -32,7 +32,7 @@ var lint = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof lint, 'function', 'main export is a function' );
+	t.strictEqual( typeof lint, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns an empty array if unable to resolve header files', f
 	names = lint();
 	bool = ( isArray( names ) && names.length === 0 );
 
-	t.equal( bool, true, 'returns an empty array' );
+	t.strictEqual( bool, true, 'returns an empty array' );
 	t.end();
 
 	function glob() {
@@ -80,7 +80,7 @@ tape( 'the function returns an empty array if all header filenames are valid', f
 	names = lint( opts );
 
 	bool = ( isArray( names ) && names.length === 0 );
-	t.equal( bool, true, 'returns an empty array' );
+	t.strictEqual( bool, true, 'returns an empty array' );
 	t.end();
 });
 
@@ -93,7 +93,7 @@ tape( 'the function returns an object array if header filenames are not valid',
 	};
 	names = lint( opts );
 
-	t.equal( isObjectArray( names ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( names ), true, 'returns an object array' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.validate.js b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.validate.js
index e87183967aa7..49808b06bf6b 100644
--- a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -95,8 +95,8 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.validate.js b/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.validate.js
index c34ea9e277dd..05058de573d8 100644
--- a/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -53,7 +53,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'if provided a `pattern` option which is not a `string`, the function retu
 		err = validate( opts, {
 			'pattern': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -139,7 +139,7 @@ tape( 'if provided an invalid `ignore` option, the function returns a type error
 		err = validate( opts, {
 			'ignore': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -184,7 +184,7 @@ tape( 'if provided an invalid `header` option, the function returns a type error
 		err = validate( opts, {
 			'header': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -207,9 +207,9 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
-	t.equal( obj.pattern, opts.pattern, 'sets pattern option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 
 	t.end();
 });
@@ -227,7 +227,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/lint/namespace-aliases/test/test.validate.js b/lib/node_modules/@stdlib/_tools/lint/namespace-aliases/test/test.validate.js
index 838277a1bf97..85319125198f 100644
--- a/lib/node_modules/@stdlib/_tools/lint/namespace-aliases/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/lint/namespace-aliases/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -53,7 +53,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -97,8 +97,8 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.escape_html.js b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.escape_html.js
index ad178216d507..86fdee4751cc 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.escape_html.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.escape_html.js
@@ -27,19 +27,20 @@ var escapeHTML = require( './../lib/escape_html.js' );
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
-	t.equal( typeof escapeHTML, 'function', 'main export is a function' );
+	t.ok( true, __filename );
+	t.strictEqual( typeof escapeHTML, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a string', function test( t ) {
 	var str = escapeHTML( 'beep' );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 	t.end();
 });
 
 tape( 'the function returns the input string if the input string does not contain any characters to be encoded', function test( t ) {
 	var str = escapeHTML( 'beep boop' );
-	t.equal( str, 'beep boop', 'returns original string' );
+	t.strictEqual( str, 'beep boop', 'returns original string' );
 	t.end();
 });
 
@@ -51,17 +52,17 @@ tape( 'the function encodes HTML special characters', function test( t ) {
 	str = 'Mr. & Mrs. Smith are <insert adjective>.';
 	out = escapeHTML( str );
 	expected = 'Mr. &amp; Mrs. Smith are &lt;insert adjective&gt;.';
-	t.equal( out, expected, 'returns encoded string' );
+	t.strictEqual( out, expected, 'returns encoded string' );
 
 	str = '"Hello World," Susan typed into her computer.';
 	out = escapeHTML( str );
 	expected = '&quot;Hello World,&quot; Susan typed into her computer.';
-	t.equal( out, expected, 'returns encoded string' );
+	t.strictEqual( out, expected, 'returns encoded string' );
 
 	str = 'And God said, \'Let there be light\'';
 	out = escapeHTML( str );
 	expected = 'And God said, &#39;Let there be light&#39;';
-	t.equal( out, expected, 'returns encoded string' );
+	t.strictEqual( out, expected, 'returns encoded string' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.js b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.js
index 3d521f9ca1db..8aad9319701d 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.js
@@ -42,7 +42,8 @@ function setup() {
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
-	t.equal( typeof createElement, 'function', 'main export is a function' );
+	t.ok( true, __filename );
+	t.strictEqual( typeof createElement, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -110,7 +111,7 @@ tape( 'the function returns an HTML string for rendering an SVG equation in GitH
 	expected = '<div class="equation" align="center" data-raw-text="y = mx + b" data-equation="eq:line">\n    <img src="https://cdn.jsdelivr.net/gh/stdlib-js/repo@branch/docs/img/eqn.svg" alt="Equation for a line.">\n    <br>\n</div>';
 	actual = createElement( setup() );
 
-	t.equal( actual, expected, 'returns a HTML string' );
+	t.strictEqual( actual, expected, 'returns a HTML string' );
 	t.end();
 });
 
@@ -121,6 +122,6 @@ tape( 'if not provided an option, the function will set a corresponding HTML att
 	expected = '<div class="equation" align="center" data-raw-text="" data-equation="">\n    <img src="" alt="">\n    <br>\n</div>';
 	actual = createElement();
 
-	t.equal( actual, expected, 'returns a HTML string' );
+	t.strictEqual( actual, expected, 'returns a HTML string' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.render.js b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.render.js
index b2d67925f323..4f58e6fa7e87 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.render.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.render.js
@@ -41,13 +41,14 @@ function setup() {
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
-	t.equal( typeof render, 'function', 'main export is a function' );
+	t.ok( true, __filename );
+	t.strictEqual( typeof render, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a string', function test( t ) {
 	var str = render( setup() );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 	t.end();
 });
 
@@ -58,6 +59,6 @@ tape( 'the function returns an HTML string for rendering an SVG equation in GitH
 	expected = '<div class="equation" align="center" data-raw-text="y = mx + b" data-equation="eq:line">\n    <img src="https://cdn.jsdelivr.net/gh/stdlib-js/repo@branch/docs/img/eqn.svg" alt="Equation for a line.">\n    <br>\n</div>';
 	actual = render( setup() );
 
-	t.equal( actual, expected, 'returns a HTML string' );
+	t.strictEqual( actual, expected, 'returns a HTML string' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.validate.js b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.validate.js
index f21e9c626535..9d5a8f035662 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -234,7 +234,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( obj, opts, 'updates destination object' );
 	t.end();
@@ -251,7 +251,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 			'b': 'c'
 		}
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'destination object is empty' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.escape_html.js b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.escape_html.js
index ad178216d507..86fdee4751cc 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.escape_html.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.escape_html.js
@@ -27,19 +27,20 @@ var escapeHTML = require( './../lib/escape_html.js' );
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
-	t.equal( typeof escapeHTML, 'function', 'main export is a function' );
+	t.ok( true, __filename );
+	t.strictEqual( typeof escapeHTML, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a string', function test( t ) {
 	var str = escapeHTML( 'beep' );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 	t.end();
 });
 
 tape( 'the function returns the input string if the input string does not contain any characters to be encoded', function test( t ) {
 	var str = escapeHTML( 'beep boop' );
-	t.equal( str, 'beep boop', 'returns original string' );
+	t.strictEqual( str, 'beep boop', 'returns original string' );
 	t.end();
 });
 
@@ -51,17 +52,17 @@ tape( 'the function encodes HTML special characters', function test( t ) {
 	str = 'Mr. & Mrs. Smith are <insert adjective>.';
 	out = escapeHTML( str );
 	expected = 'Mr. &amp; Mrs. Smith are &lt;insert adjective&gt;.';
-	t.equal( out, expected, 'returns encoded string' );
+	t.strictEqual( out, expected, 'returns encoded string' );
 
 	str = '"Hello World," Susan typed into her computer.';
 	out = escapeHTML( str );
 	expected = '&quot;Hello World,&quot; Susan typed into her computer.';
-	t.equal( out, expected, 'returns encoded string' );
+	t.strictEqual( out, expected, 'returns encoded string' );
 
 	str = 'And God said, \'Let there be light\'';
 	out = escapeHTML( str );
 	expected = 'And God said, &#39;Let there be light&#39;';
-	t.equal( out, expected, 'returns encoded string' );
+	t.strictEqual( out, expected, 'returns encoded string' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.js b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.js
index 5537f3315113..3cffa1474a6e 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.js
@@ -42,7 +42,8 @@ function setup() {
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
-	t.equal( typeof createElement, 'function', 'main export is a function' );
+	t.ok( true, __filename );
+	t.strictEqual( typeof createElement, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -168,7 +169,7 @@ tape( 'the function returns an HTML string for inlining an SVG equation in Markd
 		if ( error ) {
 			t.ok( false, error.message );
 		} else {
-			t.equal( actual+'\n', expected.toString(), 'returns expected value' );
+			t.strictEqual( actual+'\n', expected.toString(), 'returns expected value' );
 		}
 		t.end();
 	}
@@ -183,7 +184,7 @@ tape( 'if not provided an option, the function will set a corresponding HTML att
 		if ( error ) {
 			t.ok( false, error.message );
 		} else {
-			t.equal( actual, expected.toString(), 'returns expected value' );
+			t.strictEqual( actual, expected.toString(), 'returns expected value' );
 		}
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.render.js b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.render.js
index 3437402a1ce5..159d8cd3d055 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.render.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.render.js
@@ -39,13 +39,14 @@ function setup() {
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
-	t.equal( typeof render, 'function', 'main export is a function' );
+	t.ok( true, __filename );
+	t.strictEqual( typeof render, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a string', function test( t ) {
 	var str = render( setup() );
-	t.equal( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns a string' );
 	t.end();
 });
 
@@ -56,6 +57,6 @@ tape( 'the function returns an HTML string for rendering an inline SVG equation
 	expected = '<div class="equation" align="center" data-raw-text="y = mx + b" data-equation="eq:line">\n    <svg>beep boop</svg>\n</div>';
 	actual = render( setup(), '<svg>beep boop</svg>' );
 
-	t.equal( actual, expected, 'returns an HTML string' );
+	t.strictEqual( actual, expected, 'returns an HTML string' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.validate.js b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.validate.js
index 04ba9a3afd41..497048ad04d2 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -176,7 +176,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( obj, opts, 'updates destination object' );
 	t.end();
@@ -193,7 +193,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 			'b': 'c'
 		}
 	});
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'destination object is empty' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.async.js b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.async.js
index a30242a9c5de..b34b279dd485 100644
--- a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.async.js
@@ -23,6 +23,7 @@
 var join = require( 'path' ).join;
 var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
+var filled = require( '@stdlib/array/base/filled' );
 var noop = require( '@stdlib/utils/noop' );
 var ls = require( './../lib/async.js' );
 
@@ -31,7 +32,7 @@ var ls = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -144,7 +145,7 @@ tape( 'the function returns an error if an error is encountered while searching
 
 	function onList( error ) {
 		if ( error ) {
-			t.equal( error.message, 'beep', 'returns expected error' );
+			t.strictEqual( error.message, 'beep', 'returns expected error' );
 		} else {
 			t.ok( false, 'expected an error' );
 		}
@@ -188,7 +189,7 @@ tape( 'the function returns module dependencies', function test( t ) {
 	dir = join( __dirname, 'fixtures' );
 	fpath = join( dir, 'a.js' );
 
-	expected = new Array( 1 );
+	expected = filled( void 0, 1 );
 	expected[ 0 ] = {
 		'file': fpath,
 		'literals': [
diff --git a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.js b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.js
index ca3cf5f614c1..10e1c1ba560c 100644
--- a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.js
@@ -28,11 +28,11 @@ var ls = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously list module dependencies', function test( t ) {
-	t.equal( typeof ls.sync, 'function', 'has `sync` method' );
+	t.strictEqual( typeof ls.sync, 'function', 'has `sync` method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.sync.js b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.sync.js
index 575046f65e94..d05409f7cd08 100644
--- a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.sync.js
@@ -23,6 +23,7 @@
 var join = require( 'path' ).join;
 var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
+var filled = require( '@stdlib/array/base/filled' );
 var ls = require( './../lib/sync.js' );
 
 
@@ -30,7 +31,7 @@ var ls = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -108,7 +109,7 @@ tape( 'the function returns module dependencies', function test( t ) {
 	dir = join( __dirname, 'fixtures' );
 	fpath = join( dir, 'a.js' );
 
-	expected = new Array( 1 );
+	expected = filled( void 0, 1 );
 	expected[ 0 ] = {
 		'file': fpath,
 		'literals': [
diff --git a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.validate.js b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.validate.js
index 167bb5c09a69..a4a8592d02fb 100644
--- a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'if provided a `pattern` option which is not a `string`, the function retu
 		err = validate( opts, {
 			'pattern': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -123,8 +123,8 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
 });
@@ -142,7 +142,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/modules/import-require/test/test.js b/lib/node_modules/@stdlib/_tools/modules/import-require/test/test.js
index b6adfd2dbb23..8231c3ac7d34 100644
--- a/lib/node_modules/@stdlib/_tools/modules/import-require/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/modules/import-require/test/test.js
@@ -36,7 +36,7 @@ var IMPORTS = readFile( join( __dirname, './fixtures/imports.txt' ) );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.analyze.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.analyze.js
index b087faff1755..acb30bfa7da8 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.analyze.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.analyze.js
@@ -33,7 +33,7 @@ var FILE = '"use strict";\n\nvar foo = require( "foo" );\nimport beep from "beep
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof analyze, 'function', 'main export is a function' );
+	t.strictEqual( typeof analyze, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.async.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.async.js
index 8dc650432355..f459c3d14ec3 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.async.js
@@ -52,7 +52,7 @@ function sort( a, b ) {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pkgDeps, 'function', 'main export is a function' );
+	t.strictEqual( typeof pkgDeps, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -377,7 +377,7 @@ tape( 'the function returns an error if an error occurs while resolving package
 	pkgDeps( 'kaflasdjflsajflkjsd2r0923lajdflkaj20902', clbk );
 
 	function clbk( err ) {
-		t.equal( instanceOf( err, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.filter_builtins.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.filter_builtins.js
index 692f63488874..bfa81fc26907 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.filter_builtins.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.filter_builtins.js
@@ -28,7 +28,7 @@ var filter = require( './../lib/filter_builtins.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof filter, 'function', 'main export is a function' );
+	t.strictEqual( typeof filter, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.filter_literals.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.filter_literals.js
index 7746660e6f85..53f09cb60cad 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.filter_literals.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.filter_literals.js
@@ -28,7 +28,7 @@ var filter = require( './../lib/filter_literals.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof filter, 'function', 'main export is a function' );
+	t.strictEqual( typeof filter, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.js
index 21229859afb7..e110e0176a41 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.js
@@ -28,11 +28,11 @@ var pkgDeps = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pkgDeps, 'function', 'main export is a function' );
+	t.strictEqual( typeof pkgDeps, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously list package dependencies', function test( t ) {
-	t.equal( typeof pkgDeps.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof pkgDeps.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.re_relative.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.re_relative.js
index 124b5832f0db..1ded1f647f4e 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.re_relative.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.re_relative.js
@@ -29,7 +29,7 @@ var RE_RELATIVE = require( './../lib/re_relative.js' );
 
 tape( 'main export is a regular expression', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( instanceOf( RE_RELATIVE, RegExp ), true, 'main export is a regular expression' );
+	t.strictEqual( instanceOf( RE_RELATIVE, RegExp ), true, 'main export is a regular expression' );
 	t.end();
 });
 
@@ -49,7 +49,7 @@ tape( 'the regular expression matches a relative require/import literal', functi
 		'../../foo/../bar/../beep/../../boop.js'
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE_RELATIVE.test( values[ i ] ), true, 'matches a relative require/import literal' );
+		t.strictEqual( RE_RELATIVE.test( values[ i ] ), true, 'matches a relative require/import literal' );
 	}
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'the regular expression does not match a non-relative require/import liter
 		'@foo/bar-beep'
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE_RELATIVE.test( values[ i ] ), false, 'does not match' );
+		t.strictEqual( RE_RELATIVE.test( values[ i ] ), false, 'does not match' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.sync.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.sync.js
index cf25c7800d1a..6fa44a6f87a0 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.sync.js
@@ -30,7 +30,7 @@ var pkgDeps = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pkgDeps, 'function', 'main export is a function' );
+	t.strictEqual( typeof pkgDeps, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -279,6 +279,6 @@ tape( 'the function returns a list of package dependencies (no built-ins)', func
 
 tape( 'the function returns an error if an error occurs while resolving package dependencies', function test( t ) {
 	var err = pkgDeps( 'kaflasdjflsajflkjsd2r0923lajdflkaj20902' );
-	t.equal( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.to_array.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.to_array.js
index a1eed97ff89b..38469e984dbb 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.to_array.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.to_array.js
@@ -29,7 +29,7 @@ var toArray = require( './../lib/to_array.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof toArray, 'function', 'main export is a function' );
+	t.strictEqual( typeof toArray, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -68,7 +68,7 @@ tape( 'the function converts a file cache object to an array', function test( t
 
 	actual = toArray( obj );
 
-	t.equal( isArray( actual ), true, 'returns an array' );
+	t.strictEqual( isArray( actual ), true, 'returns an array' );
 
 	// Note: key iteration order is non-deterministic, so must account for result order variability...
 	if ( actual[ 0 ].file === expected[ 0 ].file ) {
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.validate.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.validate.js
index 8df0e716fe85..f62fb94dea09 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `builtins` option which is not a `boolean`, the function re
 		err = validate( opts, {
 			'builtins': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'if provided a `walk` option which is not a `boolean`, the function return
 		err = validate( opts, {
 			'walk': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'if provided an `aliases` option which is not an `object`, the function re
 		err = validate( opts, {
 			'aliases': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.strictEqual( obj.builtins, opts.builtins, 'sets builtins option' );
 	t.strictEqual( obj.walk, opts.walk, 'sets walk option' );
 	t.deepEqual( obj.aliases, opts.aliases, 'sets aliases option' );
@@ -173,7 +173,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.js
index fd8269d39fbf..6927e76aeae4 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.js
@@ -33,7 +33,7 @@ var walk = require( './../lib/walk_file.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof walk, 'function', 'main export is a function' );
+	t.strictEqual( typeof walk, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -171,8 +171,8 @@ tape( 'the function returns an error if unable to read an input file', function
 	}
 
 	function clbk( err ) {
-		t.equal( instanceOf( err, Error ), true, 'returns an error' );
-		t.equal( err.message, 'beep', 'returns expected error' );
+		t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+		t.strictEqual( err.message, 'beep', 'returns expected error' );
 		t.end();
 	}
 });
@@ -208,8 +208,8 @@ tape( 'the function returns an error if unable to read a relative module depende
 	}
 
 	function clbk( err ) {
-		t.equal( instanceOf( err, Error ), true, 'returns an error' );
-		t.equal( err.message, 'boop', 'returns expected error' );
+		t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+		t.strictEqual( err.message, 'boop', 'returns expected error' );
 		t.end();
 	}
 });
@@ -246,8 +246,8 @@ tape( 'the function returns an error if unable to read a relative module depende
 	}
 
 	function clbk( err ) {
-		t.equal( instanceOf( err, Error ), true, 'returns an error' );
-		t.equal( err.message, 'boop1', 'returns expected error' );
+		t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+		t.strictEqual( err.message, 'boop1', 'returns expected error' );
 		t.end();
 	}
 });
@@ -281,8 +281,8 @@ tape( 'the function returns an error if unable to resolve a relative module depe
 	}
 
 	function clbk( err ) {
-		t.equal( instanceOf( err, Error ), true, 'returns an error' );
-		t.equal( err.message, 'boop', 'returns expected error' );
+		t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+		t.strictEqual( err.message, 'boop', 'returns expected error' );
 		t.end();
 	}
 });
@@ -316,8 +316,8 @@ tape( 'the function returns an error if unable to resolve a relative module depe
 	}
 
 	function clbk( err ) {
-		t.equal( instanceOf( err, Error ), true, 'returns an error' );
-		t.equal( err.message, 'boop1', 'returns expected error' );
+		t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+		t.strictEqual( err.message, 'boop1', 'returns expected error' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.sync.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.sync.js
index f948bb265e10..ba966c32bbea 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.sync.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.sync.js
@@ -32,7 +32,7 @@ var walk = require( './../lib/walk_file.sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof walk, 'function', 'main export is a function' );
+	t.strictEqual( typeof walk, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -69,7 +69,7 @@ tape( 'the function synchronously walks a file\'s relative dependencies', functi
 	tmp = join( __dirname, 'fixtures', 'bool.js' );
 	expected[ tmp ] = [];
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( cache, expected, 'updates dependency cache' );
 
 	t.end();
@@ -106,7 +106,7 @@ tape( 'the function synchronously walks a file\'s relative dependencies (exclude
 	tmp = join( __dirname, 'fixtures', 'bool.js' );
 	expected[ tmp ] = [];
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( cache, expected, 'updates dependency cache' );
 
 	t.end();
@@ -133,7 +133,7 @@ tape( 'the function synchronously walks a file\'s relative dependencies (no walk
 		'fs'
 	];
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( cache, expected, 'updates dependency cache' );
 
 	t.end();
@@ -156,8 +156,8 @@ tape( 'the function returns an error if unable to read an input file', function
 
 	err = walk( {}, '/beep/boop.js', opts );
 
-	t.equal( instanceOf( err, Error ), true, 'returns an error' );
-	t.equal( err.message, 'beep', 'returns expected error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( err.message, 'beep', 'returns expected error' );
 	t.end();
 
 	function readFile() {
@@ -187,8 +187,8 @@ tape( 'the function returns an error if unable to read a relative module depende
 
 	err = walk( {}, fpath1, opts );
 
-	t.equal( instanceOf( err, Error ), true, 'returns an error' );
-	t.equal( err.message, 'boop', 'returns expected error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( err.message, 'boop', 'returns expected error' );
 	t.end();
 
 	function readFile( file, fopts ) {
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.async.js
index 443f74e5b1ed..b16fcc669432 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.async.js
@@ -32,7 +32,7 @@ var ls = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -158,7 +158,7 @@ tape( 'the function returns a string array', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -172,7 +172,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -186,7 +186,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -203,8 +203,8 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isArray( names ), true, 'returns an array' );
-		t.equal( names.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( names ), true, 'returns an array' );
+		t.strictEqual( names.length, 0, 'returns an empty array' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.js
index 29c026114b88..9ab80ef29ba4 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.js
@@ -28,11 +28,11 @@ var ls = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously list browser compatible packages', function test( t ) {
-	t.equal( typeof ls.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof ls.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.sync.js
index 48d505a530b9..648c1a86b1c3 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.sync.js
@@ -30,7 +30,7 @@ var ls = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -75,7 +75,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var names = ls();
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -88,7 +88,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 	};
 	names = ls( opts );
 
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -101,7 +101,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 	};
 	names = ls( opts );
 
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -117,7 +117,7 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 	};
 	names = ls( opts );
 
-	t.equal( isArray( names ), true, 'returns an array' );
-	t.equal( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns an array' );
+	t.strictEqual( names.length, 0, 'returns an empty array' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.validate.js
index c39dd8e6a94e..0991f2aefd96 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -53,7 +53,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'if provided a `pattern` option which is not a `string`, the function retu
 		err = validate( opts, {
 			'pattern': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'if provided a `pattern` option which does not end with `package.json`, th
 		err = validate( opts, {
 			'pattern': values[ i ]
 		});
-		t.equal( err instanceof Error, true, 'returns an error when provided '+values[ i ] );
+		t.strictEqual( err instanceof Error, true, 'returns an error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -163,7 +163,7 @@ tape( 'if provided an `ignore` option which is not an array of strings, the func
 		err = validate( opts, {
 			'ignore': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
-	t.equal( obj.pattern, opts.pattern, 'sets pattern option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
 
 	t.end();
@@ -202,7 +202,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.async.js
index 9ffc351e181c..32469404669d 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.async.js
@@ -29,7 +29,7 @@ var pkgDeps = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pkgDeps, 'function', 'main export is a function' );
+	t.strictEqual( typeof pkgDeps, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.js
index 313aeaa8019a..cc0cd3c7b4a6 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.js
@@ -28,11 +28,11 @@ var resolveDeps = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof resolveDeps, 'function', 'main export is a function' );
+	t.strictEqual( typeof resolveDeps, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously resolve package dependencies', function test( t ) {
-	t.equal( typeof resolveDeps.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof resolveDeps.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.sync.js
index 919f07c07978..a5793c9b54b6 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.sync.js
@@ -28,7 +28,7 @@ var pkgDeps = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pkgDeps, 'function', 'main export is a function' );
+	t.strictEqual( typeof pkgDeps, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.validate.js
index 8f1725b1edf9..054fcc3e8aaf 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'if provided a `builtins` option which is not a `boolean`, the function re
 		err = validate( opts, {
 			'builtins': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'if provided a `dev` option which is not a `boolean`, the function returns
 		err = validate( opts, {
 			'dev': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -151,7 +151,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.builtins, opts.builtins, 'sets builtins option' );
 	t.strictEqual( obj.dev, opts.dev, 'sets dev option' );
@@ -172,7 +172,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.async.js
index 011c67513573..d10c05311d4f 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.async.js
@@ -29,7 +29,7 @@ var entryPoints = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof entryPoints, 'function', 'main export is a function' );
+	t.strictEqual( typeof entryPoints, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.js
index 25e1b25185bf..bd0542aa04a9 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.js
@@ -28,11 +28,11 @@ var entryPoints = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof entryPoints, 'function', 'main export is a function' );
+	t.strictEqual( typeof entryPoints, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously resolve package browser entry points', function test( t ) {
-	t.equal( typeof entryPoints.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof entryPoints.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.sync.js
index 068f364f51ef..6bc70d8cfa21 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.sync.js
@@ -28,7 +28,7 @@ var entryPoints = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof entryPoints, 'function', 'main export is a function' );
+	t.strictEqual( typeof entryPoints, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.validate.js
index d64af7c7878b..663632c5b03e 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -95,8 +95,8 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.js
index 212a1ad43f22..e8d26cbb69f3 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.js
@@ -29,7 +29,7 @@ var depList = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof depList, 'function', 'main export is a function' );
+	t.strictEqual( typeof depList, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -102,7 +102,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var deps = depList( '@stdlib/regexp' );
-	t.equal( isStringArray( deps ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( deps ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -113,7 +113,7 @@ tape( 'the function handles packages that reach into a data directory (i.e., hav
 
 	len = deps.length;
 	for ( i = 0; i < len; i++ ) {
-		t.equal( deps[ i ].indexOf( '/data/' ), -1, 'does not include data directory' );
+		t.strictEqual( deps[ i ].indexOf( '/data/' ), -1, 'does not include data directory' );
 	}
 	t.end();
 });
@@ -127,6 +127,6 @@ tape( 'the function returns a string array (dev option)', function test( t ) {
 	};
 	deps = depList( '@stdlib/regexp', opts );
 
-	t.equal( isStringArray( deps ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( deps ), true, 'returns a string array' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.root.js b/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.root.js
index c4e1618efaba..7607eb5d8b3f 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.root.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.root.js
@@ -29,12 +29,12 @@ var getRoot = require( './../lib/root.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof getRoot, 'function', 'main export is a function' );
+	t.strictEqual( typeof getRoot, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.equal( typeof getRoot( '' ), 'string', 'returns a string' );
+	t.strictEqual( typeof getRoot( '' ), 'string', 'returns a string' );
 	t.end();
 });
 
@@ -48,7 +48,7 @@ tape( 'the function resolves a relative descendant directory', function test( t
 	root = getRoot( '' );
 	dpath = getRoot( dir );
 
-	t.equal( dpath, path.resolve( root, dir ), 'returns resolved descendant directory' );
+	t.strictEqual( dpath, path.resolve( root, dir ), 'returns resolved descendant directory' );
 	t.end();
 });
 
@@ -62,12 +62,12 @@ tape( 'the function does not allow accessing parent directories', function test(
 	root = getRoot( '' );
 	dpath = getRoot( dir );
 
-	t.equal( dpath, root, 'does not return parent directory' );
+	t.strictEqual( dpath, root, 'does not return parent directory' );
 
 	dir = '/proc';
 	dpath = getRoot( dir );
 
-	t.equal( dpath, root, 'does not return parent directory' );
+	t.strictEqual( dpath, root, 'does not return parent directory' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.async.js
index 7311c3409a3a..baf273e2189f 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.async.js
@@ -29,7 +29,7 @@ var pkgDeps = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pkgDeps, 'function', 'main export is a function' );
+	t.strictEqual( typeof pkgDeps, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.js
index 3e17b197e870..c8eb66de7b84 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.js
@@ -28,11 +28,11 @@ var resolveDeps = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof resolveDeps, 'function', 'main export is a function' );
+	t.strictEqual( typeof resolveDeps, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously resolve package dependencies', function test( t ) {
-	t.equal( typeof resolveDeps.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof resolveDeps.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.sync.js
index ac440ea6cf17..eca7bbbdca79 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.sync.js
@@ -28,7 +28,7 @@ var pkgDeps = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pkgDeps, 'function', 'main export is a function' );
+	t.strictEqual( typeof pkgDeps, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.validate.js
index 34392c7ce485..ce07cb34f65e 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'if provided a `builtins` option which is not a `boolean`, the function re
 		err = validate( opts, {
 			'builtins': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'if provided a `dev` option which is not a `boolean`, the function returns
 		err = validate( opts, {
 			'dev': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -151,7 +151,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.builtins, opts.builtins, 'sets builtins option' );
 	t.strictEqual( obj.dev, opts.dev, 'sets dev option' );
@@ -172,7 +172,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.async.js
index a6f1e8c05060..90a01d5ca27e 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.async.js
@@ -29,7 +29,7 @@ var entryPoints = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof entryPoints, 'function', 'main export is a function' );
+	t.strictEqual( typeof entryPoints, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.js
index 8721237bcb17..3640f6738bfa 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.js
@@ -28,11 +28,11 @@ var entryPoints = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof entryPoints, 'function', 'main export is a function' );
+	t.strictEqual( typeof entryPoints, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously resolve package entry points', function test( t ) {
-	t.equal( typeof entryPoints.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof entryPoints.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.sync.js
index 85f5c6051df7..7d802792af98 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.sync.js
@@ -28,7 +28,7 @@ var entryPoints = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof entryPoints, 'function', 'main export is a function' );
+	t.strictEqual( typeof entryPoints, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.validate.js
index bf9592e68451..55c2be78ac8c 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -95,8 +95,8 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.async.js
index ac39f63e069d..1861df3b4d41 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.async.js
@@ -38,7 +38,7 @@ var dir = resolve( __dirname, '..', '..' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof findPkgs, 'function', 'main export is a function' );
+	t.strictEqual( typeof findPkgs, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -137,7 +137,7 @@ tape( 'the function returns a string array (if able to resolve packages)', funct
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( pkgs ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( pkgs ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -161,8 +161,8 @@ tape( 'the function returns an empty array (if unable to resolve packages)', fun
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isArray( pkgs ), true, 'returns an array' );
-		t.equal( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
+		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.js
index 8093b3f12cc5..f13ea509e7e3 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.js
@@ -28,11 +28,11 @@ var findPkgs = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof findPkgs, 'function', 'main export is a function' );
+	t.strictEqual( typeof findPkgs, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously find packages', function test( t ) {
-	t.equal( typeof findPkgs.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof findPkgs.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.sync.js
index 436a49dd11cf..0db414b0ce36 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.sync.js
@@ -37,7 +37,7 @@ var dir = resolve( __dirname, '..', '..' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof findPkgs, 'function', 'main export is a function' );
+	t.strictEqual( typeof findPkgs, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns a string array (if able to resolve packages)', funct
 	};
 	pkgs = findPkgs( opts );
 
-	t.equal( isStringArray( pkgs ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( pkgs ), true, 'returns a string array' );
 
 	t.end();
 });
@@ -77,8 +77,8 @@ tape( 'the function returns an empty array (if unable to resolve packages)', fun
 	});
 	pkgs = findPkgs();
 
-	t.equal( isArray( pkgs ), true, 'returns an array' );
-	t.equal( pkgs.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( pkgs ), true, 'returns an array' );
+	t.strictEqual( pkgs.length, 0, 'returns an empty array' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.transform.js b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.transform.js
index ad7124724d89..717dbb2bd570 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.transform.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.transform.js
@@ -28,7 +28,7 @@ var transform = require( './../lib/transform.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof transform, 'function', 'main export is a function' );
+	t.strictEqual( typeof transform, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.validate.js
index 79f88a6418dd..e496f6001760 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'if provided a `pattern` option which is not a `string`, the function retu
 		err = validate( opts, {
 			'pattern': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -136,7 +136,7 @@ tape( 'if provided an `ignore` option which is not an array of strings, the func
 		err = validate( opts, {
 			'ignore': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -154,9 +154,9 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
-	t.equal( obj.pattern, opts.pattern, 'sets pattern option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
 
 	t.end();
@@ -175,7 +175,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.async.js
index 9f72b81057cb..a24068db2b10 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.async.js
@@ -32,7 +32,7 @@ var ls = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -156,7 +156,7 @@ tape( 'the function returns a string array', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -170,7 +170,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -184,7 +184,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -201,8 +201,8 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isArray( names ), true, 'returns an array' );
-		t.equal( names.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( names ), true, 'returns an array' );
+		t.strictEqual( names.length, 0, 'returns an empty array' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.js
index b944b6c34e16..7b9b1452cc59 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.js
@@ -28,11 +28,11 @@ var ls = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously list package names', function test( t ) {
-	t.equal( typeof ls.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof ls.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.root.js b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.root.js
index c4e1618efaba..7607eb5d8b3f 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.root.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.root.js
@@ -29,12 +29,12 @@ var getRoot = require( './../lib/root.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof getRoot, 'function', 'main export is a function' );
+	t.strictEqual( typeof getRoot, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.equal( typeof getRoot( '' ), 'string', 'returns a string' );
+	t.strictEqual( typeof getRoot( '' ), 'string', 'returns a string' );
 	t.end();
 });
 
@@ -48,7 +48,7 @@ tape( 'the function resolves a relative descendant directory', function test( t
 	root = getRoot( '' );
 	dpath = getRoot( dir );
 
-	t.equal( dpath, path.resolve( root, dir ), 'returns resolved descendant directory' );
+	t.strictEqual( dpath, path.resolve( root, dir ), 'returns resolved descendant directory' );
 	t.end();
 });
 
@@ -62,12 +62,12 @@ tape( 'the function does not allow accessing parent directories', function test(
 	root = getRoot( '' );
 	dpath = getRoot( dir );
 
-	t.equal( dpath, root, 'does not return parent directory' );
+	t.strictEqual( dpath, root, 'does not return parent directory' );
 
 	dir = '/proc';
 	dpath = getRoot( dir );
 
-	t.equal( dpath, root, 'does not return parent directory' );
+	t.strictEqual( dpath, root, 'does not return parent directory' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.sync.js
index 48d505a530b9..648c1a86b1c3 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.sync.js
@@ -30,7 +30,7 @@ var ls = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -75,7 +75,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var names = ls();
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -88,7 +88,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 	};
 	names = ls( opts );
 
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -101,7 +101,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 	};
 	names = ls( opts );
 
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -117,7 +117,7 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 	};
 	names = ls( opts );
 
-	t.equal( isArray( names ), true, 'returns an array' );
-	t.equal( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns an array' );
+	t.strictEqual( names.length, 0, 'returns an empty array' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.transform.js b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.transform.js
index 064fe93c3c1b..d10d2e2bab3a 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.transform.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.transform.js
@@ -28,7 +28,7 @@ var transform = require( './../lib/transform.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof transform, 'function', 'main export is a function' );
+	t.strictEqual( typeof transform, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.js
index 0650cbf7c952..3031b444196f 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.js
@@ -29,7 +29,7 @@ var namespaceDeps = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof namespaceDeps, 'function', 'main export is a function' );
+	t.strictEqual( typeof namespaceDeps, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -102,7 +102,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var deps = namespaceDeps( '@stdlib/regexp' );
-	t.equal( isStringArray( deps ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( deps ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -115,7 +115,7 @@ tape( 'the function returns a string array (dev option)', function test( t ) {
 	};
 	deps = namespaceDeps( '@stdlib/regexp', opts );
 
-	t.equal( isStringArray( deps ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( deps ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -128,6 +128,6 @@ tape( 'the function returns a string array (level option)', function test( t ) {
 	};
 	deps = namespaceDeps( '@stdlib/regexp', opts );
 
-	t.equal( isStringArray( deps ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( deps ), true, 'returns a string array' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.root.js b/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.root.js
index c4e1618efaba..7607eb5d8b3f 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.root.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.root.js
@@ -29,12 +29,12 @@ var getRoot = require( './../lib/root.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof getRoot, 'function', 'main export is a function' );
+	t.strictEqual( typeof getRoot, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.equal( typeof getRoot( '' ), 'string', 'returns a string' );
+	t.strictEqual( typeof getRoot( '' ), 'string', 'returns a string' );
 	t.end();
 });
 
@@ -48,7 +48,7 @@ tape( 'the function resolves a relative descendant directory', function test( t
 	root = getRoot( '' );
 	dpath = getRoot( dir );
 
-	t.equal( dpath, path.resolve( root, dir ), 'returns resolved descendant directory' );
+	t.strictEqual( dpath, path.resolve( root, dir ), 'returns resolved descendant directory' );
 	t.end();
 });
 
@@ -62,12 +62,12 @@ tape( 'the function does not allow accessing parent directories', function test(
 	root = getRoot( '' );
 	dpath = getRoot( dir );
 
-	t.equal( dpath, root, 'does not return parent directory' );
+	t.strictEqual( dpath, root, 'does not return parent directory' );
 
 	dir = '/proc';
 	dpath = getRoot( dir );
 
-	t.equal( dpath, root, 'does not return parent directory' );
+	t.strictEqual( dpath, root, 'does not return parent directory' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.async.js
index fbbccf8fbffd..634098b889d9 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.async.js
@@ -32,7 +32,7 @@ var ls = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -158,7 +158,7 @@ tape( 'the function returns a string array', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -172,7 +172,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -186,7 +186,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -203,8 +203,8 @@ tape( 'the function returns an empty array if unable to resolve any namespaces (
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isArray( names ), true, 'returns an array' );
-		t.equal( names.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( names ), true, 'returns an array' );
+		t.strictEqual( names.length, 0, 'returns an empty array' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.js
index 0a4a6da1b448..99b95cb7f98e 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.js
@@ -28,11 +28,11 @@ var ls = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously list namespaces', function test( t ) {
-	t.equal( typeof ls.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof ls.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.sync.js
index 48d505a530b9..648c1a86b1c3 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.sync.js
@@ -30,7 +30,7 @@ var ls = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -75,7 +75,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var names = ls();
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -88,7 +88,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 	};
 	names = ls( opts );
 
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -101,7 +101,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 	};
 	names = ls( opts );
 
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -117,7 +117,7 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 	};
 	names = ls( opts );
 
-	t.equal( isArray( names ), true, 'returns an array' );
-	t.equal( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns an array' );
+	t.strictEqual( names.length, 0, 'returns an empty array' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.validate.js
index c39dd8e6a94e..0991f2aefd96 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -53,7 +53,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'if provided a `pattern` option which is not a `string`, the function retu
 		err = validate( opts, {
 			'pattern': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'if provided a `pattern` option which does not end with `package.json`, th
 		err = validate( opts, {
 			'pattern': values[ i ]
 		});
-		t.equal( err instanceof Error, true, 'returns an error when provided '+values[ i ] );
+		t.strictEqual( err instanceof Error, true, 'returns an error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -163,7 +163,7 @@ tape( 'if provided an `ignore` option which is not an array of strings, the func
 		err = validate( opts, {
 			'ignore': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
-	t.equal( obj.pattern, opts.pattern, 'sets pattern option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
 
 	t.end();
@@ -202,7 +202,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.async.js
index f23edca21092..d2e561de8251 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.async.js
@@ -32,7 +32,7 @@ var ls = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -158,7 +158,7 @@ tape( 'the function returns a string array', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -172,7 +172,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -186,7 +186,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -203,8 +203,8 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isArray( names ), true, 'returns an array' );
-		t.equal( names.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( names ), true, 'returns an array' );
+		t.strictEqual( names.length, 0, 'returns an empty array' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.js
index 5fc8e98741f2..d95d5040e825 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.js
@@ -28,11 +28,11 @@ var ls = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously list standalone packages', function test( t ) {
-	t.equal( typeof ls.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof ls.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.sync.js
index a44e2441be25..729ccc7916c2 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.sync.js
@@ -30,7 +30,7 @@ var ls = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -75,7 +75,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var names = ls();
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -88,7 +88,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 	};
 	names = ls( opts );
 
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -101,7 +101,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 	};
 	names = ls( opts );
 
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -117,7 +117,7 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 	};
 	names = ls( opts );
 
-	t.equal( isArray( names ), true, 'returns an array' );
-	t.equal( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns an array' );
+	t.strictEqual( names.length, 0, 'returns an empty array' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.validate.js
index 3df37b5ec2d0..bb12d1f04606 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -53,7 +53,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'if provided a `pattern` option which is not a `string`, the function retu
 		err = validate( opts, {
 			'pattern': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'if provided a `pattern` option which does not end with `package.json`, th
 		err = validate( opts, {
 			'pattern': values[ i ]
 		});
-		t.equal( err instanceof Error, true, 'returns an error when provided '+values[ i ] );
+		t.strictEqual( err instanceof Error, true, 'returns an error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -163,7 +163,7 @@ tape( 'if provided an `ignore` option which is not an array of strings, the func
 		err = validate( opts, {
 			'ignore': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
-	t.equal( obj.pattern, opts.pattern, 'sets pattern option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
 
 	t.end();
@@ -202,7 +202,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.async.js
index e5fbf30d503b..7f8fa58fd703 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.async.js
@@ -32,7 +32,7 @@ var ls = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -184,7 +184,7 @@ tape( 'the function returns a string array', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -198,7 +198,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -212,7 +212,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 		t.end();
 	}
 });
@@ -229,8 +229,8 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isArray( names ), true, 'returns an array' );
-		t.equal( names.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( names ), true, 'returns an array' );
+		t.strictEqual( names.length, 0, 'returns an empty array' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.js
index 7b141565f2cc..5c45c97509dd 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.js
@@ -28,11 +28,11 @@ var ls = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously topologically sort packages', function test( t ) {
-	t.equal( typeof ls.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof ls.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.sync.js
index 57a932fd46fb..e341e73729bf 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.sync.js
@@ -31,7 +31,7 @@ var ls = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ls, 'function', 'main export is a function' );
+	t.strictEqual( typeof ls, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -76,7 +76,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var names = ls();
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -89,7 +89,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 	};
 	names = ls( opts );
 
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -102,7 +102,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 	};
 	names = ls( opts );
 
-	t.equal( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
 	t.end();
 });
 
@@ -118,8 +118,8 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 	};
 	names = ls( opts );
 
-	t.equal( isArray( names ), true, 'returns an array' );
-	t.equal( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns an array' );
+	t.strictEqual( names.length, 0, 'returns an empty array' );
 	t.end();
 });
 
@@ -135,11 +135,11 @@ tape( 'the function returns an error if unable to perform a topological sort', f
 	});
 	names = ls();
 
-	t.equal( names instanceof Error, true, 'returns expected value' );
+	t.strictEqual( names instanceof Error, true, 'returns expected value' );
 	t.end();
 
 	function pkgNames() {
-		return [ '@stdlib/foo', '@stdlib/bar' ]
+		return [ '@stdlib/foo', '@stdlib/bar' ];
 	}
 
 	function sort() {
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.validate.js
index 3df37b5ec2d0..bb12d1f04606 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -53,7 +53,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'if provided a `pattern` option which is not a `string`, the function retu
 		err = validate( opts, {
 			'pattern': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'if provided a `pattern` option which does not end with `package.json`, th
 		err = validate( opts, {
 			'pattern': values[ i ]
 		});
-		t.equal( err instanceof Error, true, 'returns an error when provided '+values[ i ] );
+		t.strictEqual( err instanceof Error, true, 'returns an error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -163,7 +163,7 @@ tape( 'if provided an `ignore` option which is not an array of strings, the func
 		err = validate( opts, {
 			'ignore': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
-	t.equal( obj.pattern, opts.pattern, 'sets pattern option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
 
 	t.end();
@@ -202,7 +202,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.async.js
index 09e1477c04ed..f15fe3a9e0f0 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.async.js
@@ -32,7 +32,7 @@ var pkgTree = require( './../lib/async.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pkgTree, 'function', 'main export is a function' );
+	t.strictEqual( typeof pkgTree, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -158,7 +158,7 @@ tape( 'the function returns an object', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isObject( tree ), true, 'returns an object' );
+		t.strictEqual( isObject( tree ), true, 'returns an object' );
 		t.end();
 	}
 });
@@ -172,7 +172,7 @@ tape( 'the function returns an object (dir option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isObject( tree ), true, 'returns an object' );
+		t.strictEqual( isObject( tree ), true, 'returns an object' );
 		t.end();
 	}
 });
@@ -186,7 +186,7 @@ tape( 'the function returns an object (pattern option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isObject( tree ), true, 'returns an object' );
+		t.strictEqual( isObject( tree ), true, 'returns an object' );
 		t.end();
 	}
 });
@@ -203,8 +203,8 @@ tape( 'the function returns an empty object if unable to resolve any packages (i
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isObject( tree ), true, 'returns an object' );
-		t.equal( isEmptyObject( tree ), true, 'returns an empty object' );
+		t.strictEqual( isObject( tree ), true, 'returns an object' );
+		t.strictEqual( isEmptyObject( tree ), true, 'returns an empty object' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.js
index 1ec03c3affc1..9d7354b85c1a 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.js
@@ -28,11 +28,11 @@ var pkgTree = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pkgTree, 'function', 'main export is a function' );
+	t.strictEqual( typeof pkgTree, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method to synchronously generate a package tree', function test( t ) {
-	t.equal( typeof pkgTree.sync, 'function', 'has sync method' );
+	t.strictEqual( typeof pkgTree.sync, 'function', 'has sync method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.sync.js
index 4ccfa5cf22e2..aba7ab8474f8 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.sync.js
@@ -30,7 +30,7 @@ var pkgTree = require( './../lib/sync.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof pkgTree, 'function', 'main export is a function' );
+	t.strictEqual( typeof pkgTree, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -75,7 +75,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns an object', function test( t ) {
 	var tree = pkgTree();
-	t.equal( isObject( tree ), true, 'returns an object' );
+	t.strictEqual( isObject( tree ), true, 'returns an object' );
 	t.end();
 });
 
@@ -87,7 +87,7 @@ tape( 'the function returns an object (dir option)', function test( t ) {
 		'dir': './@stdlib/math/base'
 	};
 	tree = pkgTree( opts );
-	t.equal( isObject( tree ), true, 'returns an object' );
+	t.strictEqual( isObject( tree ), true, 'returns an object' );
 	t.end();
 });
 
@@ -100,7 +100,7 @@ tape( 'the function returns an object (pattern option)', function test( t ) {
 	};
 	tree = pkgTree( opts );
 
-	t.equal( isObject( tree ), true, 'returns an object' );
+	t.strictEqual( isObject( tree ), true, 'returns an object' );
 	t.end();
 });
 
@@ -116,7 +116,7 @@ tape( 'the function returns an empty object if unable to resolve any packages (i
 	};
 	tree = pkgTree( opts );
 
-	t.equal( isObject( tree ), true, 'returns an object' );
-	t.equal( isEmptyObject( tree ), true, 'returns an empty object' );
+	t.strictEqual( isObject( tree ), true, 'returns an object' );
+	t.strictEqual( isEmptyObject( tree ), true, 'returns an empty object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.validate.js
index cc68dc1646e8..d103bd59e2f8 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -53,7 +53,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'if provided a `pattern` option which is not a `string`, the function retu
 		err = validate( opts, {
 			'pattern': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'if provided a `pattern` option which does not end with `package.json`, th
 		err = validate( opts, {
 			'pattern': values[ i ]
 		});
-		t.equal( err instanceof Error, true, 'returns an error when provided '+values[ i ] );
+		t.strictEqual( err instanceof Error, true, 'returns an error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -163,7 +163,7 @@ tape( 'if provided an `ignore` option which is not an array of strings, the func
 		err = validate( opts, {
 			'ignore': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -181,9 +181,9 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
-	t.equal( obj.pattern, opts.pattern, 'sets pattern option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
 
 	t.end();
@@ -202,7 +202,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/readme/to-html/test/test.validate.js b/lib/node_modules/@stdlib/_tools/readme/to-html/test/test.validate.js
index 9feeab9f5478..a2cd46fa1b5a 100644
--- a/lib/node_modules/@stdlib/_tools/readme/to-html/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/readme/to-html/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `out` option which is not a
 		err = validate( {}, {
 			'out': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `tests` option which is not a
 		err = validate( {}, {
 			'tests': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided a `benchmarks` option which is
 		err = validate( {}, {
 			'benchmarks': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `source` option which is not
 		err = validate( {}, {
 			'source': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -181,7 +181,7 @@ tape( 'the function returns an error if provided a `title` option which is not a
 		err = validate( {}, {
 			'title': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -207,7 +207,7 @@ tape( 'the function returns an error if provided a `head` option which is not a
 		err = validate( {}, {
 			'head': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -233,7 +233,7 @@ tape( 'the function returns an error if provided a `prepend` option which is not
 		err = validate( {}, {
 			'prepend': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -259,7 +259,7 @@ tape( 'the function returns an error if provided an `append` option which is not
 		err = validate( {}, {
 			'append': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -284,7 +284,7 @@ tape( 'the function returns an error if provided a `fragment` option which is no
 		err = validate( {}, {
 			'fragment': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -308,7 +308,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -327,7 +327,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/namespace/data/test/test__js.txt b/lib/node_modules/@stdlib/_tools/scaffold/namespace/data/test/test__js.txt
index 268600b54ad5..254ae0044c56 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/namespace/data/test/test__js.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/namespace/data/test/test__js.txt
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'returns expected value' );
+	t.strictEqual( keys.length > 0, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/random-array-binary/data/test/test__js.txt b/lib/node_modules/@stdlib/_tools/scaffold/random-array-binary/data/test/test__js.txt
index 0f89dff768c5..5be6271305cb 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/random-array-binary/data/test/test__js.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/random-array-binary/data/test/test__js.txt
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/random-array-ternary/data/test/test__js.txt b/lib/node_modules/@stdlib/_tools/scaffold/random-array-ternary/data/test/test__js.txt
index 0f89dff768c5..5be6271305cb 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/random-array-ternary/data/test/test__js.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/random-array-ternary/data/test/test__js.txt
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/random-array-unary/data/test/test__js.txt b/lib/node_modules/@stdlib/_tools/scaffold/random-array-unary/data/test/test__js.txt
index 0f89dff768c5..5be6271305cb 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/random-array-unary/data/test/test__js.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/random-array-unary/data/test/test__js.txt
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/random-strided-unary/data/test/test__js.txt b/lib/node_modules/@stdlib/_tools/scaffold/random-strided-unary/data/test/test__js.txt
index 7305bdab35e3..cefba6d946d8 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/random-strided-unary/data/test/test__js.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/random-strided-unary/data/test/test__js.txt
@@ -44,31 +44,31 @@ tape( 'attached to the main export is a `factory` method', function test( t ) {
 });
 
 tape( 'attached to the main export is the underlying PRNG', function test( t ) {
-	t.equal( typeof random.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof random.PRNG, 'function', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed', function test( t ) {
-	t.equal( isUint32Array( random.seed ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.seed ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator seed length', function test( t ) {
-	t.equal( typeof random.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof random.seedLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state', function test( t ) {
-	t.equal( isUint32Array( random.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( random.state ), true, 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state length', function test( t ) {
-	t.equal( typeof random.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof random.stateLength, 'number', 'has property' );
 	t.end();
 });
 
 tape( 'attached to the main export is the generator state size', function test( t ) {
-	t.equal( typeof random.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof random.byteLength, 'number', 'has property' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/cli_test.validate.js.txt b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/cli_test.validate.js.txt
index b933e142c664..174afd3f1b67 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/cli_test.validate.js.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/cli_test.validate.js.txt
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -112,7 +112,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_1.txt b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_1.txt
index c9236a67b12d..17b6c1f57401 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_1.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_1.txt
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns an error if provided a `copy` option which is not a
 		err = validate( {}, {
 			'copy': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -138,7 +138,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_2.txt b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_2.txt
index 76695a96fa3b..062c5e2902e0 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_2.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_2.txt
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided a `cmd` option which is not a s
 		err = validate( {}, {
 			'cmd': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function returns an error if provided a `concurrency` option which is
 		err = validate( {}, {
 			'concurrency': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -135,7 +135,7 @@ tape( 'the function returns an error if provided a `workers` option which is not
 		err = validate( {}, {
 			'workers': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -160,7 +160,7 @@ tape( 'the function returns an error if provided a `ordered` option which is not
 		err = validate( {}, {
 			'ordered': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -188,7 +188,7 @@ tape( 'the function returns an error if provided a `uid` option which is not a n
 		err = validate( {}, {
 			'uid': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -216,7 +216,7 @@ tape( 'the function returns an error if provided a `gid` option which is not a n
 		err = validate( {}, {
 			'gid': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -244,7 +244,7 @@ tape( 'the function returns an error if provided a `maxBuffer` option which is n
 		err = validate( {}, {
 			'maxBuffer': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -266,7 +266,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -285,7 +285,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_3.txt b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_3.txt
index 9f4b7c51c04a..8718ffcf38fb 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_3.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_3.txt
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided a `html` option which is not a
 		err = validate( {}, {
 			'html': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `javascript` option which is
 		err = validate( {}, {
 			'javascript': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function returns an error if provided a `open` option which is not a
 		err = validate( {}, {
 			'open': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -163,7 +163,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_4.txt b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_4.txt
index c9236a67b12d..17b6c1f57401 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_4.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_4.txt
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns an error if provided a `copy` option which is not a
 		err = validate( {}, {
 			'copy': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -138,7 +138,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/test.js b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/test.js
index 22f782bca859..fc494e91545d 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/test.js
@@ -49,7 +49,7 @@ var CURRENT_YEAR = String( currentYear() );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof create, 'function', 'main export is a function' );
+	t.strictEqual( typeof create, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/validate-js/test/test.js b/lib/node_modules/@stdlib/_tools/scaffold/validate-js/test/test.js
index fcad06e285fc..772311071ae4 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/validate-js/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/scaffold/validate-js/test/test.js
@@ -47,7 +47,7 @@ var CURRENT_YEAR = String( currentYear() );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof create, 'function', 'main export is a function' );
+	t.strictEqual( typeof create, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.validate.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.validate.js
index e05009a114c9..d5271cb62f63 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.validate.js
@@ -106,7 +106,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'if provided a `pattern` option which is not a `string`, the function retu
 		err = validate( opts, {
 			'pattern': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -165,7 +165,7 @@ tape( 'if provided an `ignore` option which is not an array of strings, the func
 		err = validate( opts, {
 			'ignore': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.validate.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.validate.js
index e05009a114c9..d5271cb62f63 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.validate.js
@@ -106,7 +106,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'if provided a `pattern` option which is not a `string`, the function retu
 		err = validate( opts, {
 			'pattern': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -165,7 +165,7 @@ tape( 'if provided an `ignore` option which is not an array of strings, the func
 		err = validate( opts, {
 			'ignore': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.validate.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.validate.js
index e05009a114c9..d5271cb62f63 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.validate.js
@@ -106,7 +106,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'if provided a `pattern` option which is not a `string`, the function retu
 		err = validate( opts, {
 			'pattern': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -165,7 +165,7 @@ tape( 'if provided an `ignore` option which is not an array of strings, the func
 		err = validate( opts, {
 			'ignore': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/test-cov/tape-istanbul/test/test.validate.js b/lib/node_modules/@stdlib/_tools/test-cov/tape-istanbul/test/test.validate.js
index 8622069726de..cd149839dff6 100644
--- a/lib/node_modules/@stdlib/_tools/test-cov/tape-istanbul/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/test-cov/tape-istanbul/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided a `dir` option which is not a s
 		err = validate( {}, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `global` option which is not
 		err = validate( {}, {
 			'global': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -139,7 +139,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/test/test.js b/lib/node_modules/@stdlib/_tools/test/test.js
index 651e3e02bff8..85d883db5d5e 100644
--- a/lib/node_modules/@stdlib/_tools/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/test/test.js
@@ -29,6 +29,6 @@ var ns = require( './../lib' );
 
 tape( 'main export is null', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( isNull( ns ), true, 'main export is null' );
+	t.strictEqual( isNull( ns ), true, 'main export is null' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/tests/browser-build/test/test.validate.js b/lib/node_modules/@stdlib/_tools/tests/browser-build/test/test.validate.js
index f562b9f3e8b8..0cafe1eb6078 100644
--- a/lib/node_modules/@stdlib/_tools/tests/browser-build/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/tests/browser-build/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided a `pattern` option which is not
 		err = validate( {}, {
 			'pattern': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `bundle` option which is not
 		err = validate( {}, {
 			'bundle': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided a `mount` option which is not a
 		err = validate( {}, {
 			'mount': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function returns an error if provided a `html` option which is not a
 		err = validate( {}, {
 			'html': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -181,7 +181,7 @@ tape( 'the function returns an error if provided a `title` option which is not a
 		err = validate( {}, {
 			'title': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -201,7 +201,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -220,7 +220,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.cli.js b/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.cli.js
index 31670db4c074..991a2ae58783 100644
--- a/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.cli.js
+++ b/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.cli.js
@@ -167,7 +167,7 @@ tape( 'the command-line interface generates a bundle', opts, function test( t )
 				evil( stdout.toString() );
 				t.fail( 'should throw an error' );
 			} catch ( err ) {
-				t.equal( err.message, 'BEEP', 'has expected error message' );
+				t.strictEqual( err.message, 'BEEP', 'has expected error message' );
 			}
 		}
 		t.end();
@@ -200,7 +200,7 @@ tape( 'the command-line interface supports providing a custom glob pattern', opt
 				evil( stdout.toString() );
 				t.fail( 'should throw an error' );
 			} catch ( err ) {
-				t.equal( err.message, 'BEEP', 'has expected error message' );
+				t.strictEqual( err.message, 'BEEP', 'has expected error message' );
 			}
 		}
 		t.end();
diff --git a/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.js b/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.js
index d14a42ec644b..936078fbf047 100644
--- a/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.js
@@ -35,7 +35,7 @@ var bundle = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof bundle, 'function', 'main export is a function' );
+	t.strictEqual( typeof bundle, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -137,7 +137,7 @@ tape( 'the function generates a bundle', function test( t ) {
 				evil( output.toString() );
 				t.fail( 'should throw an error' );
 			} catch ( err ) {
-				t.equal( err.message, 'BEEP', 'has expected error message' );
+				t.strictEqual( err.message, 'BEEP', 'has expected error message' );
 			}
 		}
 		t.end();
@@ -165,7 +165,7 @@ tape( 'the function generates a bundle (custom glob pattern)', function test( t
 				evil( output.toString() );
 				t.fail( 'should throw an error' );
 			} catch ( err ) {
-				t.equal( err.message, 'BEEP', 'has expected error message' );
+				t.strictEqual( err.message, 'BEEP', 'has expected error message' );
 			}
 		}
 		t.end();
@@ -200,7 +200,7 @@ tape( 'the function supports providing an output file path', function test( t )
 			evil( out.toString() );
 			t.fail( 'should throw an error' );
 		} catch ( err ) {
-			t.equal( err.message, 'BEEP', 'has expected error message' );
+			t.strictEqual( err.message, 'BEEP', 'has expected error message' );
 		}
 
 		unlink( opath );
diff --git a/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.validate.js b/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.validate.js
index 2cd44a5a88be..66171c1ec14e 100644
--- a/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `out` option which is not a
 		err = validate( {}, {
 			'out': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `pattern` option which is not
 		err = validate( {}, {
 			'pattern': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -139,7 +139,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/tests/html/test/test.js b/lib/node_modules/@stdlib/_tools/tests/html/test/test.js
index a31c9bcf5199..7baa03ab296d 100644
--- a/lib/node_modules/@stdlib/_tools/tests/html/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/tests/html/test/test.js
@@ -37,7 +37,7 @@ var EXPECTED = readFile( join( __dirname, 'fixtures', 'expected.txt' ) );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof bundle, 'function', 'main export is a function' );
+	t.strictEqual( typeof bundle, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/tests/html/test/test.validate.js b/lib/node_modules/@stdlib/_tools/tests/html/test/test.validate.js
index 093a2fc7f06b..8a388b894d9b 100644
--- a/lib/node_modules/@stdlib/_tools/tests/html/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/tests/html/test/test.validate.js
@@ -28,7 +28,7 @@ var validate = require( './../lib/validate.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof validate, 'function', 'main export is a function' );
+	t.strictEqual( typeof validate, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns an error if not provided an object', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided an `out` option which is not a
 		err = validate( {}, {
 			'out': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `title` option which is not a
 		err = validate( {}, {
 			'title': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -139,7 +139,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/utils/uncapitalize-pkg-description/test/test.js b/lib/node_modules/@stdlib/_tools/utils/uncapitalize-pkg-description/test/test.js
index dd638b797abe..1986c2ee3ccb 100644
--- a/lib/node_modules/@stdlib/_tools/utils/uncapitalize-pkg-description/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/utils/uncapitalize-pkg-description/test/test.js
@@ -28,7 +28,7 @@ var uncapitalizeDescription = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof uncapitalizeDescription, 'function', 'main export is a function' );
+	t.strictEqual( typeof uncapitalizeDescription, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'the function throws an error if not provided a string', function test( t
 });
 
 tape( 'the function returns an empty string if provided an empty string', function test( t ) {
-	t.equal( uncapitalizeDescription( '' ), '', 'returns empty string' );
+	t.strictEqual( uncapitalizeDescription( '' ), '', 'returns empty string' );
 	t.end();
 });
 
@@ -70,15 +70,15 @@ tape( 'the function turns the first character of a `stdlib` package description
 
 	descr = 'Replace search occurrences with a replacement string.';
 	out = uncapitalizeDescription( descr );
-	t.equal( out, 'replace search occurrences with a replacement string.', 'turns first character lowercase' );
+	t.strictEqual( out, 'replace search occurrences with a replacement string.', 'turns first character lowercase' );
 
 	descr = 'Poisson distribution constructor.';
 	out = uncapitalizeDescription( descr );
-	t.equal( out, descr, 'leaves proper nouns intact' );
+	t.strictEqual( out, descr, 'leaves proper nouns intact' );
 
 	descr = 'Test for deep equality between two values.';
 	out = uncapitalizeDescription( descr );
-	t.equal( out, 'test for deep equality between two values.', 'turns first character lowercase' );
+	t.strictEqual( out, 'test for deep equality between two values.', 'turns first character lowercase' );
 
 	t.end();
 });

From 7483bef13b1d3241347266d25a02957269419825 Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Thu, 14 Aug 2025 13:37:37 -0500
Subject: [PATCH 11/32] test: use .strictEqual() instead of .equal()

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/complex/base/test/test.js         |  2 +-
 .../complex/float32/base/assert/test/test.js  |  2 +-
 .../float32/base/identity/test/test.js        | 52 +++++++++----------
 .../float32/base/identity/test/test.native.js | 52 +++++++++----------
 .../@stdlib/complex/float32/base/test/test.js |  2 +-
 .../@stdlib/complex/float32/test/test.js      |  2 +-
 .../complex/float64/base/assert/test/test.js  |  2 +-
 .../float64/base/identity/test/test.js        | 52 +++++++++----------
 .../float64/base/identity/test/test.native.js | 52 +++++++++----------
 .../@stdlib/complex/float64/base/test/test.js |  2 +-
 .../@stdlib/complex/float64/test/test.js      |  2 +-
 lib/node_modules/@stdlib/complex/test/test.js |  2 +-
 .../@stdlib/console/log-each-map/test/test.js |  6 +--
 .../@stdlib/console/log-each/test/test.js     | 24 ++++-----
 lib/node_modules/@stdlib/console/test/test.js |  2 +-
 .../number/float32/base/assert/test/test.js   |  2 +-
 .../number/float32/base/exponent/test/test.js | 18 +++----
 .../float32/base/exponent/test/test.native.js | 18 +++----
 .../float32/base/from-word/test/test.js       | 32 ++++++------
 .../base/from-word/test/test.native.js        | 32 ++++++------
 .../number/float32/base/identity/test/test.js | 14 ++---
 .../float32/base/identity/test/test.native.js | 14 ++---
 .../base/normalize/test/test.assign.js        | 22 ++++----
 .../float32/base/normalize/test/test.main.js  | 10 ++--
 .../base/normalize/test/test.native.js        | 10 ++--
 .../number/float32/base/signbit/test/test.js  |  8 +--
 .../float32/base/signbit/test/test.native.js  |  8 +--
 .../float32/base/significand/test/test.js     | 18 +++----
 .../base/significand/test/test.native.js      | 18 +++----
 .../@stdlib/number/float32/base/test/test.js  |  4 +-
 .../base/to-binary-string/test/test.js        | 20 +++----
 .../number/float32/base/to-word/test/test.js  | 32 ++++++------
 .../float32/base/to-word/test/test.native.js  | 32 ++++++------
 .../@stdlib/number/float32/test/test.js       |  4 +-
 .../number/float64/base/assert/test/test.js   |  2 +-
 .../number/float64/base/exponent/test/test.js | 18 +++----
 .../float64/base/exponent/test/test.native.js | 16 +++---
 .../base/from-words/test/test.indices.js      | 14 ++---
 .../float64/base/from-words/test/test.js      | 12 ++---
 .../base/from-words/test/test.native.js       | 12 ++---
 .../base/get-high-word/test/test.high.js      |  6 +--
 .../float64/base/get-high-word/test/test.js   | 14 ++---
 .../base/get-high-word/test/test.native.js    | 14 ++---
 .../float64/base/get-low-word/test/test.js    | 12 ++---
 .../base/get-low-word/test/test.low.js        |  6 +--
 .../base/get-low-word/test/test.native.js     | 12 ++---
 .../number/float64/base/identity/test/test.js | 14 ++---
 .../float64/base/identity/test/test.native.js | 14 ++---
 .../base/normalize/test/test.assign.js        | 18 +++----
 .../float64/base/normalize/test/test.main.js  | 14 ++---
 .../base/normalize/test/test.native.js        | 14 ++---
 .../base/set-high-word/test/test.high.js      |  6 +--
 .../float64/base/set-high-word/test/test.js   | 10 ++--
 .../base/set-high-word/test/test.native.js    | 10 ++--
 .../float64/base/set-low-word/test/test.js    | 30 +++++------
 .../base/set-low-word/test/test.low.js        |  6 +--
 .../base/set-low-word/test/test.native.js     | 30 +++++------
 .../number/float64/base/signbit/test/test.js  |  8 +--
 .../float64/base/signbit/test/test.native.js  |  8 +--
 .../@stdlib/number/float64/base/test/test.js  |  4 +-
 .../base/to-binary-string/test/test.js        | 20 +++----
 .../float64/base/to-float32/test/test.js      | 36 ++++++-------
 .../base/to-float32/test/test.polyfill.js     | 32 ++++++------
 .../number/float64/base/to-int32/test/test.js | 20 +++----
 .../float64/base/to-words/test/test.assign.js | 44 ++++++++--------
 .../base/to-words/test/test.indices.js        | 12 ++---
 .../float64/base/to-words/test/test.main.js   | 22 ++++----
 .../float64/base/to-words/test/test.native.js | 16 +++---
 .../@stdlib/number/float64/test/test.js       |  4 +-
 .../number/int16/base/identity/test/test.js   |  4 +-
 .../int16/base/identity/test/test.native.js   |  4 +-
 .../number/int32/base/identity/test/test.js   |  4 +-
 .../int32/base/identity/test/test.native.js   |  4 +-
 .../number/int32/base/mul/test/test.js        |  4 +-
 .../int32/base/muldw/test/test.assign.js      | 10 ++--
 .../@stdlib/number/int32/base/test/test.js    |  4 +-
 .../@stdlib/number/int32/test/test.js         |  4 +-
 .../number/int8/base/identity/test/test.js    |  4 +-
 .../int8/base/identity/test/test.native.js    |  4 +-
 lib/node_modules/@stdlib/number/test/test.js  |  4 +-
 .../number/uint16/base/identity/test/test.js  |  4 +-
 .../uint16/base/identity/test/test.native.js  |  4 +-
 .../@stdlib/number/uint16/base/test/test.js   |  4 +-
 .../uint16/base/to-binary-string/test/test.js | 12 ++---
 .../@stdlib/number/uint16/test/test.js        |  4 +-
 .../number/uint32/base/identity/test/test.js  |  4 +-
 .../uint32/base/identity/test/test.native.js  |  4 +-
 .../uint32/base/muldw/test/test.assign.js     |  8 +--
 .../@stdlib/number/uint32/base/test/test.js   |  4 +-
 .../uint32/base/to-binary-string/test/test.js | 16 +++---
 .../number/uint32/base/to-int32/test/test.js  |  4 +-
 .../@stdlib/number/uint32/test/test.js        |  4 +-
 .../number/uint8/base/identity/test/test.js   |  4 +-
 .../uint8/base/identity/test/test.native.js   |  4 +-
 .../@stdlib/number/uint8/base/test/test.js    |  2 +-
 .../uint8/base/to-binary-string/test/test.js  | 10 ++--
 .../@stdlib/number/uint8/test/test.js         |  2 +-
 97 files changed, 623 insertions(+), 623 deletions(-)

diff --git a/lib/node_modules/@stdlib/complex/base/test/test.js b/lib/node_modules/@stdlib/complex/base/test/test.js
index 9931b3a8638f..da72de67868b 100644
--- a/lib/node_modules/@stdlib/complex/base/test/test.js
+++ b/lib/node_modules/@stdlib/complex/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/float32/base/assert/test/test.js b/lib/node_modules/@stdlib/complex/float32/base/assert/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/complex/float32/base/assert/test/test.js
+++ b/lib/node_modules/@stdlib/complex/float32/base/assert/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/float32/base/identity/test/test.js b/lib/node_modules/@stdlib/complex/float32/base/identity/test/test.js
index 390c8b6e8c83..b3d00751a9c2 100644
--- a/lib/node_modules/@stdlib/complex/float32/base/identity/test/test.js
+++ b/lib/node_modules/@stdlib/complex/float32/base/identity/test/test.js
@@ -44,12 +44,12 @@ tape( 'the function evaluates the identity function when provided a finite numbe
 	var v;
 
 	v = cidentityf( new Complex64( -2.0, 1.0 ) );
-	t.equal( real( v ), -2.0, 'returns expected value' );
-	t.equal( imag( v ), 1.0, 'returns expected value' );
+	t.strictEqual( real( v ), -2.0, 'returns expected value' );
+	t.strictEqual( imag( v ), 1.0, 'returns expected value' );
 
 	v = cidentityf( new Complex64( 3.0, -2.0 ) );
-	t.equal( real( v ), 3.0, 'returns expected value' );
-	t.equal( imag( v ), -2.0, 'returns expected value' );
+	t.strictEqual( real( v ), 3.0, 'returns expected value' );
+	t.strictEqual( imag( v ), -2.0, 'returns expected value' );
 
 	t.end();
 });
@@ -58,20 +58,20 @@ tape( 'the function evaluates the identity function when provided +-zero', funct
 	var v;
 
 	v = cidentityf( new Complex64( -0.0, -0.0 ) );
-	t.equal( isNegativeZerof( real( v ) ), true, 'returns expected value' );
-	t.equal( isNegativeZerof( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentityf( new Complex64( 0.0, 0.0 ) );
-	t.equal( isPositiveZerof( real( v ) ), true, 'returns expected value' );
-	t.equal( isPositiveZerof( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentityf( new Complex64( -0.0, 0.0 ) );
-	t.equal( isNegativeZerof( real( v ) ), true, 'returns expected value' );
-	t.equal( isPositiveZerof( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentityf( new Complex64( 0.0, -0.0 ) );
-	t.equal( isPositiveZerof( real( v ) ), true, 'returns expected value' );
-	t.equal( isNegativeZerof( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( imag( v ) ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,20 +80,20 @@ tape( 'the function evaluates the identity function when provided +-infinity', f
 	var v;
 
 	v = cidentityf( new Complex64( PINF, PINF ) );
-	t.equal( real( v ), PINF, 'returns expected value' );
-	t.equal( imag( v ), PINF, 'returns expected value' );
+	t.strictEqual( real( v ), PINF, 'returns expected value' );
+	t.strictEqual( imag( v ), PINF, 'returns expected value' );
 
 	v = cidentityf( new Complex64( NINF, NINF ) );
-	t.equal( real( v ), NINF, 'returns expected value' );
-	t.equal( imag( v ), NINF, 'returns expected value' );
+	t.strictEqual( real( v ), NINF, 'returns expected value' );
+	t.strictEqual( imag( v ), NINF, 'returns expected value' );
 
 	v = cidentityf( new Complex64( NINF, PINF ) );
-	t.equal( real( v ), NINF, 'returns expected value' );
-	t.equal( imag( v ), PINF, 'returns expected value' );
+	t.strictEqual( real( v ), NINF, 'returns expected value' );
+	t.strictEqual( imag( v ), PINF, 'returns expected value' );
 
 	v = cidentityf( new Complex64( PINF, NINF ) );
-	t.equal( real( v ), PINF, 'returns expected value' );
-	t.equal( imag( v ), NINF, 'returns expected value' );
+	t.strictEqual( real( v ), PINF, 'returns expected value' );
+	t.strictEqual( imag( v ), NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -102,16 +102,16 @@ tape( 'the function evaluates the identity function when provided `NaN`', functi
 	var v;
 
 	v = cidentityf( new Complex64( NaN, NaN ) );
-	t.equal( isnanf( real( v ) ), true, 'returns expected value' );
-	t.equal( isnanf( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnanf( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnanf( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentityf( new Complex64( 1.0, NaN ) );
-	t.equal( real( v ), 1.0, 'returns expected value' );
-	t.equal( isnanf( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( real( v ), 1.0, 'returns expected value' );
+	t.strictEqual( isnanf( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentityf( new Complex64( NaN, 1.0 ) );
-	t.equal( isnanf( real( v ) ), true, 'returns expected value' );
-	t.equal( imag( v ), 1.0, 'returns expected value' );
+	t.strictEqual( isnanf( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( imag( v ), 1.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/float32/base/identity/test/test.native.js b/lib/node_modules/@stdlib/complex/float32/base/identity/test/test.native.js
index 05e7f533775e..ec3227f68d7b 100644
--- a/lib/node_modules/@stdlib/complex/float32/base/identity/test/test.native.js
+++ b/lib/node_modules/@stdlib/complex/float32/base/identity/test/test.native.js
@@ -53,12 +53,12 @@ tape( 'the function evaluates the identity function when provided a finite numbe
 	var v;
 
 	v = cidentityf( new Complex64( -2.0, 1.0 ) );
-	t.equal( real( v ), -2.0, 'returns expected value' );
-	t.equal( imag( v ), 1.0, 'returns expected value' );
+	t.strictEqual( real( v ), -2.0, 'returns expected value' );
+	t.strictEqual( imag( v ), 1.0, 'returns expected value' );
 
 	v = cidentityf( new Complex64( 3.0, -2.0 ) );
-	t.equal( real( v ), 3.0, 'returns expected value' );
-	t.equal( imag( v ), -2.0, 'returns expected value' );
+	t.strictEqual( real( v ), 3.0, 'returns expected value' );
+	t.strictEqual( imag( v ), -2.0, 'returns expected value' );
 
 	t.end();
 });
@@ -67,20 +67,20 @@ tape( 'the function evaluates the identity function when provided +-zero', opts,
 	var v;
 
 	v = cidentityf( new Complex64( -0.0, -0.0 ) );
-	t.equal( isNegativeZerof( real( v ) ), true, 'returns expected value' );
-	t.equal( isNegativeZerof( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentityf( new Complex64( 0.0, 0.0 ) );
-	t.equal( isPositiveZerof( real( v ) ), true, 'returns expected value' );
-	t.equal( isPositiveZerof( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentityf( new Complex64( -0.0, 0.0 ) );
-	t.equal( isNegativeZerof( real( v ) ), true, 'returns expected value' );
-	t.equal( isPositiveZerof( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentityf( new Complex64( 0.0, -0.0 ) );
-	t.equal( isPositiveZerof( real( v ) ), true, 'returns expected value' );
-	t.equal( isNegativeZerof( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( imag( v ) ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,20 +89,20 @@ tape( 'the function evaluates the identity function when provided +-infinity', o
 	var v;
 
 	v = cidentityf( new Complex64( PINF, PINF ) );
-	t.equal( real( v ), PINF, 'returns expected value' );
-	t.equal( imag( v ), PINF, 'returns expected value' );
+	t.strictEqual( real( v ), PINF, 'returns expected value' );
+	t.strictEqual( imag( v ), PINF, 'returns expected value' );
 
 	v = cidentityf( new Complex64( NINF, NINF ) );
-	t.equal( real( v ), NINF, 'returns expected value' );
-	t.equal( imag( v ), NINF, 'returns expected value' );
+	t.strictEqual( real( v ), NINF, 'returns expected value' );
+	t.strictEqual( imag( v ), NINF, 'returns expected value' );
 
 	v = cidentityf( new Complex64( NINF, PINF ) );
-	t.equal( real( v ), NINF, 'returns expected value' );
-	t.equal( imag( v ), PINF, 'returns expected value' );
+	t.strictEqual( real( v ), NINF, 'returns expected value' );
+	t.strictEqual( imag( v ), PINF, 'returns expected value' );
 
 	v = cidentityf( new Complex64( PINF, NINF ) );
-	t.equal( real( v ), PINF, 'returns expected value' );
-	t.equal( imag( v ), NINF, 'returns expected value' );
+	t.strictEqual( real( v ), PINF, 'returns expected value' );
+	t.strictEqual( imag( v ), NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -111,16 +111,16 @@ tape( 'the function evaluates the identity function when provided `NaN`', opts,
 	var v;
 
 	v = cidentityf( new Complex64( NaN, NaN ) );
-	t.equal( isnanf( real( v ) ), true, 'returns expected value' );
-	t.equal( isnanf( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnanf( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnanf( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentityf( new Complex64( 1.0, NaN ) );
-	t.equal( real( v ), 1.0, 'returns expected value' );
-	t.equal( isnanf( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( real( v ), 1.0, 'returns expected value' );
+	t.strictEqual( isnanf( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentityf( new Complex64( NaN, 1.0 ) );
-	t.equal( isnanf( real( v ) ), true, 'returns expected value' );
-	t.equal( imag( v ), 1.0, 'returns expected value' );
+	t.strictEqual( isnanf( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( imag( v ), 1.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/float32/base/test/test.js b/lib/node_modules/@stdlib/complex/float32/base/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/complex/float32/base/test/test.js
+++ b/lib/node_modules/@stdlib/complex/float32/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/float32/test/test.js b/lib/node_modules/@stdlib/complex/float32/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/complex/float32/test/test.js
+++ b/lib/node_modules/@stdlib/complex/float32/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/float64/base/assert/test/test.js b/lib/node_modules/@stdlib/complex/float64/base/assert/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/complex/float64/base/assert/test/test.js
+++ b/lib/node_modules/@stdlib/complex/float64/base/assert/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/float64/base/identity/test/test.js b/lib/node_modules/@stdlib/complex/float64/base/identity/test/test.js
index 9ff58582e09a..a32c98cb066e 100644
--- a/lib/node_modules/@stdlib/complex/float64/base/identity/test/test.js
+++ b/lib/node_modules/@stdlib/complex/float64/base/identity/test/test.js
@@ -44,12 +44,12 @@ tape( 'the function evaluates the identity function when provided a finite numbe
 	var v;
 
 	v = cidentity( new Complex128( -2.0, 1.0 ) );
-	t.equal( real( v ), -2.0, 'returns expected value' );
-	t.equal( imag( v ), 1.0, 'returns expected value' );
+	t.strictEqual( real( v ), -2.0, 'returns expected value' );
+	t.strictEqual( imag( v ), 1.0, 'returns expected value' );
 
 	v = cidentity( new Complex128( 3.0, -2.0 ) );
-	t.equal( real( v ), 3.0, 'returns expected value' );
-	t.equal( imag( v ), -2.0, 'returns expected value' );
+	t.strictEqual( real( v ), 3.0, 'returns expected value' );
+	t.strictEqual( imag( v ), -2.0, 'returns expected value' );
 
 	t.end();
 });
@@ -58,20 +58,20 @@ tape( 'the function evaluates the identity function when provided +-zero', funct
 	var v;
 
 	v = cidentity( new Complex128( -0.0, -0.0 ) );
-	t.equal( isNegativeZero( real( v ) ), true, 'returns expected value' );
-	t.equal( isNegativeZero( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentity( new Complex128( 0.0, 0.0 ) );
-	t.equal( isPositiveZero( real( v ) ), true, 'returns expected value' );
-	t.equal( isPositiveZero( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentity( new Complex128( -0.0, 0.0 ) );
-	t.equal( isNegativeZero( real( v ) ), true, 'returns expected value' );
-	t.equal( isPositiveZero( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentity( new Complex128( 0.0, -0.0 ) );
-	t.equal( isPositiveZero( real( v ) ), true, 'returns expected value' );
-	t.equal( isNegativeZero( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( imag( v ) ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,20 +80,20 @@ tape( 'the function evaluates the identity function when provided +-infinity', f
 	var v;
 
 	v = cidentity( new Complex128( PINF, PINF ) );
-	t.equal( real( v ), PINF, 'returns expected value' );
-	t.equal( imag( v ), PINF, 'returns expected value' );
+	t.strictEqual( real( v ), PINF, 'returns expected value' );
+	t.strictEqual( imag( v ), PINF, 'returns expected value' );
 
 	v = cidentity( new Complex128( NINF, NINF ) );
-	t.equal( real( v ), NINF, 'returns expected value' );
-	t.equal( imag( v ), NINF, 'returns expected value' );
+	t.strictEqual( real( v ), NINF, 'returns expected value' );
+	t.strictEqual( imag( v ), NINF, 'returns expected value' );
 
 	v = cidentity( new Complex128( NINF, PINF ) );
-	t.equal( real( v ), NINF, 'returns expected value' );
-	t.equal( imag( v ), PINF, 'returns expected value' );
+	t.strictEqual( real( v ), NINF, 'returns expected value' );
+	t.strictEqual( imag( v ), PINF, 'returns expected value' );
 
 	v = cidentity( new Complex128( PINF, NINF ) );
-	t.equal( real( v ), PINF, 'returns expected value' );
-	t.equal( imag( v ), NINF, 'returns expected value' );
+	t.strictEqual( real( v ), PINF, 'returns expected value' );
+	t.strictEqual( imag( v ), NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -102,16 +102,16 @@ tape( 'the function evaluates the identity function when provided `NaN`', functi
 	var v;
 
 	v = cidentity( new Complex128( NaN, NaN ) );
-	t.equal( isnan( real( v ) ), true, 'returns expected value' );
-	t.equal( isnan( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentity( new Complex128( 1.0, NaN ) );
-	t.equal( real( v ), 1.0, 'returns expected value' );
-	t.equal( isnan( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( real( v ), 1.0, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentity( new Complex128( NaN, 1.0 ) );
-	t.equal( isnan( real( v ) ), true, 'returns expected value' );
-	t.equal( imag( v ), 1.0, 'returns expected value' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( imag( v ), 1.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/float64/base/identity/test/test.native.js b/lib/node_modules/@stdlib/complex/float64/base/identity/test/test.native.js
index bf5b4f16c442..d65ee55c3ab5 100644
--- a/lib/node_modules/@stdlib/complex/float64/base/identity/test/test.native.js
+++ b/lib/node_modules/@stdlib/complex/float64/base/identity/test/test.native.js
@@ -53,12 +53,12 @@ tape( 'the function evaluates the identity function when provided a finite numbe
 	var v;
 
 	v = cidentity( new Complex128( -2.0, 1.0 ) );
-	t.equal( real( v ), -2.0, 'returns expected value' );
-	t.equal( imag( v ), 1.0, 'returns expected value' );
+	t.strictEqual( real( v ), -2.0, 'returns expected value' );
+	t.strictEqual( imag( v ), 1.0, 'returns expected value' );
 
 	v = cidentity( new Complex128( 3.0, -2.0 ) );
-	t.equal( real( v ), 3.0, 'returns expected value' );
-	t.equal( imag( v ), -2.0, 'returns expected value' );
+	t.strictEqual( real( v ), 3.0, 'returns expected value' );
+	t.strictEqual( imag( v ), -2.0, 'returns expected value' );
 
 	t.end();
 });
@@ -67,20 +67,20 @@ tape( 'the function evaluates the identity function when provided +-zero', opts,
 	var v;
 
 	v = cidentity( new Complex128( -0.0, -0.0 ) );
-	t.equal( isNegativeZero( real( v ) ), true, 'returns expected value' );
-	t.equal( isNegativeZero( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentity( new Complex128( 0.0, 0.0 ) );
-	t.equal( isPositiveZero( real( v ) ), true, 'returns expected value' );
-	t.equal( isPositiveZero( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentity( new Complex128( -0.0, 0.0 ) );
-	t.equal( isNegativeZero( real( v ) ), true, 'returns expected value' );
-	t.equal( isPositiveZero( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentity( new Complex128( 0.0, -0.0 ) );
-	t.equal( isPositiveZero( real( v ) ), true, 'returns expected value' );
-	t.equal( isNegativeZero( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( imag( v ) ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,20 +89,20 @@ tape( 'the function evaluates the identity function when provided +-infinity', o
 	var v;
 
 	v = cidentity( new Complex128( PINF, PINF ) );
-	t.equal( real( v ), PINF, 'returns expected value' );
-	t.equal( imag( v ), PINF, 'returns expected value' );
+	t.strictEqual( real( v ), PINF, 'returns expected value' );
+	t.strictEqual( imag( v ), PINF, 'returns expected value' );
 
 	v = cidentity( new Complex128( NINF, NINF ) );
-	t.equal( real( v ), NINF, 'returns expected value' );
-	t.equal( imag( v ), NINF, 'returns expected value' );
+	t.strictEqual( real( v ), NINF, 'returns expected value' );
+	t.strictEqual( imag( v ), NINF, 'returns expected value' );
 
 	v = cidentity( new Complex128( NINF, PINF ) );
-	t.equal( real( v ), NINF, 'returns expected value' );
-	t.equal( imag( v ), PINF, 'returns expected value' );
+	t.strictEqual( real( v ), NINF, 'returns expected value' );
+	t.strictEqual( imag( v ), PINF, 'returns expected value' );
 
 	v = cidentity( new Complex128( PINF, NINF ) );
-	t.equal( real( v ), PINF, 'returns expected value' );
-	t.equal( imag( v ), NINF, 'returns expected value' );
+	t.strictEqual( real( v ), PINF, 'returns expected value' );
+	t.strictEqual( imag( v ), NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -111,16 +111,16 @@ tape( 'the function evaluates the identity function when provided `NaN`', opts,
 	var v;
 
 	v = cidentity( new Complex128( NaN, NaN ) );
-	t.equal( isnan( real( v ) ), true, 'returns expected value' );
-	t.equal( isnan( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentity( new Complex128( 1.0, NaN ) );
-	t.equal( real( v ), 1.0, 'returns expected value' );
-	t.equal( isnan( imag( v ) ), true, 'returns expected value' );
+	t.strictEqual( real( v ), 1.0, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	v = cidentity( new Complex128( NaN, 1.0 ) );
-	t.equal( isnan( real( v ) ), true, 'returns expected value' );
-	t.equal( imag( v ), 1.0, 'returns expected value' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( imag( v ), 1.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/float64/base/test/test.js b/lib/node_modules/@stdlib/complex/float64/base/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/complex/float64/base/test/test.js
+++ b/lib/node_modules/@stdlib/complex/float64/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/float64/test/test.js b/lib/node_modules/@stdlib/complex/float64/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/complex/float64/test/test.js
+++ b/lib/node_modules/@stdlib/complex/float64/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/test/test.js b/lib/node_modules/@stdlib/complex/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/complex/test/test.js
+++ b/lib/node_modules/@stdlib/complex/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/console/log-each-map/test/test.js b/lib/node_modules/@stdlib/console/log-each-map/test/test.js
index acf98cc70234..f61d6d5543fa 100644
--- a/lib/node_modules/@stdlib/console/log-each-map/test/test.js
+++ b/lib/node_modules/@stdlib/console/log-each-map/test/test.js
@@ -251,7 +251,7 @@ tape( 'the function prints a formatted message', function test( t ) {
 	}
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
@@ -280,7 +280,7 @@ tape( 'the function prints a formatted message when provided only a non-array el
 	}
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
@@ -309,7 +309,7 @@ tape( 'the function prints a formatted message when provided only two non-array
 	}
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
diff --git a/lib/node_modules/@stdlib/console/log-each/test/test.js b/lib/node_modules/@stdlib/console/log-each/test/test.js
index 9e1ef53faf32..671a26331409 100644
--- a/lib/node_modules/@stdlib/console/log-each/test/test.js
+++ b/lib/node_modules/@stdlib/console/log-each/test/test.js
@@ -133,7 +133,7 @@ tape( 'the function prints a formatted message', function test( t ) {
 	t.end();
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
@@ -167,7 +167,7 @@ tape( 'the function prints a formatted message for each element in an array', fu
 	t.end();
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
@@ -230,7 +230,7 @@ tape( 'the function prints a formatted message for each pair of array elements (
 	t.end();
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
@@ -266,7 +266,7 @@ tape( 'the function repeatedly prints a formatted message (three arrays)', funct
 	t.end();
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
@@ -304,7 +304,7 @@ tape( 'the function repeatedly prints a formatted message (four arrays)', functi
 	t.end();
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
@@ -338,7 +338,7 @@ tape( 'the function broadcasts non-array arguments (one array, one scalar)', fun
 	t.end();
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
@@ -372,7 +372,7 @@ tape( 'the function broadcasts non-array arguments (one scalar, one array)', fun
 	t.end();
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
@@ -408,7 +408,7 @@ tape( 'the function broadcasts non-array elements (two arrays, one scalar)', fun
 	t.end();
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
@@ -444,7 +444,7 @@ tape( 'the function broadcasts non-array arguments (one scalar, two arrays)', fu
 	t.end();
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
@@ -480,7 +480,7 @@ tape( 'the function prints a formatted message when provided only a scalar argum
 	t.end();
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
@@ -516,7 +516,7 @@ tape( 'the function prints a formatted message when only provided two scalar arg
 	t.end();
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
@@ -548,7 +548,7 @@ tape( 'the function handles escaped percent signs (%%)', function test( t ) {
 	t.end();
 
 	function logger( str ) {
-		t.equal( str, expected[ j ], 'returns expected value' );
+		t.strictEqual( str, expected[ j ], 'returns expected value' );
 		j += 1;
 	}
 });
diff --git a/lib/node_modules/@stdlib/console/test/test.js b/lib/node_modules/@stdlib/console/test/test.js
index 9931b3a8638f..da72de67868b 100644
--- a/lib/node_modules/@stdlib/console/test/test.js
+++ b/lib/node_modules/@stdlib/console/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/assert/test/test.js b/lib/node_modules/@stdlib/number/float32/base/assert/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/number/float32/base/assert/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/assert/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.js b/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.js
index 6f11271654cc..b6371051cebb 100644
--- a/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.js
@@ -36,12 +36,12 @@ var exponentf = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof exponentf, 'function', 'main export is a function' );
+	t.strictEqual( typeof exponentf, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a number', function test( t ) {
-	t.equal( typeof exponentf( toFloat32( 3.14e30 ) ), 'number', 'returns a number' );
+	t.strictEqual( typeof exponentf( toFloat32( 3.14e30 ) ), 'number', 'returns a number' );
 	t.end();
 });
 
@@ -70,33 +70,33 @@ tape( 'the function returns an integer corresponding to the unbiased exponent of
 		expected = parseInt( b.substring( 1, 9 ), 2 ) - BIAS;
 
 		actual = exponentf( x );
-		t.equal( actual, expected, 'returns the unbiased exponent for ' + x );
+		t.strictEqual( actual, expected, 'returns the unbiased exponent for ' + x );
 	}
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `+-0`', function test( t ) {
-	t.equal( exponentf( 0.0 ), -BIAS, 'returns -127' );
-	t.equal( exponentf( -0.0 ), -BIAS, 'returns -127' );
+	t.strictEqual( exponentf( 0.0 ), -BIAS, 'returns -127' );
+	t.strictEqual( exponentf( -0.0 ), -BIAS, 'returns -127' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `+infinity`', function test( t ) {
-	t.equal( exponentf( PINF ), BIAS+1, 'returns 128' );
+	t.strictEqual( exponentf( PINF ), BIAS+1, 'returns 128' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `-infinity`', function test( t ) {
-	t.equal( exponentf( NINF ), BIAS+1, 'returns 128' );
+	t.strictEqual( exponentf( NINF ), BIAS+1, 'returns 128' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `NaN`', function test( t ) {
-	t.equal( exponentf( NaN ), BIAS+1, 'returns 128' );
+	t.strictEqual( exponentf( NaN ), BIAS+1, 'returns 128' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for subnormals', function test( t ) {
-	t.equal( exponentf( toFloat32( 3.14e-42 ) ), -BIAS, 'returns -127' );
+	t.strictEqual( exponentf( toFloat32( 3.14e-42 ) ), -BIAS, 'returns -127' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.native.js b/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.native.js
index d9304f21eb20..0dff500b92a8 100644
--- a/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.native.js
@@ -45,12 +45,12 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof exponentf, 'function', 'main export is a function' );
+	t.strictEqual( typeof exponentf, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a number', opts, function test( t ) {
-	t.equal( typeof exponentf( toFloat32( 3.14e30 ) ), 'number', 'returns a number' );
+	t.strictEqual( typeof exponentf( toFloat32( 3.14e30 ) ), 'number', 'returns a number' );
 	t.end();
 });
 
@@ -79,33 +79,33 @@ tape( 'the function returns an integer corresponding to the unbiased exponent of
 		expected = parseInt( b.substring( 1, 9 ), 2 ) - BIAS;
 
 		actual = exponentf( x );
-		t.equal( actual, expected, 'returns the unbiased exponent for ' + x );
+		t.strictEqual( actual, expected, 'returns the unbiased exponent for ' + x );
 	}
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `+-0`', opts, function test( t ) {
-	t.equal( exponentf( 0.0 ), -BIAS, 'returns -127' );
-	t.equal( exponentf( -0.0 ), -BIAS, 'returns -127' );
+	t.strictEqual( exponentf( 0.0 ), -BIAS, 'returns -127' );
+	t.strictEqual( exponentf( -0.0 ), -BIAS, 'returns -127' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `+infinity`', opts, function test( t ) {
-	t.equal( exponentf( PINF ), BIAS+1, 'returns 128' );
+	t.strictEqual( exponentf( PINF ), BIAS+1, 'returns 128' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `-infinity`', opts, function test( t ) {
-	t.equal( exponentf( NINF ), BIAS+1, 'returns 128' );
+	t.strictEqual( exponentf( NINF ), BIAS+1, 'returns 128' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `NaN`', opts, function test( t ) {
-	t.equal( exponentf( NaN ), BIAS+1, 'returns 128' );
+	t.strictEqual( exponentf( NaN ), BIAS+1, 'returns 128' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for subnormals', opts, function test( t ) {
-	t.equal( exponentf( toFloat32( 3.14e-42 ) ), -BIAS, 'returns -127' );
+	t.strictEqual( exponentf( toFloat32( 3.14e-42 ) ), -BIAS, 'returns -127' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.js b/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.js
index 5f8749543dc7..3a77c59c5c63 100644
--- a/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.js
@@ -49,12 +49,12 @@ var positiveTiny = require( './fixtures/julia/positive_tiny.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof fromWordf, 'function', 'main export is a function' );
+	t.strictEqual( typeof fromWordf, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'if provided `0`, the function returns `0`', function test( t ) {
-	t.equal( isPositiveZero( fromWordf( 0 ) ), true, 'equals 0' );
+	t.strictEqual( isPositiveZero( fromWordf( 0 ) ), true, 'equals 0' );
 	t.end();
 });
 
@@ -75,7 +75,7 @@ tape( 'if provided a word corresponding to `-0`, the function returns `-0`', fun
 
 	x = fromWordf( word );
 
-	t.equal( isNegativeZero( x ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( x ), true, 'returns -0' );
 	t.end();
 });
 
@@ -96,7 +96,7 @@ tape( 'if provided a word corresponding to `+infinity`, the function returns `+i
 
 	x = fromWordf( word );
 
-	t.equal( x, PINF, 'equals +infinity' );
+	t.strictEqual( x, PINF, 'equals +infinity' );
 	t.end();
 });
 
@@ -117,7 +117,7 @@ tape( 'if provided a word corresponding to `-infinity`, the function returns `-i
 
 	x = fromWordf( word );
 
-	t.equal( x, NINF, 'equals -infinity' );
+	t.strictEqual( x, NINF, 'equals -infinity' );
 	t.end();
 });
 
@@ -138,7 +138,7 @@ tape( 'if provided a word corresponding to `NaN`, the function returns `NaN`', f
 
 	x = fromWordf( word );
 
-	t.equal( isnan( x ), true, 'equals NaN' );
+	t.strictEqual( isnan( x ), true, 'equals NaN' );
 	t.end();
 });
 
@@ -152,7 +152,7 @@ tape( 'if provided words corresponding to large positive values, the function re
 	expected = positiveLarge.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -167,7 +167,7 @@ tape( 'if provided words corresponding to normal positive values, the function r
 	expected = positiveNormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -182,7 +182,7 @@ tape( 'if provided words corresponding to small positive values, the function re
 	expected = positiveSmall.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -197,7 +197,7 @@ tape( 'if provided words corresponding to tiny positive values, the function ret
 	expected = positiveTiny.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -212,7 +212,7 @@ tape( 'if provided words corresponding to subnormal positive values, the functio
 	expected = positiveSubnormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -227,7 +227,7 @@ tape( 'if provided words corresponding to large negative values, the function re
 	expected = negativeLarge.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -242,7 +242,7 @@ tape( 'if provided words corresponding to normal negative values, the function r
 	expected = negativeNormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -257,7 +257,7 @@ tape( 'if provided words corresponding to small negative values, the function re
 	expected = negativeSmall.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -272,7 +272,7 @@ tape( 'if provided words corresponding to tiny negative values, the function ret
 	expected = negativeTiny.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -287,7 +287,7 @@ tape( 'if provided words corresponding to subnormal negative values, the functio
 	expected = negativeSubnormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.native.js b/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.native.js
index e2291db87f37..359dfe1d3ca8 100644
--- a/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.native.js
@@ -58,12 +58,12 @@ var positiveTiny = require( './fixtures/julia/positive_tiny.json' );
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof fromWordf, 'function', 'main export is a function' );
+	t.strictEqual( typeof fromWordf, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'if provided `0`, the function returns `0`', opts, function test( t ) {
-	t.equal( isPositiveZero( fromWordf( 0 ) ), true, 'equals 0' );
+	t.strictEqual( isPositiveZero( fromWordf( 0 ) ), true, 'equals 0' );
 	t.end();
 });
 
@@ -84,7 +84,7 @@ tape( 'if provided a word corresponding to `-0`, the function returns `-0`', opt
 
 	x = fromWordf( word );
 
-	t.equal( isNegativeZero( x ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( x ), true, 'returns -0' );
 	t.end();
 });
 
@@ -105,7 +105,7 @@ tape( 'if provided a word corresponding to `+infinity`, the function returns `+i
 
 	x = fromWordf( word );
 
-	t.equal( x, PINF, 'equals +infinity' );
+	t.strictEqual( x, PINF, 'equals +infinity' );
 	t.end();
 });
 
@@ -126,7 +126,7 @@ tape( 'if provided a word corresponding to `-infinity`, the function returns `-i
 
 	x = fromWordf( word );
 
-	t.equal( x, NINF, 'equals -infinity' );
+	t.strictEqual( x, NINF, 'equals -infinity' );
 	t.end();
 });
 
@@ -147,7 +147,7 @@ tape( 'if provided a word corresponding to `NaN`, the function returns `NaN`', o
 
 	x = fromWordf( word );
 
-	t.equal( isnan( x ), true, 'equals NaN' );
+	t.strictEqual( isnan( x ), true, 'equals NaN' );
 	t.end();
 });
 
@@ -161,7 +161,7 @@ tape( 'if provided words corresponding to large positive values, the function re
 	expected = positiveLarge.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -176,7 +176,7 @@ tape( 'if provided words corresponding to normal positive values, the function r
 	expected = positiveNormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -191,7 +191,7 @@ tape( 'if provided words corresponding to small positive values, the function re
 	expected = positiveSmall.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -206,7 +206,7 @@ tape( 'if provided words corresponding to tiny positive values, the function ret
 	expected = positiveTiny.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -221,7 +221,7 @@ tape( 'if provided words corresponding to subnormal positive values, the functio
 	expected = positiveSubnormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -236,7 +236,7 @@ tape( 'if provided words corresponding to large negative values, the function re
 	expected = negativeLarge.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -251,7 +251,7 @@ tape( 'if provided words corresponding to normal negative values, the function r
 	expected = negativeNormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -266,7 +266,7 @@ tape( 'if provided words corresponding to small negative values, the function re
 	expected = negativeSmall.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -281,7 +281,7 @@ tape( 'if provided words corresponding to tiny negative values, the function ret
 	expected = negativeTiny.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
@@ -296,7 +296,7 @@ tape( 'if provided words corresponding to subnormal negative values, the functio
 	expected = negativeSubnormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = fromWordf( x[ i ] );
-		t.equal( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
+		t.strictEqual( y, expected[i], 'x: '+x[i]+', expected: '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/identity/test/test.js b/lib/node_modules/@stdlib/number/float32/base/identity/test/test.js
index 41d31a65a25c..23084c8ccded 100644
--- a/lib/node_modules/@stdlib/number/float32/base/identity/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/identity/test/test.js
@@ -38,25 +38,25 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a finite number', function test( t ) {
-	t.equal( identityf( -2.0 ), -2.0, 'returns expected value' );
-	t.equal( identityf( 3.0 ), 3.0, 'returns expected value' );
+	t.strictEqual( identityf( -2.0 ), -2.0, 'returns expected value' );
+	t.strictEqual( identityf( 3.0 ), 3.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function evaluates the identity function when provided +-zero', function test( t ) {
-	t.equal( isNegativeZerof( identityf( -0.0 ) ), true, 'returns expected value' );
-	t.equal( isPositiveZerof( identityf( 0.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( identityf( -0.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( identityf( 0.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function evaluates the identity function when provided +-infinity', function test( t ) {
-	t.equal( identityf( PINF ), PINF, 'returns expected value' );
-	t.equal( identityf( NINF ), NINF, 'returns expected value' );
+	t.strictEqual( identityf( PINF ), PINF, 'returns expected value' );
+	t.strictEqual( identityf( NINF ), NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = identityf( NaN );
-	t.equal( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns NaN' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/identity/test/test.native.js b/lib/node_modules/@stdlib/number/float32/base/identity/test/test.native.js
index b75497a61098..1df0d1b14530 100644
--- a/lib/node_modules/@stdlib/number/float32/base/identity/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float32/base/identity/test/test.native.js
@@ -47,25 +47,25 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a finite number', opts, function test( t ) {
-	t.equal( identityf( -2.0 ), -2.0, 'returns expected value' );
-	t.equal( identityf( 3.0 ), 3.0, 'returns expected value' );
+	t.strictEqual( identityf( -2.0 ), -2.0, 'returns expected value' );
+	t.strictEqual( identityf( 3.0 ), 3.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function evaluates the identity function when provided +-zero', opts, function test( t ) {
-	t.equal( isNegativeZerof( identityf( -0.0 ) ), true, 'returns expected value' );
-	t.equal( isPositiveZerof( identityf( 0.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZerof( identityf( -0.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZerof( identityf( 0.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function evaluates the identity function when provided +-infinity', opts, function test( t ) {
-	t.equal( identityf( PINF ), PINF, 'returns expected value' );
-	t.equal( identityf( NINF ), NINF, 'returns expected value' );
+	t.strictEqual( identityf( PINF ), PINF, 'returns expected value' );
+	t.strictEqual( identityf( NINF ), NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var v = identityf( NaN );
-	t.equal( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns NaN' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/normalize/test/test.assign.js b/lib/node_modules/@stdlib/number/float32/base/normalize/test/test.assign.js
index 1c748c614676..b0c5a02d85a7 100644
--- a/lib/node_modules/@stdlib/number/float32/base/normalize/test/test.assign.js
+++ b/lib/node_modules/@stdlib/number/float32/base/normalize/test/test.assign.js
@@ -38,7 +38,7 @@ var normalizef = require( './../lib/assign.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof normalizef, 'function', 'main export is a function' );
+	t.strictEqual( typeof normalizef, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -54,9 +54,9 @@ tape( 'the function normalizes a denormalized number, returning a normal number
 	// Smallest denormalized number:
 	out = [ 0.0, 0.0 ];
 	v = normalizef( FLOAT32_SMALLEST_SUBNORMAL, out, 1, 0 );
-	t.equal( v, out, 'returns output array' );
+	t.strictEqual( v, out, 'returns output array' );
 	t.ok( v[ 0 ] >= FLOAT32_SMALLEST_NORMAL, 'returns a normal number' );
-	t.equal( v[ 0 ]*pow( 2.0, v[ 1 ] ), FLOAT32_SMALLEST_SUBNORMAL, 'x = y * 2^exp' );
+	t.strictEqual( v[ 0 ]*pow( 2.0, v[ 1 ] ), FLOAT32_SMALLEST_SUBNORMAL, 'x = y * 2^exp' );
 
 	// Other subnormals...
 	for ( i = 0; i < 1000; i++ ) {
@@ -67,12 +67,12 @@ tape( 'the function normalizes a denormalized number, returning a normal number
 
 		out = [ 0.0, 0.0 ];
 		v = normalizef( x, out, 1, 0 );
-		t.equal( v, out, 'returns output array' );
+		t.strictEqual( v, out, 'returns output array' );
 		t.ok( v[ 0 ] >= FLOAT32_SMALLEST_NORMAL, 'returns a normal number ' + v[0] );
 
 		x1 = v[ 0 ] * pow( 2.0, v[ 1 ] );
 		x1 = toFloat32( x1 );
-		t.equal( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
+		t.strictEqual( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
 	}
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns `[0,0]` if provided a `0`', function test( t ) {
 
 	out = [ 0, 0 ];
 	val = normalizef( 0.0, out, 1, 0 );
-	t.equal( val, out, 'returns output array' );
+	t.strictEqual( val, out, 'returns output array' );
 	t.deepEqual( val, [0.0, 0], 'returns [0,0]' );
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'the function returns `[+inf,0]` if provided a `+infinity`', function test
 
 	out = [ 0.0, 0.0 ];
 	val = normalizef( PINF, out, 1, 0 );
-	t.equal( val, out, 'returns output array' );
+	t.strictEqual( val, out, 'returns output array' );
 	t.deepEqual( val, [PINF, 0], 'returns [+inf,0]' );
 	t.end();
 });
@@ -105,7 +105,7 @@ tape( 'the function returns `[-inf,0]` if provided a `-infinity`', function test
 
 	out = [ 0.0, 0.0 ];
 	val = normalizef( NINF, out, 1, 0 );
-	t.equal( val, out, 'returns output array' );
+	t.strictEqual( val, out, 'returns output array' );
 	t.deepEqual( val, [NINF, 0], 'returns [-inf,0]' );
 	t.end();
 });
@@ -116,9 +116,9 @@ tape( 'the function returns `[NaN,0]` if provided a `NaN`', function test( t ) {
 
 	out = [ 0.0, 0.0 ];
 	val = normalizef( NaN, out, 1, 0 );
-	t.equal( val, out, 'returns output array' );
-	t.equal( isnan( val[0] ), true, 'first element is NaN' );
-	t.equal( val[1], 0, 'second element is 0' );
+	t.strictEqual( val, out, 'returns output array' );
+	t.strictEqual( isnan( val[0] ), true, 'first element is NaN' );
+	t.strictEqual( val[1], 0, 'second element is 0' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/normalize/test/test.main.js b/lib/node_modules/@stdlib/number/float32/base/normalize/test/test.main.js
index aa47a0bca781..956a0c25618c 100644
--- a/lib/node_modules/@stdlib/number/float32/base/normalize/test/test.main.js
+++ b/lib/node_modules/@stdlib/number/float32/base/normalize/test/test.main.js
@@ -37,7 +37,7 @@ var normalizef = require( './../lib/main.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof normalizef, 'function', 'main export is a function' );
+	t.strictEqual( typeof normalizef, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'the function normalizes a denormalized number, returning a normal number
 	// Smallest denormalized number:
 	v = normalizef( FLOAT32_SMALLEST_SUBNORMAL );
 	t.ok( v[ 0 ] >= FLOAT32_SMALLEST_NORMAL, 'returns a normal number' );
-	t.equal( v[ 0 ]*pow( 2.0, v[ 1 ] ), FLOAT32_SMALLEST_SUBNORMAL, 'x = y * 2^exp' );
+	t.strictEqual( v[ 0 ]*pow( 2.0, v[ 1 ] ), FLOAT32_SMALLEST_SUBNORMAL, 'x = y * 2^exp' );
 
 	// Other subnormals...
 	for ( i = 0; i < 1000; i++ ) {
@@ -66,7 +66,7 @@ tape( 'the function normalizes a denormalized number, returning a normal number
 
 		x1 = v[ 0 ] * pow( 2.0, v[ 1 ] );
 		x1 = toFloat32( x1 );
-		t.equal( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
+		t.strictEqual( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
 	}
 	t.end();
 });
@@ -91,7 +91,7 @@ tape( 'the function returns `[-inf,0]` if provided a `-infinity`', function test
 
 tape( 'the function returns `[NaN,0]` if provided a `NaN`', function test( t ) {
 	var val = normalizef( NaN );
-	t.equal( isnan( val[0] ), true, 'first element is NaN' );
-	t.equal( val[1], 0, 'second element is 0' );
+	t.strictEqual( isnan( val[0] ), true, 'first element is NaN' );
+	t.strictEqual( val[1], 0, 'second element is 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/normalize/test/test.native.js b/lib/node_modules/@stdlib/number/float32/base/normalize/test/test.native.js
index a2712a581599..4289126c554d 100644
--- a/lib/node_modules/@stdlib/number/float32/base/normalize/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float32/base/normalize/test/test.native.js
@@ -46,7 +46,7 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof normalize, 'function', 'main export is a function' );
+	t.strictEqual( typeof normalize, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function normalizes a denormalized number, returning a normal number
 	// Smallest denormalized number:
 	v = normalize( FLOAT32_SMALLEST_SUBNORMAL );
 	t.ok( v[ 0 ] >= FLOAT32_SMALLEST_NORMAL, 'returns a normal number' );
-	t.equal( v[ 0 ]*pow( 2.0, v[ 1 ] ), FLOAT32_SMALLEST_SUBNORMAL, 'x = y * 2^exp' );
+	t.strictEqual( v[ 0 ]*pow( 2.0, v[ 1 ] ), FLOAT32_SMALLEST_SUBNORMAL, 'x = y * 2^exp' );
 
 	// Other subnormals...
 	for ( i = 0; i < 1000; i++ ) {
@@ -75,7 +75,7 @@ tape( 'the function normalizes a denormalized number, returning a normal number
 
 		x1 = v[ 0 ] * pow( 2.0, v[ 1 ] );
 		x1 = toFloat32( x1 );
-		t.equal( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
+		t.strictEqual( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns `[-inf,0]` if provided a `-infinity`', opts, functio
 
 tape( 'the function returns `[NaN,0]` if provided a `NaN`', opts, function test( t ) {
 	var val = normalize( NaN );
-	t.equal( isnan( val[0] ), true, 'first element is NaN' );
-	t.equal( val[1], 0, 'second element is 0' );
+	t.strictEqual( isnan( val[0] ), true, 'first element is NaN' );
+	t.strictEqual( val[1], 0, 'second element is 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.js b/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.js
index 16abd68c1fdb..1bee060a4dca 100644
--- a/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.js
@@ -32,12 +32,12 @@ var signbitf = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof signbitf, 'function', 'main export is a function' );
+	t.strictEqual( typeof signbitf, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a boolean', function test( t ) {
-	t.equal( typeof signbitf(5.0), 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof signbitf(5.0), 'boolean', 'returns a boolean' );
 	t.end();
 });
 
@@ -61,9 +61,9 @@ tape( 'the function returns a boolean indicating if a sign bit is on (true) or o
 		x = toFloat32( x );
 		bool = signbitf( x );
 		if ( sign < 0.0 ) {
-			t.equal( bool, true, 'returns true for ' + x );
+			t.strictEqual( bool, true, 'returns true for ' + x );
 		} else {
-			t.equal( bool, false, 'returns false for ' + x );
+			t.strictEqual( bool, false, 'returns false for ' + x );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.native.js b/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.native.js
index 7f0fe3434f78..6619a9c850e4 100644
--- a/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.native.js
@@ -41,12 +41,12 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof signbitf, 'function', 'main export is a function' );
+	t.strictEqual( typeof signbitf, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a boolean', opts, function test( t ) {
-	t.equal( typeof signbitf(5.0), 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof signbitf(5.0), 'boolean', 'returns a boolean' );
 	t.end();
 });
 
@@ -70,9 +70,9 @@ tape( 'the function returns a boolean indicating if a sign bit is on (true) or o
 		x = toFloat32( x );
 		bool = signbitf( x );
 		if ( sign < 0.0 ) {
-			t.equal( bool, true, 'returns true for ' + x );
+			t.strictEqual( bool, true, 'returns true for ' + x );
 		} else {
-			t.equal( bool, false, 'returns false for ' + x );
+			t.strictEqual( bool, false, 'returns false for ' + x );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/float32/base/significand/test/test.js b/lib/node_modules/@stdlib/number/float32/base/significand/test/test.js
index 846668dd9b14..133c7caa9941 100644
--- a/lib/node_modules/@stdlib/number/float32/base/significand/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/significand/test/test.js
@@ -35,12 +35,12 @@ var significandf = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof significandf, 'function', 'main export is a function' );
+	t.strictEqual( typeof significandf, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a number', function test( t ) {
-	t.equal( typeof significandf( toFloat32( 3.14e30 ) ), 'number', 'returns a number' );
+	t.strictEqual( typeof significandf( toFloat32( 3.14e30 ) ), 'number', 'returns a number' );
 	t.end();
 });
 
@@ -69,35 +69,35 @@ tape( 'the function returns an integer corresponding to the significand of a sin
 		expected = parseInt( b.substring( 9 ), 2 );
 
 		actual = significandf( x );
-		t.equal( actual, expected, 'returns the significand for ' + x );
+		t.strictEqual( actual, expected, 'returns the significand for ' + x );
 	}
 	t.end();
 });
 
 tape( 'the function returns the significand for `+-0`', function test( t ) {
-	t.equal( significandf( 0.0 ), 0, 'returns 0' );
-	t.equal( significandf( -0.0 ), 0, 'returns 0' );
+	t.strictEqual( significandf( 0.0 ), 0, 'returns 0' );
+	t.strictEqual( significandf( -0.0 ), 0, 'returns 0' );
 	t.end();
 });
 
 tape( 'the function returns the significand for `+infinity`', function test( t ) {
-	t.equal( significandf( PINF ), 0, 'returns 0' );
+	t.strictEqual( significandf( PINF ), 0, 'returns 0' );
 	t.end();
 });
 
 tape( 'the function returns the significand for `-infinity`', function test( t ) {
-	t.equal( significandf( NINF ), 0, 'returns 0' );
+	t.strictEqual( significandf( NINF ), 0, 'returns 0' );
 	t.end();
 });
 
 tape( 'the function returns the significand for `NaN`', function test( t ) {
-	t.equal( significandf( NaN ), 4194304, 'returns int corresponding to bit sequence 10000000000000000000000' );
+	t.strictEqual( significandf( NaN ), 4194304, 'returns int corresponding to bit sequence 10000000000000000000000' );
 	t.end();
 });
 
 tape( 'the function returns the significand for subnormals', function test( t ) {
 	var x = toFloat32( 3.14e-42 );
 	var s = parseInt( bits( x ).substring( 9 ), 2 );
-	t.equal( significandf( x ), s, 'returns the significand for ' + x );
+	t.strictEqual( significandf( x ), s, 'returns the significand for ' + x );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/significand/test/test.native.js b/lib/node_modules/@stdlib/number/float32/base/significand/test/test.native.js
index 0a58adbc502b..7cea1c444bd8 100644
--- a/lib/node_modules/@stdlib/number/float32/base/significand/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float32/base/significand/test/test.native.js
@@ -44,12 +44,12 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof significand, 'function', 'main export is a function' );
+	t.strictEqual( typeof significand, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a number', opts, function test( t ) {
-	t.equal( typeof significand( toFloat32( 3.14e30 ) ), 'number', 'returns a number' );
+	t.strictEqual( typeof significand( toFloat32( 3.14e30 ) ), 'number', 'returns a number' );
 	t.end();
 });
 
@@ -78,35 +78,35 @@ tape( 'the function returns an integer corresponding to the significand of a sin
 		expected = parseInt( b.substring( 9 ), 2 );
 
 		actual = significand( x );
-		t.equal( actual, expected, 'returns the significand for ' + x );
+		t.strictEqual( actual, expected, 'returns the significand for ' + x );
 	}
 	t.end();
 });
 
 tape( 'the function returns the significand for `+-0`', opts, function test( t ) {
-	t.equal( significand( 0.0 ), 0, 'returns 0' );
-	t.equal( significand( -0.0 ), 0, 'returns 0' );
+	t.strictEqual( significand( 0.0 ), 0, 'returns 0' );
+	t.strictEqual( significand( -0.0 ), 0, 'returns 0' );
 	t.end();
 });
 
 tape( 'the function returns the significand for `+infinity`', opts, function test( t ) {
-	t.equal( significand( PINF ), 0, 'returns 0' );
+	t.strictEqual( significand( PINF ), 0, 'returns 0' );
 	t.end();
 });
 
 tape( 'the function returns the significand for `-infinity`', opts, function test( t ) {
-	t.equal( significand( NINF ), 0, 'returns 0' );
+	t.strictEqual( significand( NINF ), 0, 'returns 0' );
 	t.end();
 });
 
 tape( 'the function returns the significand for `NaN`', opts, function test( t ) {
-	t.equal( significand( NaN ), 4194304, 'returns int corresponding to bit sequence 10000000000000000000000' );
+	t.strictEqual( significand( NaN ), 4194304, 'returns int corresponding to bit sequence 10000000000000000000000' );
 	t.end();
 });
 
 tape( 'the function returns the significand for subnormals', opts, function test( t ) {
 	var x = toFloat32( 3.14e-42 );
 	var s = parseInt( bits( x ).substring( 9 ), 2 );
-	t.equal( significand( x ), s, 'returns the significand for ' + x );
+	t.strictEqual( significand( x ), s, 'returns the significand for ' + x );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/test/test.js b/lib/node_modules/@stdlib/number/float32/base/test/test.js
index 14dda1f7d171..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/number/float32/base/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/test/test.js
@@ -29,12 +29,12 @@ var ns = require( './../lib' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ns, 'object', 'main export is an object' );
+	t.strictEqual( typeof ns, 'object', 'main export is an object' );
 	t.end();
 });
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/to-binary-string/test/test.js b/lib/node_modules/@stdlib/number/float32/base/to-binary-string/test/test.js
index de62dfbfa3cf..ef91c6020169 100644
--- a/lib/node_modules/@stdlib/number/float32/base/to-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/to-binary-string/test/test.js
@@ -47,19 +47,19 @@ var subnormal = require( './fixtures/julia/bits_1e-39_1e-45.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof toBinaryStringf, 'function', 'main export is a function' );
+	t.strictEqual( typeof toBinaryStringf, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'if provided `+0`, the function returns a string of all zeros', function test( t ) {
 	var expected = repeat( '0', 32 );
-	t.equal( toBinaryStringf( 0.0 ), expected, 'returns all 0s' );
+	t.strictEqual( toBinaryStringf( 0.0 ), expected, 'returns all 0s' );
 	t.end();
 });
 
 tape( 'if provided `-0`, the function returns a string of all zeros except for the sign bit', function test( t ) {
 	var expected = rpad( '1', 32, '0' );
-	t.equal( toBinaryStringf( -0.0 ), expected, 'returns all 0s except the sign bit' );
+	t.strictEqual( toBinaryStringf( -0.0 ), expected, 'returns all 0s except the sign bit' );
 	t.end();
 });
 
@@ -70,7 +70,7 @@ tape( 'if provided `+infinity`, the function returns a string where all exponent
 	expected += repeat( '1', NUM_EXPONENT_BITS );
 	expected += repeat( '0', NUM_SIGNIFICAND_BITS );
 
-	t.equal( toBinaryStringf( PINF ), expected, 'returns bit string for +infinity' );
+	t.strictEqual( toBinaryStringf( PINF ), expected, 'returns bit string for +infinity' );
 	t.end();
 });
 
@@ -81,7 +81,7 @@ tape( 'if provided `-infinity`, the function returns a string where the sign bit
 	expected += repeat( '1', NUM_EXPONENT_BITS );
 	expected += repeat( '0', NUM_SIGNIFICAND_BITS );
 
-	t.equal( toBinaryStringf( NINF ), expected, 'returns bit string for -infinity' );
+	t.strictEqual( toBinaryStringf( NINF ), expected, 'returns bit string for -infinity' );
 	t.end();
 });
 
@@ -96,7 +96,7 @@ tape( 'if provided `NaN`, the function returns a string where the sign bit may b
 	actual = toBinaryStringf( NaN );
 
 	t.ok( actual[0] === '0' || actual[1] === '1', 'sign bit is either 1 or 0' );
-	t.equal( actual.substring( 1, 9 ), exp, 'all 1s for exponent' );
+	t.strictEqual( actual.substring( 1, 9 ), exp, 'all 1s for exponent' );
 	t.notEqual( actual.substring( 9 ), frac, 'fraction does not equal all 0s' );
 	t.end();
 });
@@ -111,7 +111,7 @@ tape( 'the function returns literal bit representations for small values', funct
 	expected = small.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		str = toBinaryStringf( x[ i ] );
-		t.equal( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
+		t.strictEqual( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
 	}
 	t.end();
 });
@@ -126,7 +126,7 @@ tape( 'the function returns literal bit representations for medium values', func
 	expected = medium.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		str = toBinaryStringf( x[ i ] );
-		t.equal( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
+		t.strictEqual( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
 	}
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the function returns literal bit representations for large values', funct
 	expected = large.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		str = toBinaryStringf( x[ i ] );
-		t.equal( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
+		t.strictEqual( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
 	}
 	t.end();
 });
@@ -156,7 +156,7 @@ tape( 'the function returns literal bit representations for subnormal values', f
 	expected = subnormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		str = toBinaryStringf( x[ i ] );
-		t.equal( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
+		t.strictEqual( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/to-word/test/test.js b/lib/node_modules/@stdlib/number/float32/base/to-word/test/test.js
index a7cf05fb98df..1ecd0ace0c58 100644
--- a/lib/node_modules/@stdlib/number/float32/base/to-word/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/to-word/test/test.js
@@ -53,7 +53,7 @@ var positiveTiny = require( './fixtures/julia/positive_tiny.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof toWord, 'function', 'main export is a function' );
+	t.strictEqual( typeof toWord, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -74,7 +74,7 @@ tape( 'if provided `0`, the function returns an unsigned 32-bit integer represen
 
 	word = toWord( 0.0 );
 
-	t.equal( word, uint32, 'equals '+w );
+	t.strictEqual( word, uint32, 'equals '+w );
 	t.end();
 });
 
@@ -95,7 +95,7 @@ tape( 'if provided `-0`, the function returns an unsigned 32-bit integer represe
 
 	word = toWord( -0.0 );
 
-	t.equal( word, uint32, 'equals '+w );
+	t.strictEqual( word, uint32, 'equals '+w );
 	t.end();
 });
 
@@ -116,7 +116,7 @@ tape( 'if provided `+infinity`, the function returns an unsigned 32-bit integer
 
 	word = toWord( PINF );
 
-	t.equal( word, uint32, 'equals '+w );
+	t.strictEqual( word, uint32, 'equals '+w );
 	t.end();
 });
 
@@ -137,7 +137,7 @@ tape( 'if provided `-infinity`, the function returns an unsigned 32-bit integer
 
 	word = toWord( NINF );
 
-	t.equal( word, uint32, 'equals '+w );
+	t.strictEqual( word, uint32, 'equals '+w );
 	t.end();
 });
 
@@ -158,7 +158,7 @@ tape( 'if provided `NaN`, the function returns an unsigned 32-bit integer repres
 
 	word = toWord( NaN );
 
-	t.equal( word, uint32, 'equals '+w );
+	t.strictEqual( word, uint32, 'equals '+w );
 	t.end();
 });
 
@@ -174,7 +174,7 @@ tape( 'if provided large positive values, the function returns unsigned 32-bit i
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -191,7 +191,7 @@ tape( 'if provided normal positive values, the function returns unsigned 32-bit
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -208,7 +208,7 @@ tape( 'if provided small positive values, the function returns unsigned 32-bit i
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -225,7 +225,7 @@ tape( 'if provided tiny positive values, the function returns unsigned 32-bit in
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -242,7 +242,7 @@ tape( 'if provided subnormal positive values, the function returns unsigned 32-b
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -259,7 +259,7 @@ tape( 'if provided large negative values, the function returns unsigned 32-bit i
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -276,7 +276,7 @@ tape( 'if provided normal negative values, the function returns unsigned 32-bit
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -293,7 +293,7 @@ tape( 'if provided small negative values, the function returns unsigned 32-bit i
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -310,7 +310,7 @@ tape( 'if provided tiny negative values, the function returns unsigned 32-bit in
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -327,7 +327,7 @@ tape( 'if provided subnormal negative values, the function returns unsigned 32-b
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/to-word/test/test.native.js b/lib/node_modules/@stdlib/number/float32/base/to-word/test/test.native.js
index aa466bbd6475..a8a5b4c12c35 100644
--- a/lib/node_modules/@stdlib/number/float32/base/to-word/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float32/base/to-word/test/test.native.js
@@ -59,7 +59,7 @@ var positiveTiny = require( './fixtures/julia/positive_tiny.json' );
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof toWord, 'function', 'main export is a function' );
+	t.strictEqual( typeof toWord, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -80,7 +80,7 @@ tape( 'if provided `0`, the function returns an unsigned 32-bit integer represen
 
 	word = toWord( 0.0 );
 
-	t.equal( word, uint32, 'equals '+w );
+	t.strictEqual( word, uint32, 'equals '+w );
 	t.end();
 });
 
@@ -101,7 +101,7 @@ tape( 'if provided `-0`, the function returns an unsigned 32-bit integer represe
 
 	word = toWord( -0.0 );
 
-	t.equal( word, uint32, 'equals '+w );
+	t.strictEqual( word, uint32, 'equals '+w );
 	t.end();
 });
 
@@ -122,7 +122,7 @@ tape( 'if provided `+infinity`, the function returns an unsigned 32-bit integer
 
 	word = toWord( PINF );
 
-	t.equal( word, uint32, 'equals '+w );
+	t.strictEqual( word, uint32, 'equals '+w );
 	t.end();
 });
 
@@ -143,7 +143,7 @@ tape( 'if provided `-infinity`, the function returns an unsigned 32-bit integer
 
 	word = toWord( NINF );
 
-	t.equal( word, uint32, 'equals '+w );
+	t.strictEqual( word, uint32, 'equals '+w );
 	t.end();
 });
 
@@ -164,7 +164,7 @@ tape( 'if provided `NaN`, the function returns an unsigned 32-bit integer repres
 
 	word = toWord( NaN );
 
-	t.equal( word, uint32, 'equals '+w );
+	t.strictEqual( word, uint32, 'equals '+w );
 	t.end();
 });
 
@@ -180,7 +180,7 @@ tape( 'if provided large positive values, the function returns unsigned 32-bit i
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -197,7 +197,7 @@ tape( 'if provided normal positive values, the function returns unsigned 32-bit
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -214,7 +214,7 @@ tape( 'if provided small positive values, the function returns unsigned 32-bit i
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -231,7 +231,7 @@ tape( 'if provided tiny positive values, the function returns unsigned 32-bit in
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -248,7 +248,7 @@ tape( 'if provided subnormal positive values, the function returns unsigned 32-b
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -265,7 +265,7 @@ tape( 'if provided large negative values, the function returns unsigned 32-bit i
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -282,7 +282,7 @@ tape( 'if provided normal negative values, the function returns unsigned 32-bit
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -299,7 +299,7 @@ tape( 'if provided small negative values, the function returns unsigned 32-bit i
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -316,7 +316,7 @@ tape( 'if provided tiny negative values, the function returns unsigned 32-bit in
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
@@ -333,7 +333,7 @@ tape( 'if provided subnormal negative values, the function returns unsigned 32-b
 	for ( i = 0; i < x.length; i++ ) {
 		y = toWord( x[ i ] );
 		w = parseInt( expected[ i ], 2 );
-		t.equal( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
+		t.strictEqual( y, w, 'x: '+x[i]+', y: '+y+', expected: '+w );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/test/test.js b/lib/node_modules/@stdlib/number/float32/test/test.js
index 14dda1f7d171..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/number/float32/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/test/test.js
@@ -29,12 +29,12 @@ var ns = require( './../lib' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ns, 'object', 'main export is an object' );
+	t.strictEqual( typeof ns, 'object', 'main export is an object' );
 	t.end();
 });
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/assert/test/test.js b/lib/node_modules/@stdlib/number/float64/base/assert/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/number/float64/base/assert/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/assert/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.js b/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.js
index e1c1326f5b3d..4441c6909950 100644
--- a/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.js
@@ -35,12 +35,12 @@ var exponent = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof exponent, 'function', 'main export is a function' );
+	t.strictEqual( typeof exponent, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a number', function test( t ) {
-	t.equal( typeof exponent(3.14e240), 'number', 'returns a number' );
+	t.strictEqual( typeof exponent(3.14e240), 'number', 'returns a number' );
 	t.end();
 });
 
@@ -68,33 +68,33 @@ tape( 'the function returns an integer corresponding to the unbiased exponent of
 		expected = parseInt( b.substring( 1, 12 ), 2 ) - BIAS;
 
 		actual = exponent( x );
-		t.equal( actual, expected, 'returns the unbiased exponent for ' + x );
+		t.strictEqual( actual, expected, 'returns the unbiased exponent for ' + x );
 	}
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `+-0`', function test( t ) {
-	t.equal( exponent( 0.0 ), -BIAS, 'returns -1023' );
-	t.equal( exponent( -0.0 ), -BIAS, 'returns -1023' );
+	t.strictEqual( exponent( 0.0 ), -BIAS, 'returns -1023' );
+	t.strictEqual( exponent( -0.0 ), -BIAS, 'returns -1023' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `+infinity`', function test( t ) {
-	t.equal( exponent( PINF ), BIAS+1, 'returns 1024' );
+	t.strictEqual( exponent( PINF ), BIAS+1, 'returns 1024' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `-infinity`', function test( t ) {
-	t.equal( exponent( NINF ), BIAS+1, 'returns 1024' );
+	t.strictEqual( exponent( NINF ), BIAS+1, 'returns 1024' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `NaN`', function test( t ) {
-	t.equal( exponent( NaN ), BIAS+1, 'returns 1024' );
+	t.strictEqual( exponent( NaN ), BIAS+1, 'returns 1024' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for subnormals', function test( t ) {
-	t.equal( exponent( 3.14e-320 ), -BIAS, 'returns -1023' );
+	t.strictEqual( exponent( 3.14e-320 ), -BIAS, 'returns -1023' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.native.js
index 084a3df97b04..51d07484b837 100644
--- a/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.native.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns a number', opts, function test( t ) {
-	t.equal( typeof exponent( 3.14e240 ), 'number', 'returns a number' );
+	t.strictEqual( typeof exponent( 3.14e240 ), 'number', 'returns a number' );
 	t.end();
 });
 
@@ -77,33 +77,33 @@ tape( 'the function returns an integer corresponding to the unbiased exponent of
 		expected = parseInt( b.substring( 1, 12 ), 2 ) - BIAS;
 
 		actual = exponent( x );
-		t.equal( actual, expected, 'returns the unbiased exponent for ' + x );
+		t.strictEqual( actual, expected, 'returns the unbiased exponent for ' + x );
 	}
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `+-0`', opts, function test( t ) {
-	t.equal( exponent( 0.0 ), -BIAS, 'returns -1023' );
-	t.equal( exponent( -0.0 ), -BIAS, 'returns -1023' );
+	t.strictEqual( exponent( 0.0 ), -BIAS, 'returns -1023' );
+	t.strictEqual( exponent( -0.0 ), -BIAS, 'returns -1023' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `+infinity`', opts, function test( t ) {
-	t.equal( exponent( PINF ), BIAS+1, 'returns 1024' );
+	t.strictEqual( exponent( PINF ), BIAS+1, 'returns 1024' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `-infinity`', opts, function test( t ) {
-	t.equal( exponent( NINF ), BIAS+1, 'returns 1024' );
+	t.strictEqual( exponent( NINF ), BIAS+1, 'returns 1024' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for `NaN`', opts, function test( t ) {
-	t.equal( exponent( NaN ), BIAS+1, 'returns 1024' );
+	t.strictEqual( exponent( NaN ), BIAS+1, 'returns 1024' );
 	t.end();
 });
 
 tape( 'the function returns the unbiased exponent for subnormals', opts, function test( t ) {
-	t.equal( exponent( 3.14e-320 ), -BIAS, 'returns -1023' );
+	t.strictEqual( exponent( 3.14e-320 ), -BIAS, 'returns -1023' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.indices.js b/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.indices.js
index 97f5caa3575d..4aee66200e50 100644
--- a/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.indices.js
+++ b/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.indices.js
@@ -29,13 +29,13 @@ var indices = require( './../lib/indices.js' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof indices, 'object', 'main export is an object' );
+	t.strictEqual( typeof indices, 'object', 'main export is an object' );
 	t.end();
 });
 
 tape( 'object contains a HIGH and a LOW index', function test( t ) {
-	t.equal( typeof indices.HIGH, 'number', 'HIGH index' );
-	t.equal( typeof indices.LOW, 'number', 'LOW index' );
+	t.strictEqual( typeof indices.HIGH, 'number', 'HIGH index' );
+	t.strictEqual( typeof indices.LOW, 'number', 'LOW index' );
 	t.end();
 });
 
@@ -44,8 +44,8 @@ tape( 'if little endian, the HIGH index is 1 and the LOW index is 0', function t
 		'@stdlib/assert/is-little-endian': true
 	});
 
-	t.equal( indices.HIGH, 1, 'HIGH equals 1' );
-	t.equal( indices.LOW, 0, 'LOW equals 0' );
+	t.strictEqual( indices.HIGH, 1, 'HIGH equals 1' );
+	t.strictEqual( indices.LOW, 0, 'LOW equals 0' );
 	t.end();
 });
 
@@ -54,7 +54,7 @@ tape( 'if big endian, the HIGH index is 0 and the LOW index is 1', function test
 		'@stdlib/assert/is-little-endian': 'beep' // a value other than `true`
 	});
 
-	t.equal( indices.HIGH, 0, 'HIGH equals 0' );
-	t.equal( indices.LOW, 1, 'LOW equals 1' );
+	t.strictEqual( indices.HIGH, 0, 'HIGH equals 0' );
+	t.strictEqual( indices.LOW, 1, 'LOW equals 1' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.js b/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.js
index aa303f9f2409..a60e4ae0f890 100644
--- a/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.js
@@ -33,13 +33,13 @@ var fromWords = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof fromWords, 'function', 'main export is a function' );
+	t.strictEqual( typeof fromWords, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns number', function test( t ) {
 	var x = fromWords( 5, 4 );
-	t.equal( typeof x, 'number', 'returns a number' );
+	t.strictEqual( typeof x, 'number', 'returns a number' );
 	t.end();
 });
 
@@ -94,7 +94,7 @@ tape( 'the function creates a floating-point number from a higher order word and
 		v = values[ i ];
 		w = toWords( v );
 		x = fromWords( w[ 0 ], w[ 1 ] );
-		t.equal( x, v, 'returns ' + x + ' from a higher order word (' + w[0] + ') and a lower order word (' + w[1] + ')' );
+		t.strictEqual( x, v, 'returns ' + x + ' from a higher order word (' + w[0] + ') and a lower order word (' + w[1] + ')' );
 	}
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function can return `NaN`', function test( t ) {
 	w = toWords( NaN );
 	x = fromWords( w[0], w[1] );
 
-	t.equal( isnan( x ), true, 'returns NaN' );
+	t.strictEqual( isnan( x ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -117,7 +117,7 @@ tape( 'the function can return `+infinity`', function test( t ) {
 	w = toWords( PINF );
 	x = fromWords( w[0], w[1] );
 
-	t.equal( x, PINF, 'returns positive infinity' );
+	t.strictEqual( x, PINF, 'returns positive infinity' );
 	t.end();
 });
 
@@ -128,6 +128,6 @@ tape( 'the function can return `-infinity`', function test( t ) {
 	w = toWords( NINF );
 	x = fromWords( w[0], w[1] );
 
-	t.equal( x, NINF, 'returns negative infinity' );
+	t.strictEqual( x, NINF, 'returns negative infinity' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.native.js
index 34c5fc88aa3a..792fe46db9d3 100644
--- a/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.native.js
@@ -42,13 +42,13 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof fromWords, 'function', 'main export is a function' );
+	t.strictEqual( typeof fromWords, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns number', opts, function test( t ) {
 	var x = fromWords( 5, 4 );
-	t.equal( typeof x, 'number', 'returns a number' );
+	t.strictEqual( typeof x, 'number', 'returns a number' );
 	t.end();
 });
 
@@ -103,7 +103,7 @@ tape( 'the function creates a floating-point number from a higher order word and
 		v = values[ i ];
 		w = toWords( v );
 		x = fromWords( w[ 0 ], w[ 1 ] );
-		t.equal( x, v, 'returns ' + x + ' from a higher order word (' + w[0] + ') and a lower order word (' + w[1] + ')' );
+		t.strictEqual( x, v, 'returns ' + x + ' from a higher order word (' + w[0] + ') and a lower order word (' + w[1] + ')' );
 	}
 	t.end();
 });
@@ -115,7 +115,7 @@ tape( 'the function can return `NaN`', opts, function test( t ) {
 	w = toWords( NaN );
 	x = fromWords( w[0], w[1] );
 
-	t.equal( isnan( x ), true, 'returns NaN' );
+	t.strictEqual( isnan( x ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -126,7 +126,7 @@ tape( 'the function can return `+infinity`', opts, function test( t ) {
 	w = toWords( PINF );
 	x = fromWords( w[0], w[1] );
 
-	t.equal( x, PINF, 'returns positive infinity' );
+	t.strictEqual( x, PINF, 'returns positive infinity' );
 	t.end();
 });
 
@@ -137,6 +137,6 @@ tape( 'the function can return `-infinity`', opts, function test( t ) {
 	w = toWords( NINF );
 	x = fromWords( w[0], w[1] );
 
-	t.equal( x, NINF, 'returns negative infinity' );
+	t.strictEqual( x, NINF, 'returns negative infinity' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.high.js b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.high.js
index 3fe08dd6bbcf..bc2af205c8a9 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.high.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.high.js
@@ -29,7 +29,7 @@ var HIGH = require( './../lib/high.js' );
 
 tape( 'main export is a number', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof HIGH, 'number', 'main export is a number' );
+	t.strictEqual( typeof HIGH, 'number', 'main export is a number' );
 	t.end();
 });
 
@@ -38,7 +38,7 @@ tape( 'if little endian, the export equals 1', function test( t ) {
 		'@stdlib/assert/is-little-endian': true
 	});
 
-	t.equal( HIGH, 1, 'HIGH equals 1' );
+	t.strictEqual( HIGH, 1, 'HIGH equals 1' );
 	t.end();
 });
 
@@ -47,6 +47,6 @@ tape( 'if big endian, the export equals 0', function test( t ) {
 		'@stdlib/assert/is-little-endian': 'beep' // a value other than `true`
 	});
 
-	t.equal( HIGH, 0, 'HIGH equals 0' );
+	t.strictEqual( HIGH, 0, 'HIGH equals 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.js b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.js
index 3f6b1443098d..76b60d1eb995 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.js
@@ -34,15 +34,15 @@ var getHighWord = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof getHighWord, 'function', 'main export is a function' );
+	t.strictEqual( typeof getHighWord, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an integer', function test( t ) {
 	var w = getHighWord( pow( 2.0, 53 ) );
 
-	t.equal( typeof w, 'number', 'returns a number' );
-	t.equal( w%1, 0, 'returns an integer' );
+	t.strictEqual( typeof w, 'number', 'returns a number' );
+	t.strictEqual( w%1, 0, 'returns an integer' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function extracts a higher order word from a floating-point number',
 		high = lpad( high, 32, '0' );
 
 		expected = toBinaryString( v ).substring( 0, 32 );
-		t.equal( high, expected, 'high equals expected bit string for ' + v );
+		t.strictEqual( high, expected, 'high equals expected bit string for ' + v );
 	}
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'if provided `NaN`, the sign bit may be either 0 or 1 and the exponent mus
 	t.ok( high[0] === '1' || high[0] === '0', 'sign is either 1 or 0' );
 
 	// Exponent all 1s.
-	t.equal( high.substring( 1, 12 ), '11111111111', 'exponent all 1s' );
+	t.strictEqual( high.substring( 1, 12 ), '11111111111', 'exponent all 1s' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'if provided `+infinity`, the higher order word corresponds to a sign of 0
 	high = parseInt( high, 2 );
 
 	w = getHighWord( PINF );
-	t.equal( w, high, 'equals high word' );
+	t.strictEqual( w, high, 'equals high word' );
 	t.end();
 });
 
@@ -152,6 +152,6 @@ tape( 'if provided `-infinity`, the higher order word corresponds to a sign of 1
 	high = parseInt( high, 2 );
 
 	w = getHighWord( NINF );
-	t.equal( w, high, 'equals high word' );
+	t.strictEqual( w, high, 'equals high word' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.native.js
index 6c9fb6bd11ba..68501fceca48 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.native.js
@@ -43,15 +43,15 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof getHighWord, 'function', 'main export is a function' );
+	t.strictEqual( typeof getHighWord, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an integer', opts, function test( t ) {
 	var w = getHighWord( pow( 2.0, 53 ) );
 
-	t.equal( typeof w, 'number', 'returns a number' );
-	t.equal( w%1, 0, 'returns an integer' );
+	t.strictEqual( typeof w, 'number', 'returns a number' );
+	t.strictEqual( w%1, 0, 'returns an integer' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function extracts a higher order word from a floating-point number',
 		high = lpad( high, 32, '0' );
 
 		expected = toBinaryString( v ).substring( 0, 32 );
-		t.equal( high, expected, 'high equals expected bit string for ' + v );
+		t.strictEqual( high, expected, 'high equals expected bit string for ' + v );
 	}
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'if provided `NaN`, the sign bit may be either 0 or 1 and the exponent mus
 	t.ok( high[0] === '1' || high[0] === '0', 'sign is either 1 or 0' );
 
 	// Exponent all 1s.
-	t.equal( high.substring( 1, 12 ), '11111111111', 'exponent all 1s' );
+	t.strictEqual( high.substring( 1, 12 ), '11111111111', 'exponent all 1s' );
 
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'if provided `+infinity`, the higher order word corresponds to a sign of 0
 	high = parseInt( high, 2 );
 
 	w = getHighWord( PINF );
-	t.equal( w, high, 'equals high word' );
+	t.strictEqual( w, high, 'equals high word' );
 	t.end();
 });
 
@@ -161,6 +161,6 @@ tape( 'if provided `-infinity`, the higher order word corresponds to a sign of 1
 	high = parseInt( high, 2 );
 
 	w = getHighWord( NINF );
-	t.equal( w, high, 'equals high word' );
+	t.strictEqual( w, high, 'equals high word' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.js b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.js
index 8a35e0eef4ec..780382eaa18a 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.js
@@ -33,15 +33,15 @@ var getLowWord = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof getLowWord, 'function', 'main export is a function' );
+	t.strictEqual( typeof getLowWord, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an integer', function test( t ) {
 	var w = getLowWord( pow( 2, 53 ) );
 
-	t.equal( typeof w, 'number', 'returns a number' );
-	t.equal( w%1, 0, 'returns an integer' );
+	t.strictEqual( typeof w, 'number', 'returns a number' );
+	t.strictEqual( w%1, 0, 'returns an integer' );
 
 	t.end();
 });
@@ -103,19 +103,19 @@ tape( 'the function extracts a lower order word from a double-precision floating
 		low = lpad( low, 32, '0' );
 
 		expected = bits( v ).substring( 32 );
-		t.equal( low, expected, 'low equals expected bit string for ' + v );
+		t.strictEqual( low, expected, 'low equals expected bit string for ' + v );
 	}
 	t.end();
 });
 
 tape( 'if provided `+infinity`, the lower order word is 0 (IEEE 754-1985)', function test( t ) {
 	var w = getLowWord( PINF );
-	t.equal( w, 0, 'equals 0' );
+	t.strictEqual( w, 0, 'equals 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the lower order word is 0 (IEEE 754-1985)', function test( t ) {
 	var w = getLowWord( NINF );
-	t.equal( w, 0, 'equals 0' );
+	t.strictEqual( w, 0, 'equals 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.low.js b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.low.js
index cc5d17291c6a..f66cc118a75c 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.low.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.low.js
@@ -29,7 +29,7 @@ var LOW = require( './../lib/low.js' );
 
 tape( 'main export is a number', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof LOW, 'number', 'main export is a number' );
+	t.strictEqual( typeof LOW, 'number', 'main export is a number' );
 	t.end();
 });
 
@@ -38,7 +38,7 @@ tape( 'if little endian, the export equals 0', function test( t ) {
 		'@stdlib/assert/is-little-endian': true
 	});
 
-	t.equal( LOW, 0, 'LOW equals 0' );
+	t.strictEqual( LOW, 0, 'LOW equals 0' );
 	t.end();
 });
 
@@ -47,6 +47,6 @@ tape( 'if big endian, the export equals 1', function test( t ) {
 		'@stdlib/assert/is-little-endian': 'beep' // a value other than `true`
 	});
 
-	t.equal( LOW, 1, 'LOW equals 1' );
+	t.strictEqual( LOW, 1, 'LOW equals 1' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.native.js
index d7abf6366564..8967e8793552 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.native.js
@@ -42,15 +42,15 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof getLowWord, 'function', 'main export is a function' );
+	t.strictEqual( typeof getLowWord, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns an integer', opts, function test( t ) {
 	var w = getLowWord( pow( 2, 53 ) );
 
-	t.equal( typeof w, 'number', 'returns a number' );
-	t.equal( w%1, 0, 'returns an integer' );
+	t.strictEqual( typeof w, 'number', 'returns a number' );
+	t.strictEqual( w%1, 0, 'returns an integer' );
 
 	t.end();
 });
@@ -112,19 +112,19 @@ tape( 'the function extracts a lower order word from a double-precision floating
 		low = lpad( low, 32, '0' );
 
 		expected = bits( v ).substring( 32 );
-		t.equal( low, expected, 'low equals expected bit string for ' + v );
+		t.strictEqual( low, expected, 'low equals expected bit string for ' + v );
 	}
 	t.end();
 });
 
 tape( 'if provided `+infinity`, the lower order word is 0 (IEEE 754-1985)', opts, function test( t ) {
 	var w = getLowWord( PINF );
-	t.equal( w, 0, 'equals 0' );
+	t.strictEqual( w, 0, 'equals 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the lower order word is 0 (IEEE 754-1985)', opts, function test( t ) {
 	var w = getLowWord( NINF );
-	t.equal( w, 0, 'equals 0' );
+	t.strictEqual( w, 0, 'equals 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/identity/test/test.js b/lib/node_modules/@stdlib/number/float64/base/identity/test/test.js
index 63d518215e61..35ae6fdc55f7 100644
--- a/lib/node_modules/@stdlib/number/float64/base/identity/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/identity/test/test.js
@@ -38,25 +38,25 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a finite number', function test( t ) {
-	t.equal( identity( -2.0 ), -2.0, 'returns expected value' );
-	t.equal( identity( 3.0 ), 3.0, 'returns expected value' );
+	t.strictEqual( identity( -2.0 ), -2.0, 'returns expected value' );
+	t.strictEqual( identity( 3.0 ), 3.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function evaluates the identity function when provided +-zero', function test( t ) {
-	t.equal( isNegativeZero( identity( -0.0 ) ), true, 'returns expected value' );
-	t.equal( isPositiveZero( identity( 0.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( identity( -0.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( identity( 0.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function evaluates the identity function when provided +-infinity', function test( t ) {
-	t.equal( identity( PINF ), PINF, 'returns expected value' );
-	t.equal( identity( NINF ), NINF, 'returns expected value' );
+	t.strictEqual( identity( PINF ), PINF, 'returns expected value' );
+	t.strictEqual( identity( NINF ), NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = identity( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/identity/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/identity/test/test.native.js
index 9651c4fffd27..427ca66189c1 100644
--- a/lib/node_modules/@stdlib/number/float64/base/identity/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/identity/test/test.native.js
@@ -47,25 +47,25 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a finite number', opts, function test( t ) {
-	t.equal( identity( -2.0 ), -2.0, 'returns expected value' );
-	t.equal( identity( 3.0 ), 3.0, 'returns expected value' );
+	t.strictEqual( identity( -2.0 ), -2.0, 'returns expected value' );
+	t.strictEqual( identity( 3.0 ), 3.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function evaluates the identity function when provided +-zero', opts, function test( t ) {
-	t.equal( isNegativeZero( identity( -0.0 ) ), true, 'returns expected value' );
-	t.equal( isPositiveZero( identity( 0.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( identity( -0.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( identity( 0.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function evaluates the identity function when provided +-infinity', opts, function test( t ) {
-	t.equal( identity( PINF ), PINF, 'returns expected value' );
-	t.equal( identity( NINF ), NINF, 'returns expected value' );
+	t.strictEqual( identity( PINF ), PINF, 'returns expected value' );
+	t.strictEqual( identity( NINF ), NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var v = identity( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/normalize/test/test.assign.js b/lib/node_modules/@stdlib/number/float64/base/normalize/test/test.assign.js
index c2ec7280db4c..dc5fda4ea024 100644
--- a/lib/node_modules/@stdlib/number/float64/base/normalize/test/test.assign.js
+++ b/lib/node_modules/@stdlib/number/float64/base/normalize/test/test.assign.js
@@ -37,7 +37,7 @@ var normalize = require( './../lib/assign.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof normalize, 'function', 'main export is a function' );
+	t.strictEqual( typeof normalize, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -53,7 +53,7 @@ tape( 'the function normalizes a denormalized number, returning a normal number
 	// Smallest denormalized number:
 	v = normalize( FLOAT64_SMALLEST_SUBNORMAL, new Float64Array( 2 ), 1, 0 );
 	t.ok( v[ 0 ] >= FLOAT64_SMALLEST_NORMAL, 'returns a normal number' );
-	t.equal( v[ 0 ]*pow( 2, v[ 1 ] ), FLOAT64_SMALLEST_SUBNORMAL, 'x = y * 2^exp' );
+	t.strictEqual( v[ 0 ]*pow( 2, v[ 1 ] ), FLOAT64_SMALLEST_SUBNORMAL, 'x = y * 2^exp' );
 
 	// Other subnormals...
 	for ( i = 0; i < 1000; i++ ) {
@@ -63,11 +63,11 @@ tape( 'the function normalizes a denormalized number, returning a normal number
 		out = new Float64Array( 2 );
 		v = normalize( x, out, 1, 0 );
 
-		t.equal( v, out, 'returns expected value' );
+		t.strictEqual( v, out, 'returns expected value' );
 		t.ok( v[ 0 ] >= FLOAT64_SMALLEST_NORMAL, 'returns a normal number ' + v[0] );
 
 		x1 = v[ 0 ] * pow( 2.0, v[ 1 ] );
-		t.equal( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
+		t.strictEqual( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
 	}
 	t.end();
 });
@@ -88,11 +88,11 @@ tape( 'the function handles normalized numbers, returning a normal number and an
 		out = new Float64Array( 2 );
 		v = normalize( x, out, 1, 0 );
 
-		t.equal( v, out, 'returns expected value' );
-		t.equal( v[ 0 ], x, 'returns a normal number ' + v[0] );
+		t.strictEqual( v, out, 'returns expected value' );
+		t.strictEqual( v[ 0 ], x, 'returns a normal number ' + v[0] );
 
 		x1 = v[ 0 ] * pow( 2.0, v[ 1 ] );
-		t.equal( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
+		t.strictEqual( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
 	}
 	t.end();
 });
@@ -121,8 +121,8 @@ tape( 'the function returns `[-inf,0]` if provided a `-infinity`', function test
 tape( 'the function returns `[NaN,0]` if provided a `NaN`', function test( t ) {
 	var out = [ 0.0, 0 ];
 	var val = normalize( NaN, out, 1, 0 );
-	t.equal( isnan( val[0] ), true, 'first element is NaN' );
-	t.equal( val[1], 0, 'second element is 0' );
+	t.strictEqual( isnan( val[0] ), true, 'first element is NaN' );
+	t.strictEqual( val[1], 0, 'second element is 0' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/base/normalize/test/test.main.js b/lib/node_modules/@stdlib/number/float64/base/normalize/test/test.main.js
index bf7b86e7cf53..361a5d1c6cae 100644
--- a/lib/node_modules/@stdlib/number/float64/base/normalize/test/test.main.js
+++ b/lib/node_modules/@stdlib/number/float64/base/normalize/test/test.main.js
@@ -36,7 +36,7 @@ var normalize = require( './../lib/main.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof normalize, 'function', 'main export is a function' );
+	t.strictEqual( typeof normalize, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function normalizes a denormalized number, returning a normal number
 	// Smallest denormalized number:
 	v = normalize( FLOAT64_SMALLEST_SUBNORMAL );
 	t.ok( v[ 0 ] >= FLOAT64_SMALLEST_NORMAL, 'returns a normal number' );
-	t.equal( v[ 0 ]*pow( 2, v[ 1 ] ), FLOAT64_SMALLEST_SUBNORMAL, 'x = y * 2^exp' );
+	t.strictEqual( v[ 0 ]*pow( 2, v[ 1 ] ), FLOAT64_SMALLEST_SUBNORMAL, 'x = y * 2^exp' );
 
 	// Other subnormals...
 	for ( i = 0; i < 1000; i++ ) {
@@ -63,7 +63,7 @@ tape( 'the function normalizes a denormalized number, returning a normal number
 		t.ok( v[ 0 ] >= FLOAT64_SMALLEST_NORMAL, 'returns a normal number ' + v[0] );
 
 		x1 = v[ 0 ] * pow( 2.0, v[ 1 ] );
-		t.equal( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
+		t.strictEqual( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
 	}
 	t.end();
 });
@@ -82,10 +82,10 @@ tape( 'the function handles normalized numbers, returning a normal number and an
 		x = frac * pow( 10.0, exp );
 		v = normalize( x );
 
-		t.equal( v[ 0 ], x, 'returns a normal number ' + v[0] );
+		t.strictEqual( v[ 0 ], x, 'returns a normal number ' + v[0] );
 
 		x1 = v[ 0 ] * pow( 2.0, v[ 1 ] );
-		t.equal( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
+		t.strictEqual( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function returns `[-inf,0]` if provided a `-infinity`', function test
 
 tape( 'the function returns `[NaN,0]` if provided a `NaN`', function test( t ) {
 	var val = normalize( NaN );
-	t.equal( isnan( val[0] ), true, 'first element is NaN' );
-	t.equal( val[1], 0, 'second element is 0' );
+	t.strictEqual( isnan( val[0] ), true, 'first element is NaN' );
+	t.strictEqual( val[1], 0, 'second element is 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/normalize/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/normalize/test/test.native.js
index c779d09f2a13..78f3aa9f024b 100644
--- a/lib/node_modules/@stdlib/number/float64/base/normalize/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/normalize/test/test.native.js
@@ -45,7 +45,7 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof normalize, 'function', 'main export is a function' );
+	t.strictEqual( typeof normalize, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'the function normalizes a denormalized number, returning a normal number
 	// Smallest denormalized number:
 	v = normalize( FLOAT64_SMALLEST_SUBNORMAL );
 	t.ok( v[ 0 ] >= FLOAT64_SMALLEST_NORMAL, 'returns a normal number' );
-	t.equal( v[ 0 ]*pow( 2, v[ 1 ] ), FLOAT64_SMALLEST_SUBNORMAL, 'x = y * 2^exp' );
+	t.strictEqual( v[ 0 ]*pow( 2, v[ 1 ] ), FLOAT64_SMALLEST_SUBNORMAL, 'x = y * 2^exp' );
 
 	// Other subnormals...
 	for ( i = 0; i < 1000; i++ ) {
@@ -72,7 +72,7 @@ tape( 'the function normalizes a denormalized number, returning a normal number
 		t.ok( v[ 0 ] >= FLOAT64_SMALLEST_NORMAL, 'returns a normal number ' + v[0] );
 
 		x1 = v[ 0 ] * pow( 2.0, v[ 1 ] );
-		t.equal( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
+		t.strictEqual( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
 	}
 	t.end();
 });
@@ -91,10 +91,10 @@ tape( 'the function handles normalized numbers, returning a normal number and an
 		x = frac * pow( 10.0, exp );
 		v = normalize( x );
 
-		t.equal( v[ 0 ], x, 'returns a normal number ' + v[0] );
+		t.strictEqual( v[ 0 ], x, 'returns a normal number ' + v[0] );
 
 		x1 = v[ 0 ] * pow( 2.0, v[ 1 ] );
-		t.equal( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
+		t.strictEqual( x1, x, 'y*2^exp=x. y='+v[0]+', exp='+v[1]+', x='+x );
 	}
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function returns `[-inf,0]` if provided a `-infinity`', opts, functio
 
 tape( 'the function returns `[NaN,0]` if provided a `NaN`', opts, function test( t ) {
 	var val = normalize( NaN );
-	t.equal( isnan( val[0] ), true, 'first element is NaN' );
-	t.equal( val[1], 0, 'second element is 0' );
+	t.strictEqual( isnan( val[0] ), true, 'first element is NaN' );
+	t.strictEqual( val[1], 0, 'second element is 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.high.js b/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.high.js
index e9396c66fadc..4b28ab5e304b 100644
--- a/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.high.js
+++ b/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.high.js
@@ -29,7 +29,7 @@ var HIGH = require( './../lib/high.js' );
 
 tape( 'main export is a number', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof HIGH, 'number', 'main export is a number' );
+	t.strictEqual( typeof HIGH, 'number', 'main export is a number' );
 	t.end();
 });
 
@@ -38,7 +38,7 @@ tape( 'if little endian, the export equals 1', function test( t ) {
 		'@stdlib/assert/is-little-endian': true
 	});
 
-	t.equal( HIGH, 1, 'HIGH equals 1' );
+	t.strictEqual( HIGH, 1, 'HIGH equals 1' );
 	t.end();
 });
 
@@ -47,6 +47,6 @@ tape( 'if big endian, the export equals 0', function test( t ) {
 		'@stdlib/assert/is-little-endian': 'beep' // a value other than true
 	});
 
-	t.equal( HIGH, 0, 'HIGH equals 0' );
+	t.strictEqual( HIGH, 0, 'HIGH equals 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.js b/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.js
index 1470f3ed2266..b1635a7cf931 100644
--- a/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.js
@@ -52,13 +52,13 @@ var DISTINGUISHABLE_NANS_POSSIBLE = ( // eslint-disable-line id-length
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof setHighWord, 'function', 'main export is a function' );
+	t.strictEqual( typeof setHighWord, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a number', function test( t ) {
 	var y = setHighWord( pow( 2.0, 53 ), 5 );
-	t.equal( typeof y, 'number', 'returns a number' );
+	t.strictEqual( typeof y, 'number', 'returns a number' );
 	t.end();
 });
 
@@ -148,16 +148,16 @@ tape( 'the function sets the higher order word of a double-precision floating-po
 
 			) {
 				high = high.substring( 1, 12 );
-				t.equal( high, '11111111111', 'generated NaN => exponent all 1s' );
+				t.strictEqual( high, '11111111111', 'generated NaN => exponent all 1s' );
 			}
 			else {
 				// Higher order bits:
 				actual = toBinaryString( y ).substring( 0, 32 );
-				t.equal( actual, high, 'returned double contains expected higher order word. v: ' + v + '. y: ' + y + '. high: ' + high + '.' );
+				t.strictEqual( actual, high, 'returned double contains expected higher order word. v: ' + v + '. y: ' + y + '. high: ' + high + '.' );
 
 				// Lower order bits:
 				actual = toBinaryString( y ).substring( 32 );
-				t.equal( actual, low, 'returned double contains expected lower order word. v: ' + v + '.' );
+				t.strictEqual( actual, low, 'returned double contains expected lower order word. v: ' + v + '.' );
 			}
 		}
 	}
diff --git a/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.native.js
index 0d5420472732..5766a764dd25 100644
--- a/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.native.js
@@ -57,13 +57,13 @@ var DISTINGUISHABLE_NANS_POSSIBLE = ( // eslint-disable-line id-length
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof setHighWord, 'function', 'main export is a function' );
+	t.strictEqual( typeof setHighWord, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a number', opts, function test( t ) {
 	var y = setHighWord( pow( 2.0, 53 ), 5 );
-	t.equal( typeof y, 'number', 'returns a number' );
+	t.strictEqual( typeof y, 'number', 'returns a number' );
 	t.end();
 });
 
@@ -153,16 +153,16 @@ tape( 'the function sets the higher order word of a double-precision floating-po
 
 			) {
 				high = high.substring( 1, 12 );
-				t.equal( high, '11111111111', 'generated NaN => exponent all 1s' );
+				t.strictEqual( high, '11111111111', 'generated NaN => exponent all 1s' );
 			}
 			else {
 				// Higher order bits:
 				actual = toBinaryString( y ).substring( 0, 32 );
-				t.equal( actual, high, 'returned double contains expected higher order word. v: ' + v + '. y: ' + y + '. high: ' + high + '.' );
+				t.strictEqual( actual, high, 'returned double contains expected higher order word. v: ' + v + '. y: ' + y + '. high: ' + high + '.' );
 
 				// Lower order bits:
 				actual = toBinaryString( y ).substring( 32 );
-				t.equal( actual, low, 'returned double contains expected lower order word. v: ' + v + '.' );
+				t.strictEqual( actual, low, 'returned double contains expected lower order word. v: ' + v + '.' );
 			}
 		}
 	}
diff --git a/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.js b/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.js
index b51a9aa09a9a..134dacea1aca 100644
--- a/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.js
@@ -47,13 +47,13 @@ var opts;
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof setLowWord, 'function', 'main export is a function' );
+	t.strictEqual( typeof setLowWord, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a number', function test( t ) {
 	var y = setLowWord( pow( 2, 53 ), 5 );
-	t.equal( typeof y, 'number', 'returns a number' );
+	t.strictEqual( typeof y, 'number', 'returns a number' );
 	t.end();
 });
 
@@ -126,11 +126,11 @@ tape( 'the function sets the lower order word of a double-precision floating-poi
 
 			// Lower order bits:
 			actual = toBinaryString( y ).substring( 32 );
-			t.equal( actual, low, 'returned double has the same lower order word as ' + v );
+			t.strictEqual( actual, low, 'returned double has the same lower order word as ' + v );
 
 			// Higher order bits:
 			actual = toBinaryString( y ).substring( 0, 32 );
-			t.equal( actual, high, 'returned double has the same higher order word as ' + v );
+			t.strictEqual( actual, high, 'returned double has the same higher order word as ' + v );
 		}
 	}
 	t.end();
@@ -146,7 +146,7 @@ tape( 'if provided `+infinity`, setting the lower order bits will return `NaN`',
 	low = pow( 2.0, 14 );
 	y = setLowWord( PINF, low );
 
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -161,14 +161,14 @@ tape( 'if provided `+infinity`, setting the lower order bits will return `NaN` (
 	low = pow( 2.0, 14 );
 	y = setLowWord( PINF, low );
 
-	t.equal( isNumber( y ), true, 'returns a number' );
-	t.equal( y.toString(), 'NaN', 'serializes as NaN' );
+	t.strictEqual( isNumber( y ), true, 'returns a number' );
+	t.strictEqual( y.toString(), 'NaN', 'serializes as NaN' );
 
 	bool = isnan( y );
 	if ( bool ) {
-		t.equal( bool, true, 'treated as canonical NaN (IEEE 754 compliant)' );
+		t.strictEqual( bool, true, 'treated as canonical NaN (IEEE 754 compliant)' );
 	} else {
-		t.equal( bool, false, 'not IEEE 754 compliant' );
+		t.strictEqual( bool, false, 'not IEEE 754 compliant' );
 	}
 	t.end();
 });
@@ -183,7 +183,7 @@ tape( 'if provided `-infinity`, setting the lower order bits will return `NaN`',
 	low = pow( 2.0, 14 );
 	y = setLowWord( NINF, low );
 
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -198,20 +198,20 @@ tape( 'if provided `-infinity`, setting the lower order bits will return `NaN` (
 	low = pow( 2.0, 14 );
 	y = setLowWord( NINF, low );
 
-	t.equal( isNumber( y ), true, 'returns a number' );
-	t.equal( y.toString(), 'NaN', 'serializes as NaN' );
+	t.strictEqual( isNumber( y ), true, 'returns a number' );
+	t.strictEqual( y.toString(), 'NaN', 'serializes as NaN' );
 
 	bool = isnan( y );
 	if ( bool ) {
-		t.equal( bool, true, 'treated as canonical NaN (IEEE 754 compliant)' );
+		t.strictEqual( bool, true, 'treated as canonical NaN (IEEE 754 compliant)' );
 	} else {
-		t.equal( bool, false, 'not IEEE 754 compliant' );
+		t.strictEqual( bool, false, 'not IEEE 754 compliant' );
 	}
 	t.end();
 });
 
 tape( 'if provided `NaN`, setting the lower order bits will return `NaN`', function test( t ) {
 	var y = setLowWord( NaN, pow( 2.0, 14 ) );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.low.js b/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.low.js
index d251f02e1a25..6f9a89a2c44b 100644
--- a/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.low.js
+++ b/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.low.js
@@ -29,7 +29,7 @@ var LOW = require( './../lib/low.js' );
 
 tape( 'main export is a number', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof LOW, 'number', 'main export is a number' );
+	t.strictEqual( typeof LOW, 'number', 'main export is a number' );
 	t.end();
 });
 
@@ -38,7 +38,7 @@ tape( 'if little endian, the export equals 0', function test( t ) {
 		'@stdlib/assert/is-little-endian': true
 	});
 
-	t.equal( LOW, 0, 'LOW equals 0' );
+	t.strictEqual( LOW, 0, 'LOW equals 0' );
 	t.end();
 });
 
@@ -47,6 +47,6 @@ tape( 'if big endian, the export equals 1', function test( t ) {
 		'@stdlib/assert/is-little-endian': 'beep' // a value other than true
 	});
 
-	t.equal( LOW, 1, 'LOW equals 1' );
+	t.strictEqual( LOW, 1, 'LOW equals 1' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.native.js
index 7eb519aea6c2..1503041b9e57 100644
--- a/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.native.js
@@ -51,13 +51,13 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof setLowWord, 'function', 'main export is a function' );
+	t.strictEqual( typeof setLowWord, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a number', opts, function test( t ) {
 	var y = setLowWord( pow( 2, 53 ), 5 );
-	t.equal( typeof y, 'number', 'returns a number' );
+	t.strictEqual( typeof y, 'number', 'returns a number' );
 	t.end();
 });
 
@@ -130,11 +130,11 @@ tape( 'the function sets the lower order word of a double-precision floating-poi
 
 			// Lower order bits:
 			actual = toBinaryString( y ).substring( 32 );
-			t.equal( actual, low, 'returned double has the same lower order word as ' + v );
+			t.strictEqual( actual, low, 'returned double has the same lower order word as ' + v );
 
 			// Higher order bits:
 			actual = toBinaryString( y ).substring( 0, 32 );
-			t.equal( actual, high, 'returned double has the same higher order word as ' + v );
+			t.strictEqual( actual, high, 'returned double has the same higher order word as ' + v );
 		}
 	}
 	t.end();
@@ -150,7 +150,7 @@ tape( 'if provided `+infinity`, setting the lower order bits will return `NaN`',
 	low = pow( 2.0, 14 );
 	y = setLowWord( PINF, low );
 
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -165,14 +165,14 @@ tape( 'if provided `+infinity`, setting the lower order bits will return `NaN` (
 	low = pow( 2.0, 14 );
 	y = setLowWord( PINF, low );
 
-	t.equal( isNumber( y ), true, 'returns a number' );
-	t.equal( y.toString(), 'NaN', 'serializes as NaN' );
+	t.strictEqual( isNumber( y ), true, 'returns a number' );
+	t.strictEqual( y.toString(), 'NaN', 'serializes as NaN' );
 
 	bool = isnan( y );
 	if ( bool ) {
-		t.equal( bool, true, 'treated as canonical NaN (IEEE 754 compliant)' );
+		t.strictEqual( bool, true, 'treated as canonical NaN (IEEE 754 compliant)' );
 	} else {
-		t.equal( bool, false, 'not IEEE 754 compliant' );
+		t.strictEqual( bool, false, 'not IEEE 754 compliant' );
 	}
 	t.end();
 });
@@ -187,7 +187,7 @@ tape( 'if provided `-infinity`, setting the lower order bits will return `NaN`',
 	low = pow( 2.0, 14 );
 	y = setLowWord( NINF, low );
 
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -202,14 +202,14 @@ tape( 'if provided `-infinity`, setting the lower order bits will return `NaN` (
 	low = pow( 2.0, 14 );
 	y = setLowWord( NINF, low );
 
-	t.equal( isNumber( y ), true, 'returns a number' );
-	t.equal( y.toString(), 'NaN', 'serializes as NaN' );
+	t.strictEqual( isNumber( y ), true, 'returns a number' );
+	t.strictEqual( y.toString(), 'NaN', 'serializes as NaN' );
 
 	bool = isnan( y );
 	if ( bool ) {
-		t.equal( bool, true, 'treated as canonical NaN (IEEE 754 compliant)' );
+		t.strictEqual( bool, true, 'treated as canonical NaN (IEEE 754 compliant)' );
 	} else {
-		t.equal( bool, false, 'not IEEE 754 compliant' );
+		t.strictEqual( bool, false, 'not IEEE 754 compliant' );
 	}
 	t.end();
 });
@@ -219,6 +219,6 @@ opts = {
 };
 tape( 'if provided `NaN`, setting the lower order bits will return `NaN`', opts, function test( t ) {
 	var y = setLowWord( NaN, pow( 2.0, 14 ) );
-	t.equal( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns NaN' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.js b/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.js
index ee81a876a029..75e4d7cd9a78 100644
--- a/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.js
@@ -31,12 +31,12 @@ var signbit = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof signbit, 'function', 'main export is a function' );
+	t.strictEqual( typeof signbit, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a boolean', function test( t ) {
-	t.equal( typeof signbit( 5.0 ), 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof signbit( 5.0 ), 'boolean', 'returns a boolean' );
 	t.end();
 });
 
@@ -59,9 +59,9 @@ tape( 'the function returns a boolean indicating if a sign bit is on (true) or o
 		x = sign * frac * pow( 10.0, exp );
 		bool = signbit( x );
 		if ( sign < 0.0 ) {
-			t.equal( bool, true, 'returns true for ' + x );
+			t.strictEqual( bool, true, 'returns true for ' + x );
 		} else {
-			t.equal( bool, false, 'returns false for ' + x );
+			t.strictEqual( bool, false, 'returns false for ' + x );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.native.js
index 49f0b830068b..8e42a1898e92 100644
--- a/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.native.js
@@ -40,12 +40,12 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof signbit, 'function', 'main export is a function' );
+	t.strictEqual( typeof signbit, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a boolean', opts, function test( t ) {
-	t.equal( typeof signbit( 5.0 ), 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof signbit( 5.0 ), 'boolean', 'returns a boolean' );
 	t.end();
 });
 
@@ -68,9 +68,9 @@ tape( 'the function returns a boolean indicating if a sign bit is on (true) or o
 		x = sign * frac * pow( 10.0, exp );
 		bool = signbit( x );
 		if ( sign < 0.0 ) {
-			t.equal( bool, true, 'returns true for ' + x );
+			t.strictEqual( bool, true, 'returns true for ' + x );
 		} else {
-			t.equal( bool, false, 'returns false for ' + x );
+			t.strictEqual( bool, false, 'returns false for ' + x );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/float64/base/test/test.js b/lib/node_modules/@stdlib/number/float64/base/test/test.js
index 14dda1f7d171..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/number/float64/base/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/test/test.js
@@ -29,12 +29,12 @@ var ns = require( './../lib' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ns, 'object', 'main export is an object' );
+	t.strictEqual( typeof ns, 'object', 'main export is an object' );
 	t.end();
 });
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/to-binary-string/test/test.js b/lib/node_modules/@stdlib/number/float64/base/to-binary-string/test/test.js
index 2d657d80982c..dafc8a59ac71 100644
--- a/lib/node_modules/@stdlib/number/float64/base/to-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/to-binary-string/test/test.js
@@ -47,19 +47,19 @@ var subnormal = require( './fixtures/julia/bits_1e-308_5e-324.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof toBinaryString, 'function', 'main export is a function' );
+	t.strictEqual( typeof toBinaryString, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'if provided `+0`, the function returns a string of all zeros', function test( t ) {
 	var expected = repeat( '0', 64 );
-	t.equal( toBinaryString( 0.0 ), expected, 'returns all 0s' );
+	t.strictEqual( toBinaryString( 0.0 ), expected, 'returns all 0s' );
 	t.end();
 });
 
 tape( 'if provided `-0`, the function returns a string of all zeros except for the sign bit', function test( t ) {
 	var expected = rpad( '1', 64, '0' );
-	t.equal( toBinaryString( -0.0 ), expected, 'returns all 0s except the sign bit' );
+	t.strictEqual( toBinaryString( -0.0 ), expected, 'returns all 0s except the sign bit' );
 	t.end();
 });
 
@@ -70,7 +70,7 @@ tape( 'if provided `+infinity`, the function returns a string where all exponent
 	expected += repeat( '1', NUM_EXPONENT_BITS );
 	expected += repeat( '0', NUM_SIGNIFICAND_BITS );
 
-	t.equal( toBinaryString( PINF ), expected, 'returns bit string for +infinity' );
+	t.strictEqual( toBinaryString( PINF ), expected, 'returns bit string for +infinity' );
 	t.end();
 });
 
@@ -81,7 +81,7 @@ tape( 'if provided `-infinity`, the function returns a string where the sign bit
 	expected += repeat( '1', NUM_EXPONENT_BITS );
 	expected += repeat( '0', NUM_SIGNIFICAND_BITS );
 
-	t.equal( toBinaryString( NINF ), expected, 'returns bit string for -infinity' );
+	t.strictEqual( toBinaryString( NINF ), expected, 'returns bit string for -infinity' );
 	t.end();
 });
 
@@ -96,7 +96,7 @@ tape( 'if provided `NaN`, the function returns a string where the sign bit may b
 	actual = toBinaryString( NaN );
 
 	t.ok( actual[0] === '0' || actual[1] === '1', 'sign bit is either 1 or 0' );
-	t.equal( actual.substring( 1, 12 ), exp, 'all 1s for exponent' );
+	t.strictEqual( actual.substring( 1, 12 ), exp, 'all 1s for exponent' );
 	t.notEqual( actual.substring( 12 ), frac, 'fraction does not equal all 0s' );
 	t.end();
 });
@@ -111,7 +111,7 @@ tape( 'the function returns literal bit representations for small values', funct
 	expected = small.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		str = toBinaryString( x[ i ] );
-		t.equal( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
+		t.strictEqual( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
 	}
 	t.end();
 });
@@ -126,7 +126,7 @@ tape( 'the function returns literal bit representations for medium values', func
 	expected = medium.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		str = toBinaryString( x[ i ] );
-		t.equal( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
+		t.strictEqual( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
 	}
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the function returns literal bit representations for large values', funct
 	expected = large.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		str = toBinaryString( x[ i ] );
-		t.equal( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
+		t.strictEqual( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
 	}
 	t.end();
 });
@@ -156,7 +156,7 @@ tape( 'the function returns literal bit representations for subnormal values', f
 	expected = subnormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		str = toBinaryString( x[ i ] );
-		t.equal( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
+		t.strictEqual( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.js b/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.js
index 7008d0bca8c6..737ce9c72e0c 100644
--- a/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.js
@@ -55,7 +55,7 @@ var positiveTiny = require( './fixtures/julia/positive_tiny.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof float64ToFloat32, 'function', 'main export is a function' );
+	t.strictEqual( typeof float64ToFloat32, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -63,7 +63,7 @@ tape( 'if an environment supports `Math.fround` (ES2015+), the main export is th
 	var float64ToFloat32 = proxyquire( './../lib', {
 		'./main.js': foo
 	});
-	t.equal( float64ToFloat32, foo, 'returns expected value' );
+	t.strictEqual( float64ToFloat32, foo, 'returns expected value' );
 	t.end();
 
 	function foo() {
@@ -75,37 +75,37 @@ tape( 'if an environment does not support `Math.fround` (non-ES2015+), the main
 	var float64ToFloat32 = proxyquire( './../lib', {
 		'./main.js': false
 	});
-	t.equal( float64ToFloat32, polyfill, 'returns expected value' );
+	t.strictEqual( float64ToFloat32, polyfill, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `0`, the function returns `0`', function test( t ) {
 	var v = float64ToFloat32( 0.0 );
-	t.equal( v, 0.0, 'equals 0' );
+	t.strictEqual( v, 0.0, 'equals 0' );
 	t.end();
 });
 
 tape( 'if provided `-0`, the function returns `-0`', function test( t ) {
 	var v = float64ToFloat32( -0.0 );
-	t.equal( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
 	t.end();
 });
 
 tape( 'if provided `+infinity`, the function returns `+infinity`', function test( t ) {
 	var v = float64ToFloat32( PINF );
-	t.equal( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns +infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `-infinity`', function test( t ) {
 	var v = float64ToFloat32( NINF );
-	t.equal( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns -infinity' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = float64ToFloat32( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -119,7 +119,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = positiveLarge.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = positiveNormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = positiveSmall.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -164,7 +164,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = positiveTiny.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -179,7 +179,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = positiveSubnormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -194,7 +194,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = negativeLarge.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -209,7 +209,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = negativeNormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -224,7 +224,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = negativeSmall.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -239,7 +239,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = negativeTiny.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -254,7 +254,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = negativeSubnormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.polyfill.js b/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.polyfill.js
index e9d0e6694664..4f6e29452916 100644
--- a/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.polyfill.js
@@ -53,37 +53,37 @@ var positiveTiny = require( './fixtures/julia/positive_tiny.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof float64ToFloat32, 'function', 'main export is a function' );
+	t.strictEqual( typeof float64ToFloat32, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'if provided `0`, the function returns `0`', function test( t ) {
 	var v = float64ToFloat32( 0.0 );
-	t.equal( v, 0.0, 'equals 0' );
+	t.strictEqual( v, 0.0, 'equals 0' );
 	t.end();
 });
 
 tape( 'if provided `-0`, the function returns `-0`', function test( t ) {
 	var v = float64ToFloat32( -0.0 );
-	t.equal( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
 	t.end();
 });
 
 tape( 'if provided `+infinity`, the function returns `+infinity`', function test( t ) {
 	var v = float64ToFloat32( PINF );
-	t.equal( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns +infinity' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `-infinity`', function test( t ) {
 	var v = float64ToFloat32( NINF );
-	t.equal( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns -infinity' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = float64ToFloat32( NaN );
-	t.equal( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns NaN' );
 	t.end();
 });
 
@@ -97,7 +97,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = positiveLarge.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -112,7 +112,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = positiveNormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = positiveSmall.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -142,7 +142,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = positiveTiny.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = positiveSubnormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -172,7 +172,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = negativeLarge.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -187,7 +187,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = negativeNormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -202,7 +202,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = negativeSmall.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -217,7 +217,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = negativeTiny.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -232,7 +232,7 @@ tape( 'the function returns the nearest single-precision floating-point number (
 	expected = negativeSubnormal.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToFloat32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/to-int32/test/test.js b/lib/node_modules/@stdlib/number/float64/base/to-int32/test/test.js
index 7b0633e908ac..21a944c32225 100644
--- a/lib/node_modules/@stdlib/number/float64/base/to-int32/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/to-int32/test/test.js
@@ -38,39 +38,39 @@ var decimals = require( './fixtures/julia/decimals.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof float64ToInt32, 'function', 'main export is a function' );
+	t.strictEqual( typeof float64ToInt32, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'if provided `0`, the function returns `0`', function test( t ) {
 	var v = float64ToInt32( 0.0 );
-	t.equal( v, 0, 'equals 0' );
+	t.strictEqual( v, 0, 'equals 0' );
 	t.end();
 });
 
 tape( 'if provided `-0`, the function returns `0`', function test( t ) {
 	var v = float64ToInt32( -0.0 );
-	t.equal( v, 0, 'equals 0' );
-	t.equal( isNegativeZero( v ), false, 'does not return -0' );
+	t.strictEqual( v, 0, 'equals 0' );
+	t.strictEqual( isNegativeZero( v ), false, 'does not return -0' );
 	t.end();
 });
 
 tape( 'if provided `+infinity`, the function returns `0`', function test( t ) {
 	var v = float64ToInt32( PINF );
-	t.equal( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `0`', function test( t ) {
 	var v = float64ToInt32( NINF );
-	t.equal( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns 0' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `0`', function test( t ) {
 	var v = float64ToInt32( NaN );
-	t.equal( isnan( v ), false, 'does not return NaN' );
-	t.equal( v, 0, 'returns 0' );
+	t.strictEqual( isnan( v ), false, 'does not return NaN' );
+	t.strictEqual( v, 0, 'returns 0' );
 	t.end();
 });
 
@@ -84,7 +84,7 @@ tape( 'the function converts integer double-precision floating-point values to s
 	expected = integers.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToInt32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'the function converts decimal double-precision floating-point values to s
 	expected = decimals.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = float64ToInt32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.assign.js b/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.assign.js
index 593e836a4c14..84bfd34e17a0 100644
--- a/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.assign.js
+++ b/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.assign.js
@@ -36,7 +36,7 @@ var toWords = require( './../lib/assign.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof toWords, 'function', 'main export is a function' );
+	t.strictEqual( typeof toWords, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -47,12 +47,12 @@ tape( 'the function returns a two-element numeric array containing integers', fu
 	out = [ 0, 0 ];
 	w= toWords( pow( 2.0, 53 ), out, 1, 0 );
 
-	t.equal( w, out, 'returns output array' );
-	t.equal( typeof w[ 0 ], 'number', 'first element is a number' );
-	t.equal( isInteger( w[0] ), true, 'first element is an integer' );
+	t.strictEqual( w, out, 'returns output array' );
+	t.strictEqual( typeof w[ 0 ], 'number', 'first element is a number' );
+	t.strictEqual( isInteger( w[0] ), true, 'first element is an integer' );
 
-	t.equal( typeof w[ 1 ], 'number', 'second element is a number' );
-	t.equal( isInteger( w[1] ), true, 'second element is an integer' );
+	t.strictEqual( typeof w[ 1 ], 'number', 'second element is a number' );
+	t.strictEqual( isInteger( w[1] ), true, 'second element is an integer' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function splits a floating-point number into a higher order word and
 		out = [ 0, 0 ];
 		w = toWords( v, out, 1, 0 );
 
-		t.equal( w, out, 'returns output array' );
+		t.strictEqual( w, out, 'returns output array' );
 
 		// Convert to binary strings:
 		high = w[ 0 ].toString( 2 );
@@ -129,7 +129,7 @@ tape( 'the function splits a floating-point number into a higher order word and
 		str += lpad( low, 32, '0' );
 
 		expected = toBinaryString( v );
-		t.equal( str, expected, 'high+low equals bit string for ' + v );
+		t.strictEqual( str, expected, 'high+low equals bit string for ' + v );
 	}
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'if provided `NaN`, the sign bit may be either 0 or 1, the exponent must b
 	out = [ 0, 0 ];
 	w = toWords( NaN, out, 1, 0 );
 
-	t.equal( w, out, 'returns output array' );
+	t.strictEqual( w, out, 'returns output array' );
 
 	// Convert to binary strings...
 	high = w[ 0 ].toString( 2 );
@@ -158,7 +158,7 @@ tape( 'if provided `NaN`, the sign bit may be either 0 or 1, the exponent must b
 	t.ok( high[0] === '1' || high[0] === '0', 'sign is either 1 or 0' );
 
 	// Exponent all 1s.
-	t.equal( high.substring( 1, 12 ), '11111111111', 'exponent all 1s' );
+	t.strictEqual( high.substring( 1, 12 ), '11111111111', 'exponent all 1s' );
 
 	// Fraction cannot be all zeros.
 	frac = repeat( '0', 52 );
@@ -184,9 +184,9 @@ tape( 'if provided `+infinity`, the higher order word corresponds to a sign of 0
 
 	out = [ 0, 0 ];
 	w = toWords( PINF, out, 1, 0 );
-	t.equal( w, out, 'returns output array' );
-	t.equal( w[0], high, 'equals high word' );
-	t.equal( w[1], low, 'equals low word' );
+	t.strictEqual( w, out, 'returns output array' );
+	t.strictEqual( w[0], high, 'equals high word' );
+	t.strictEqual( w[1], low, 'equals low word' );
 	t.end();
 });
 
@@ -206,9 +206,9 @@ tape( 'if provided `-infinity`, the higher order word corresponds to a sign of 1
 
 	out = [ 0, 0 ];
 	w = toWords( NINF, out, 1, 0 );
-	t.equal( w, out, 'returns output array' );
-	t.equal( w[0], high, 'equals high word' );
-	t.equal( w[1], low, 'equals low word' );
+	t.strictEqual( w, out, 'returns output array' );
+	t.strictEqual( w[0], high, 'equals high word' );
+	t.strictEqual( w[1], low, 'equals low word' );
 	t.end();
 });
 
@@ -219,9 +219,9 @@ tape( 'the function supports providing an output object (array)', function test(
 	out = [ 0, 0 ];
 	w = toWords( pow( 2.0, 53 ), out, 1, 0 );
 
-	t.equal( w, out, 'returns output array' );
-	t.equal( w[ 0 ], 1128267776, 'returns expected higher order word' );
-	t.equal( w[ 1 ], 0, 'returns expected lower order word' );
+	t.strictEqual( w, out, 'returns output array' );
+	t.strictEqual( w[ 0 ], 1128267776, 'returns expected higher order word' );
+	t.strictEqual( w[ 1 ], 0, 'returns expected lower order word' );
 
 	t.end();
 });
@@ -233,9 +233,9 @@ tape( 'the function supports providing an output object (typed array)', function
 	out = new Uint32Array( 2 );
 	w = toWords( pow( 2.0, 53 ), out, 1, 0 );
 
-	t.equal( w, out, 'returns output array' );
-	t.equal( w[ 0 ], 1128267776, 'returns expected higher order word' );
-	t.equal( w[ 1 ], 0, 'returns expected lower order word' );
+	t.strictEqual( w, out, 'returns output array' );
+	t.strictEqual( w[ 0 ], 1128267776, 'returns expected higher order word' );
+	t.strictEqual( w[ 1 ], 0, 'returns expected lower order word' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.indices.js b/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.indices.js
index 453ea0da65ea..0927a4cdf751 100644
--- a/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.indices.js
+++ b/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.indices.js
@@ -34,8 +34,8 @@ tape( 'main export is an object', function test( t ) {
 });
 
 tape( 'object contains a HIGH and a LOW index', function test( t ) {
-	t.equal( typeof indices.HIGH, 'number', 'HIGH index' );
-	t.equal( typeof indices.LOW, 'number', 'LOW index' );
+	t.strictEqual( typeof indices.HIGH, 'number', 'HIGH index' );
+	t.strictEqual( typeof indices.LOW, 'number', 'LOW index' );
 	t.end();
 });
 
@@ -44,8 +44,8 @@ tape( 'if little endian, the HIGH index is 1 and the LOW index is 0', function t
 		'@stdlib/assert/is-little-endian': true
 	});
 
-	t.equal( indices.HIGH, 1, 'HIGH equals 1' );
-	t.equal( indices.LOW, 0, 'LOW equals 0' );
+	t.strictEqual( indices.HIGH, 1, 'HIGH equals 1' );
+	t.strictEqual( indices.LOW, 0, 'LOW equals 0' );
 	t.end();
 });
 
@@ -54,7 +54,7 @@ tape( 'if big endian, the HIGH index is 0 and the LOW index is 1', function test
 		'@stdlib/assert/is-little-endian': 'beep' // a value other than `true`
 	});
 
-	t.equal( indices.HIGH, 0, 'HIGH equals 0' );
-	t.equal( indices.LOW, 1, 'LOW equals 1' );
+	t.strictEqual( indices.HIGH, 0, 'HIGH equals 0' );
+	t.strictEqual( indices.LOW, 1, 'LOW equals 1' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.main.js b/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.main.js
index 1033fa55abcb..d69732d845ca 100644
--- a/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.main.js
+++ b/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.main.js
@@ -35,18 +35,18 @@ var toWords = require( './../lib/main.js' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof toWords, 'function', 'main export is a function' );
+	t.strictEqual( typeof toWords, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function returns a two-element numeric array containing integers', function test( t ) {
 	var w = toWords( pow( 2.0, 53 ) );
 
-	t.equal( typeof w[ 0 ], 'number', 'first element is a number' );
-	t.equal( isInteger( w[0] ), true, 'first element is an integer' );
+	t.strictEqual( typeof w[ 0 ], 'number', 'first element is a number' );
+	t.strictEqual( isInteger( w[0] ), true, 'first element is an integer' );
 
-	t.equal( typeof w[ 1 ], 'number', 'second element is a number' );
-	t.equal( isInteger( w[1] ), true, 'second element is an integer' );
+	t.strictEqual( typeof w[ 1 ], 'number', 'second element is a number' );
+	t.strictEqual( isInteger( w[1] ), true, 'second element is an integer' );
 
 	t.end();
 });
@@ -119,7 +119,7 @@ tape( 'the function splits a floating-point number into a higher order word and
 		str += lpad( low, 32, '0' );
 
 		expected = toBinaryString( v );
-		t.equal( str, expected, 'high+low equals bit string for ' + v );
+		t.strictEqual( str, expected, 'high+low equals bit string for ' + v );
 	}
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'if provided `NaN`, the sign bit may be either 0 or 1, the exponent must b
 	t.ok( high[0] === '1' || high[0] === '0', 'sign is either 1 or 0' );
 
 	// Exponent all 1s.
-	t.equal( high.substring( 1, 12 ), '11111111111', 'exponent all 1s' );
+	t.strictEqual( high.substring( 1, 12 ), '11111111111', 'exponent all 1s' );
 
 	// Fraction cannot be all zeros.
 	frac = repeat( '0', 52 );
@@ -168,8 +168,8 @@ tape( 'if provided `+infinity`, the higher order word corresponds to a sign of 0
 	low = parseInt( low, 2 );
 
 	w = toWords( PINF );
-	t.equal( w[0], high, 'equals high word' );
-	t.equal( w[1], low, 'equals low word' );
+	t.strictEqual( w[0], high, 'equals high word' );
+	t.strictEqual( w[1], low, 'equals low word' );
 	t.end();
 });
 
@@ -187,7 +187,7 @@ tape( 'if provided `-infinity`, the higher order word corresponds to a sign of 1
 	low = parseInt( low, 2 );
 
 	w = toWords( NINF );
-	t.equal( w[0], high, 'equals high word' );
-	t.equal( w[1], low, 'equals low word' );
+	t.strictEqual( w[0], high, 'equals high word' );
+	t.strictEqual( w[1], low, 'equals low word' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.native.js
index e60c442e6be5..b2f32dfc42a4 100644
--- a/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/to-words/test/test.native.js
@@ -44,7 +44,7 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof toWords, 'function', 'main export is a function' );
+	t.strictEqual( typeof toWords, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -104,7 +104,7 @@ tape( 'the function splits a floating-point number into a higher order word and
 		v = values[ i ];
 
 		w = toWords( out, v );
-		t.equal( out, w, 'returns expected value' );
+		t.strictEqual( out, w, 'returns expected value' );
 
 		// Convert to binary strings:
 		high = w[ 0 ].toString( 2 );
@@ -120,7 +120,7 @@ tape( 'the function splits a floating-point number into a higher order word and
 		str += lpad( low, 32, '0' );
 
 		expected = toBinaryString( v );
-		t.equal( str, expected, 'high+low equals bit string for ' + v );
+		t.strictEqual( str, expected, 'high+low equals bit string for ' + v );
 	}
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'if provided `NaN`, the sign bit may be either 0 or 1, the exponent must b
 	t.ok( high[0] === '1' || high[0] === '0', 'sign is either 1 or 0' );
 
 	// Exponent all 1s.
-	t.equal( high.substring( 1, 12 ), '11111111111', 'exponent all 1s' );
+	t.strictEqual( high.substring( 1, 12 ), '11111111111', 'exponent all 1s' );
 
 	// Fraction cannot be all zeros.
 	frac = repeat( '0', 52 );
@@ -173,8 +173,8 @@ tape( 'if provided `+infinity`, the higher order word corresponds to a sign of 0
 
 	out = new Uint32Array( 2 );
 	w = toWords( out, PINF );
-	t.equal( w[0], high, 'equals high word' );
-	t.equal( w[1], low, 'equals low word' );
+	t.strictEqual( w[0], high, 'equals high word' );
+	t.strictEqual( w[1], low, 'equals low word' );
 	t.end();
 });
 
@@ -194,7 +194,7 @@ tape( 'if provided `-infinity`, the higher order word corresponds to a sign of 1
 
 	out = new Uint32Array( 2 );
 	w = toWords( out, NINF );
-	t.equal( w[0], high, 'equals high word' );
-	t.equal( w[1], low, 'equals low word' );
+	t.strictEqual( w[0], high, 'equals high word' );
+	t.strictEqual( w[1], low, 'equals low word' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/test/test.js b/lib/node_modules/@stdlib/number/float64/test/test.js
index 14dda1f7d171..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/number/float64/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/test/test.js
@@ -29,12 +29,12 @@ var ns = require( './../lib' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ns, 'object', 'main export is an object' );
+	t.strictEqual( typeof ns, 'object', 'main export is an object' );
 	t.end();
 });
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/int16/base/identity/test/test.js b/lib/node_modules/@stdlib/number/int16/base/identity/test/test.js
index a602adf14e6c..6b5dee22f682 100644
--- a/lib/node_modules/@stdlib/number/int16/base/identity/test/test.js
+++ b/lib/node_modules/@stdlib/number/int16/base/identity/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a number', function test( t ) {
-	t.equal( identity( 2 ), 2, 'returns expected value' );
-	t.equal( identity( 3 ), 3, 'returns expected value' );
+	t.strictEqual( identity( 2 ), 2, 'returns expected value' );
+	t.strictEqual( identity( 3 ), 3, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/int16/base/identity/test/test.native.js b/lib/node_modules/@stdlib/number/int16/base/identity/test/test.native.js
index 4883a87af20c..681b79cd2ad8 100644
--- a/lib/node_modules/@stdlib/number/int16/base/identity/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/int16/base/identity/test/test.native.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a number', opts, function test( t ) {
-	t.equal( identity( 2 ), 2, 'returns expected value' );
-	t.equal( identity( 3 ), 3, 'returns expected value' );
+	t.strictEqual( identity( 2 ), 2, 'returns expected value' );
+	t.strictEqual( identity( 3 ), 3, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/int32/base/identity/test/test.js b/lib/node_modules/@stdlib/number/int32/base/identity/test/test.js
index a602adf14e6c..6b5dee22f682 100644
--- a/lib/node_modules/@stdlib/number/int32/base/identity/test/test.js
+++ b/lib/node_modules/@stdlib/number/int32/base/identity/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a number', function test( t ) {
-	t.equal( identity( 2 ), 2, 'returns expected value' );
-	t.equal( identity( 3 ), 3, 'returns expected value' );
+	t.strictEqual( identity( 2 ), 2, 'returns expected value' );
+	t.strictEqual( identity( 3 ), 3, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/int32/base/identity/test/test.native.js b/lib/node_modules/@stdlib/number/int32/base/identity/test/test.native.js
index 4883a87af20c..681b79cd2ad8 100644
--- a/lib/node_modules/@stdlib/number/int32/base/identity/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/int32/base/identity/test/test.native.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a number', opts, function test( t ) {
-	t.equal( identity( 2 ), 2, 'returns expected value' );
-	t.equal( identity( 3 ), 3, 'returns expected value' );
+	t.strictEqual( identity( 2 ), 2, 'returns expected value' );
+	t.strictEqual( identity( 3 ), 3, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/int32/base/mul/test/test.js b/lib/node_modules/@stdlib/number/int32/base/mul/test/test.js
index d6f56ab72353..c4cfae383454 100644
--- a/lib/node_modules/@stdlib/number/int32/base/mul/test/test.js
+++ b/lib/node_modules/@stdlib/number/int32/base/mul/test/test.js
@@ -43,7 +43,7 @@ tape( 'if an environment supports `Math.imul` (ES2015+), the main export is the
 	var imul = proxyquire( './../lib', {
 		'./main.js': foo
 	});
-	t.equal( imul, foo, 'returns expected value' );
+	t.strictEqual( imul, foo, 'returns expected value' );
 	t.end();
 
 	function foo() {
@@ -55,7 +55,7 @@ tape( 'if an environment does not support `Math.imul` (non-ES2015+), the main ex
 	var imul = proxyquire( './../lib', {
 		'./main.js': false
 	});
-	t.equal( imul, polyfill, 'returns expected value' );
+	t.strictEqual( imul, polyfill, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/int32/base/muldw/test/test.assign.js b/lib/node_modules/@stdlib/number/int32/base/muldw/test/test.assign.js
index fc587c070044..a8eaf1613e75 100644
--- a/lib/node_modules/@stdlib/number/int32/base/muldw/test/test.assign.js
+++ b/lib/node_modules/@stdlib/number/int32/base/muldw/test/test.assign.js
@@ -45,19 +45,19 @@ tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 
 	out = [ 0, 0 ];
 	v = imuldw( NaN, 1, out, 1, 0 );
-	t.equal( v, out, 'returns output array' );
+	t.strictEqual( v, out, 'returns output array' );
 	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
 	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 
 	out = [ 0, 0 ];
 	v = imuldw( 1, NaN, out, 1, 0 );
-	t.equal( v, out, 'returns output array' );
+	t.strictEqual( v, out, 'returns output array' );
 	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
 	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 
 	out = [ 0, 0 ];
 	v = imuldw( NaN, NaN, out, 1, 0 );
-	t.equal( v, out, 'returns output array' );
+	t.strictEqual( v, out, 'returns output array' );
 	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
 	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 
@@ -78,12 +78,12 @@ tape( 'the function computes the double word product of two (signed) words', fun
 	for ( i = 0; i < expected.length; i++ ) {
 		out = [ 0, 0 ];
 		actual = imuldw( a[ i ], b[ i ], out, 1, 0 );
-		t.equal( actual, out, 'returns output array' );
+		t.strictEqual( actual, out, 'returns output array' );
 		t.deepEqual( actual, expected[ i ], 'returns expected value. a: '+a[i]+'. b: '+b[i]+'. expected: ['+expected[i].join(',')+']' );
 
 		out = [ 0, 0 ];
 		actual = imuldw( b[ i ], a[ i ], out, 1, 0 );
-		t.equal( actual, out, 'returns output array' );
+		t.strictEqual( actual, out, 'returns output array' );
 		t.deepEqual( actual, expected[ i ], 'returns expected value. a: '+b[i]+'. b: '+a[i]+'. expected: ['+expected[i].join(',')+']' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/int32/base/test/test.js b/lib/node_modules/@stdlib/number/int32/base/test/test.js
index 14dda1f7d171..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/number/int32/base/test/test.js
+++ b/lib/node_modules/@stdlib/number/int32/base/test/test.js
@@ -29,12 +29,12 @@ var ns = require( './../lib' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ns, 'object', 'main export is an object' );
+	t.strictEqual( typeof ns, 'object', 'main export is an object' );
 	t.end();
 });
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/int32/test/test.js b/lib/node_modules/@stdlib/number/int32/test/test.js
index 14dda1f7d171..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/number/int32/test/test.js
+++ b/lib/node_modules/@stdlib/number/int32/test/test.js
@@ -29,12 +29,12 @@ var ns = require( './../lib' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ns, 'object', 'main export is an object' );
+	t.strictEqual( typeof ns, 'object', 'main export is an object' );
 	t.end();
 });
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/int8/base/identity/test/test.js b/lib/node_modules/@stdlib/number/int8/base/identity/test/test.js
index a602adf14e6c..6b5dee22f682 100644
--- a/lib/node_modules/@stdlib/number/int8/base/identity/test/test.js
+++ b/lib/node_modules/@stdlib/number/int8/base/identity/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a number', function test( t ) {
-	t.equal( identity( 2 ), 2, 'returns expected value' );
-	t.equal( identity( 3 ), 3, 'returns expected value' );
+	t.strictEqual( identity( 2 ), 2, 'returns expected value' );
+	t.strictEqual( identity( 3 ), 3, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/int8/base/identity/test/test.native.js b/lib/node_modules/@stdlib/number/int8/base/identity/test/test.native.js
index 4883a87af20c..681b79cd2ad8 100644
--- a/lib/node_modules/@stdlib/number/int8/base/identity/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/int8/base/identity/test/test.native.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a number', opts, function test( t ) {
-	t.equal( identity( 2 ), 2, 'returns expected value' );
-	t.equal( identity( 3 ), 3, 'returns expected value' );
+	t.strictEqual( identity( 2 ), 2, 'returns expected value' );
+	t.strictEqual( identity( 3 ), 3, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/test/test.js b/lib/node_modules/@stdlib/number/test/test.js
index 71f6e0ab51b2..e682e93dba4d 100644
--- a/lib/node_modules/@stdlib/number/test/test.js
+++ b/lib/node_modules/@stdlib/number/test/test.js
@@ -29,12 +29,12 @@ var ns = require( './../lib' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ns, 'object', 'main export is an object' );
+	t.strictEqual( typeof ns, 'object', 'main export is an object' );
 	t.end();
 });
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint16/base/identity/test/test.js b/lib/node_modules/@stdlib/number/uint16/base/identity/test/test.js
index a602adf14e6c..6b5dee22f682 100644
--- a/lib/node_modules/@stdlib/number/uint16/base/identity/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint16/base/identity/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a number', function test( t ) {
-	t.equal( identity( 2 ), 2, 'returns expected value' );
-	t.equal( identity( 3 ), 3, 'returns expected value' );
+	t.strictEqual( identity( 2 ), 2, 'returns expected value' );
+	t.strictEqual( identity( 3 ), 3, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint16/base/identity/test/test.native.js b/lib/node_modules/@stdlib/number/uint16/base/identity/test/test.native.js
index 4883a87af20c..681b79cd2ad8 100644
--- a/lib/node_modules/@stdlib/number/uint16/base/identity/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/uint16/base/identity/test/test.native.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a number', opts, function test( t ) {
-	t.equal( identity( 2 ), 2, 'returns expected value' );
-	t.equal( identity( 3 ), 3, 'returns expected value' );
+	t.strictEqual( identity( 2 ), 2, 'returns expected value' );
+	t.strictEqual( identity( 3 ), 3, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint16/base/test/test.js b/lib/node_modules/@stdlib/number/uint16/base/test/test.js
index 14dda1f7d171..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/number/uint16/base/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint16/base/test/test.js
@@ -29,12 +29,12 @@ var ns = require( './../lib' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ns, 'object', 'main export is an object' );
+	t.strictEqual( typeof ns, 'object', 'main export is an object' );
 	t.end();
 });
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint16/base/to-binary-string/test/test.js b/lib/node_modules/@stdlib/number/uint16/base/to-binary-string/test/test.js
index 3f6a3912d592..89ac0be39697 100644
--- a/lib/node_modules/@stdlib/number/uint16/base/to-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint16/base/to-binary-string/test/test.js
@@ -34,7 +34,7 @@ var data = require( './fixtures/julia/data.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof toBinaryString, 'function', 'main export is a function' );
+	t.strictEqual( typeof toBinaryString, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -43,7 +43,7 @@ tape( 'the function returns a literal 16-bit unsigned integer representation for
 
 	expected = '0000000000000000';
 
-	t.equal( toBinaryString(0), expected, 'returns bit literal for 0' );
+	t.strictEqual( toBinaryString(0), expected, 'returns bit literal for 0' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'the function returns a literal 16-bit unsigned integer representation for
 
 	expected = '1111111111111111';
 
-	t.equal( toBinaryString(MAX_UINT16), expected, 'returns bit literal for MAX_UINT16' );
+	t.strictEqual( toBinaryString(MAX_UINT16), expected, 'returns bit literal for MAX_UINT16' );
 	t.end();
 });
 
@@ -66,7 +66,7 @@ tape( 'the function returns literal bit representations for unsigned 16-bit inte
 	expected = data.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		str = toBinaryString( x[ i ] );
-		t.equal( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
+		t.strictEqual( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
 	}
 	t.end();
 });
@@ -91,8 +91,8 @@ tape( 'the function will accept floating-point values, but will interpret the va
 
 	for ( i = 0; i < values.length; i++ ) {
 		str = toBinaryString( values[i] );
-		t.equal( typeof str, 'string', 'returns a string' );
-		t.equal( str.length, 16, 'returns a string of length 16' );
+		t.strictEqual( typeof str, 'string', 'returns a string' );
+		t.strictEqual( str.length, 16, 'returns a string of length 16' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint16/test/test.js b/lib/node_modules/@stdlib/number/uint16/test/test.js
index 14dda1f7d171..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/number/uint16/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint16/test/test.js
@@ -29,12 +29,12 @@ var ns = require( './../lib' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ns, 'object', 'main export is an object' );
+	t.strictEqual( typeof ns, 'object', 'main export is an object' );
 	t.end();
 });
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint32/base/identity/test/test.js b/lib/node_modules/@stdlib/number/uint32/base/identity/test/test.js
index a602adf14e6c..6b5dee22f682 100644
--- a/lib/node_modules/@stdlib/number/uint32/base/identity/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint32/base/identity/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a number', function test( t ) {
-	t.equal( identity( 2 ), 2, 'returns expected value' );
-	t.equal( identity( 3 ), 3, 'returns expected value' );
+	t.strictEqual( identity( 2 ), 2, 'returns expected value' );
+	t.strictEqual( identity( 3 ), 3, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint32/base/identity/test/test.native.js b/lib/node_modules/@stdlib/number/uint32/base/identity/test/test.native.js
index 4883a87af20c..681b79cd2ad8 100644
--- a/lib/node_modules/@stdlib/number/uint32/base/identity/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/uint32/base/identity/test/test.native.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a number', opts, function test( t ) {
-	t.equal( identity( 2 ), 2, 'returns expected value' );
-	t.equal( identity( 3 ), 3, 'returns expected value' );
+	t.strictEqual( identity( 2 ), 2, 'returns expected value' );
+	t.strictEqual( identity( 3 ), 3, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint32/base/muldw/test/test.assign.js b/lib/node_modules/@stdlib/number/uint32/base/muldw/test/test.assign.js
index f5b11b01e8a7..084332c020a0 100644
--- a/lib/node_modules/@stdlib/number/uint32/base/muldw/test/test.assign.js
+++ b/lib/node_modules/@stdlib/number/uint32/base/muldw/test/test.assign.js
@@ -45,19 +45,19 @@ tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 
 	out = [ 0, 0 ];
 	v = umuldw( NaN, 1, out, 1, 0 );
-	t.equal( v, out, 'returns output array' );
+	t.strictEqual( v, out, 'returns output array' );
 	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
 	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 
 	out = [ 0, 0 ];
 	v = umuldw( 1, NaN, out, 1, 0 );
-	t.equal( v, out, 'returns output array' );
+	t.strictEqual( v, out, 'returns output array' );
 	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
 	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 
 	out = [ 0, 0 ];
 	v = umuldw( NaN, NaN, out, 1, 0 );
-	t.equal( v, out, 'returns output array' );
+	t.strictEqual( v, out, 'returns output array' );
 	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
 	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 
@@ -78,7 +78,7 @@ tape( 'the function computes the double word product of two (unsigned) words', f
 	for ( i = 0; i < expected.length; i++ ) {
 		out = [ 0, 0 ];
 		actual = umuldw( a[ i ], b[ i ], out, 1, 0 );
-		t.equal( actual, out, 'returns output array' );
+		t.strictEqual( actual, out, 'returns output array' );
 		t.deepEqual( actual, expected[ i ], 'returns expected value. a: '+a[i]+'. b: '+b[i]+'. expected: ['+expected[i].join(',')+']');
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/uint32/base/test/test.js b/lib/node_modules/@stdlib/number/uint32/base/test/test.js
index 14dda1f7d171..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/number/uint32/base/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint32/base/test/test.js
@@ -29,12 +29,12 @@ var ns = require( './../lib' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ns, 'object', 'main export is an object' );
+	t.strictEqual( typeof ns, 'object', 'main export is an object' );
 	t.end();
 });
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint32/base/to-binary-string/test/test.js b/lib/node_modules/@stdlib/number/uint32/base/to-binary-string/test/test.js
index e470cf0849b0..d03280829a05 100644
--- a/lib/node_modules/@stdlib/number/uint32/base/to-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint32/base/to-binary-string/test/test.js
@@ -36,7 +36,7 @@ var large = require( './fixtures/julia/large.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof toBinaryString, 'function', 'main export is a function' );
+	t.strictEqual( typeof toBinaryString, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -45,7 +45,7 @@ tape( 'the function returns a literal 32-bit unsigned integer representation for
 
 	expected = '00000000000000000000000000000000';
 
-	t.equal( toBinaryString(0), expected, 'returns bit literal for 0' );
+	t.strictEqual( toBinaryString(0), expected, 'returns bit literal for 0' );
 	t.end();
 });
 
@@ -54,7 +54,7 @@ tape( 'the function returns a literal 32-bit unsigned integer representation for
 
 	expected = '11111111111111111111111111111111';
 
-	t.equal( toBinaryString(MAX_UINT32), expected, 'returns bit literal for MAX_UINT32' );
+	t.strictEqual( toBinaryString(MAX_UINT32), expected, 'returns bit literal for MAX_UINT32' );
 	t.end();
 });
 
@@ -68,7 +68,7 @@ tape( 'the function returns literal bit representations for unsigned 32-bit inte
 	expected = small.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		str = toBinaryString( x[ i ] );
-		t.equal( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
+		t.strictEqual( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
 	}
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns literal bit representations for unsigned 32-bit inte
 	expected = medium.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		str = toBinaryString( x[ i ] );
-		t.equal( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
+		t.strictEqual( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns literal bit representations for unsigned 32-bit inte
 	expected = large.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		str = toBinaryString( x[ i ] );
-		t.equal( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
+		t.strictEqual( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
 	}
 	t.end();
 });
@@ -123,8 +123,8 @@ tape( 'the function will accept floating-point values, but will interpret the va
 
 	for ( i = 0; i < values.length; i++ ) {
 		str = toBinaryString( values[i] );
-		t.equal( typeof str, 'string', 'returns a string' );
-		t.equal( str.length, 32, 'returns a string of length 32' );
+		t.strictEqual( typeof str, 'string', 'returns a string' );
+		t.strictEqual( str.length, 32, 'returns a string of length 32' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint32/base/to-int32/test/test.js b/lib/node_modules/@stdlib/number/uint32/base/to-int32/test/test.js
index 914b26ef0592..bcbeadfade9c 100644
--- a/lib/node_modules/@stdlib/number/uint32/base/to-int32/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint32/base/to-int32/test/test.js
@@ -33,7 +33,7 @@ var data = require( './fixtures/julia/data.json' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof uint32ToInt32, 'function', 'main export is a function' );
+	t.strictEqual( typeof uint32ToInt32, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -47,7 +47,7 @@ tape( 'the function converts unsigned 32-bit integers to signed 32-bit integers'
 	expected = data.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		y = uint32ToInt32( x[ i ] );
-		t.equal( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
+		t.strictEqual( y, expected[ i ], 'y: '+y+', expected: '+expected[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint32/test/test.js b/lib/node_modules/@stdlib/number/uint32/test/test.js
index 14dda1f7d171..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/number/uint32/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint32/test/test.js
@@ -29,12 +29,12 @@ var ns = require( './../lib' );
 
 tape( 'main export is an object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( typeof ns, 'object', 'main export is an object' );
+	t.strictEqual( typeof ns, 'object', 'main export is an object' );
 	t.end();
 });
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint8/base/identity/test/test.js b/lib/node_modules/@stdlib/number/uint8/base/identity/test/test.js
index a602adf14e6c..6b5dee22f682 100644
--- a/lib/node_modules/@stdlib/number/uint8/base/identity/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint8/base/identity/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a number', function test( t ) {
-	t.equal( identity( 2 ), 2, 'returns expected value' );
-	t.equal( identity( 3 ), 3, 'returns expected value' );
+	t.strictEqual( identity( 2 ), 2, 'returns expected value' );
+	t.strictEqual( identity( 3 ), 3, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint8/base/identity/test/test.native.js b/lib/node_modules/@stdlib/number/uint8/base/identity/test/test.native.js
index 4883a87af20c..681b79cd2ad8 100644
--- a/lib/node_modules/@stdlib/number/uint8/base/identity/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/uint8/base/identity/test/test.native.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function evaluates the identity function when provided a number', opts, function test( t ) {
-	t.equal( identity( 2 ), 2, 'returns expected value' );
-	t.equal( identity( 3 ), 3, 'returns expected value' );
+	t.strictEqual( identity( 2 ), 2, 'returns expected value' );
+	t.strictEqual( identity( 3 ), 3, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint8/base/test/test.js b/lib/node_modules/@stdlib/number/uint8/base/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/number/uint8/base/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint8/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint8/base/to-binary-string/test/test.js b/lib/node_modules/@stdlib/number/uint8/base/to-binary-string/test/test.js
index 180d99cb4a1e..8ec08c8661d6 100644
--- a/lib/node_modules/@stdlib/number/uint8/base/to-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint8/base/to-binary-string/test/test.js
@@ -43,7 +43,7 @@ tape( 'the function returns a literal 8-bit unsigned integer representation for
 
 	expected = '00000000';
 
-	t.equal( bits(0), expected, 'returns bit literal for 0' );
+	t.strictEqual( bits(0), expected, 'returns bit literal for 0' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'the function returns a literal 8-bit unsigned integer representation for
 
 	expected = '11111111';
 
-	t.equal( bits(MAX_UINT8), expected, 'returns bit literal for MAX_UINT8' );
+	t.strictEqual( bits(MAX_UINT8), expected, 'returns bit literal for MAX_UINT8' );
 	t.end();
 });
 
@@ -66,7 +66,7 @@ tape( 'the function returns literal bit representations for unsigned 8-bit integ
 	expected = data.expected;
 	for ( i = 0; i < x.length; i++ ) {
 		str = bits( x[ i ] );
-		t.equal( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
+		t.strictEqual( str, expected[ i ], 'returns bit literal for ' + x[ i ] );
 	}
 	t.end();
 });
@@ -91,8 +91,8 @@ tape( 'the function will accept floating-point values, but will interpret the va
 
 	for ( i = 0; i < values.length; i++ ) {
 		str = bits( values[i] );
-		t.equal( typeof str, 'string', 'returns a string' );
-		t.equal( str.length, 8, 'returns a string of length 8' );
+		t.strictEqual( typeof str, 'string', 'returns a string' );
+		t.strictEqual( str.length, 8, 'returns a string of length 8' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/uint8/test/test.js b/lib/node_modules/@stdlib/number/uint8/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/number/uint8/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint8/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });

From c894b664661bfb87286304b24dd5a1758ae482b7 Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Thu, 14 Aug 2025 13:52:09 -0500
Subject: [PATCH 12/32] test: use .strictEqual() instead of .equal() and fix
 lint errors

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../datasets/afinn-96/test/test.browser.js    |  10 +-
 .../test/test.browser.js                      |   6 +-
 .../berndt-cps-wages-1985/test/test.js        |   6 +-
 .../test/test.browser.js                      |   6 +-
 .../cdc-nchs-us-births-1969-1988/test/test.js |   6 +-
 .../test/test.browser.js                      |   6 +-
 .../cdc-nchs-us-births-1994-2003/test/test.js |   6 +-
 .../test/test.browser.js                      |  16 +-
 .../test/test.js                              |  16 +-
 .../datasets/cmudict/test/test.browser.js     |  28 +--
 .../@stdlib/datasets/cmudict/test/test.js     |  28 +--
 .../datasets/cmudict/test/test.validate.js    |   6 +-
 .../emoji-code-picto/test/test.browser.js     |   8 +-
 .../datasets/emoji-code-picto/test/test.js    |   8 +-
 .../emoji-picto-code/test/test.browser.js     |   4 +-
 .../datasets/emoji-picto-code/test/test.js    |   4 +-
 .../datasets/emoji/test/test.browser.js       |   6 +-
 .../@stdlib/datasets/emoji/test/test.js       |   6 +-
 .../test/test.browser.js                      |   6 +-
 .../female-first-names-en/test/test.js        |   6 +-
 .../fivethirtyeight-ffq/test/test.browser.js  |   6 +-
 .../datasets/fivethirtyeight-ffq/test/test.js |   6 +-
 .../frb-sf-wage-rigidity/test/test.browser.js |   6 +-
 .../frb-sf-wage-rigidity/test/test.js         |   6 +-
 .../img-acanthus-mollis/test/test.browser.js  |   2 +-
 .../datasets/img-acanthus-mollis/test/test.js |   2 +-
 .../test/test.browser.js                      |   2 +-
 .../img-airplane-from-above/test/test.js      |   2 +-
 .../test/test.browser.js                      |   2 +-
 .../img-allium-oreophilum/test/test.js        |   2 +-
 .../img-black-canyon/test/test.browser.js     |   2 +-
 .../datasets/img-black-canyon/test/test.js    |   2 +-
 .../img-dust-bowl-home/test/test.browser.js   |   2 +-
 .../datasets/img-dust-bowl-home/test/test.js  |   2 +-
 .../test/test.browser.js                      |   2 +-
 .../img-french-alpine-landscape/test/test.js  |   2 +-
 .../test/test.browser.js                      |   2 +-
 .../img-locomotion-house-cat/test/test.js     |   2 +-
 .../test/test.browser.js                      |   2 +-
 .../img-locomotion-nude-male/test/test.js     |   2 +-
 .../img-march-pastoral/test/test.browser.js   |   2 +-
 .../datasets/img-march-pastoral/test/test.js  |   2 +-
 .../img-nagasaki-boats/test/test.browser.js   |   2 +-
 .../datasets/img-nagasaki-boats/test/test.js  |   2 +-
 .../test/test.browser.js                      |   6 +-
 .../test/test.js                              |   6 +-
 .../test/test.browser.js                      |   6 +-
 .../test/test.js                              |   6 +-
 .../male-first-names-en/test/test.browser.js  |   6 +-
 .../datasets/male-first-names-en/test/test.js |   6 +-
 .../test/test.browser.js                      |  34 ++--
 .../minard-napoleons-march/test/test.js       |  34 ++--
 .../test/test.validate.js                     |   6 +-
 .../month-names-en/test/test.browser.js       |   8 +-
 .../datasets/month-names-en/test/test.js      |   8 +-
 .../nightingales-rose/test/test.browser.js    |   6 +-
 .../datasets/nightingales-rose/test/test.js   |   6 +-
 .../datasets/primes-100k/test/test.browser.js |   8 +-
 .../@stdlib/datasets/primes-100k/test/test.js |   8 +-
 .../savoy-stopwords-fin/test/test.browser.js  |   6 +-
 .../datasets/savoy-stopwords-fin/test/test.js |   6 +-
 .../savoy-stopwords-fr/test/test.browser.js   |   6 +-
 .../datasets/savoy-stopwords-fr/test/test.js  |   6 +-
 .../savoy-stopwords-ger/test/test.browser.js  |   6 +-
 .../datasets/savoy-stopwords-ger/test/test.js |   6 +-
 .../savoy-stopwords-it/test/test.browser.js   |   6 +-
 .../datasets/savoy-stopwords-it/test/test.js  |   6 +-
 .../savoy-stopwords-por/test/test.browser.js  |   6 +-
 .../datasets/savoy-stopwords-por/test/test.js |   6 +-
 .../savoy-stopwords-sp/test/test.browser.js   |   6 +-
 .../datasets/savoy-stopwords-sp/test/test.js  |   6 +-
 .../savoy-stopwords-swe/test/test.browser.js  |   6 +-
 .../datasets/savoy-stopwords-swe/test/test.js |   6 +-
 .../datasets/sotu/test/test.browser_db.js     |   4 +-
 .../sotu/test/test.browser_file_list.js       |   4 +-
 .../sotu/test/test.browser_get_file.js        |   2 +-
 .../@stdlib/datasets/sotu/test/test.db.js     |   6 +-
 .../datasets/sotu/test/test.file_list.js      |   6 +-
 .../datasets/sotu/test/test.get_file.js       |  11 +-
 .../datasets/sotu/test/test.index_name.js     |   4 +-
 .../datasets/sotu/test/test.index_party.js    |   4 +-
 .../datasets/sotu/test/test.index_year.js     |   4 +-
 .../@stdlib/datasets/sotu/test/test.js        |  60 +++---
 .../datasets/sotu/test/test.re_filename.js    |  16 +-
 .../@stdlib/datasets/sotu/test/test.union.js  |   4 +-
 .../datasets/sotu/test/test.unsnakecase.js    |   2 +-
 .../datasets/sotu/test/test.validate.js       |  18 +-
 .../spache-revised/test/test.browser.js       |   6 +-
 .../datasets/spache-revised/test/test.js      |   6 +-
 .../test/test.browser.js                      |   6 +-
 .../ssa-us-births-2000-2014/test/test.js      |   6 +-
 .../standard-card-deck/test/test.browser.js   |   8 +-
 .../datasets/standard-card-deck/test/test.js  |   8 +-
 .../stopwords-en/test/test.browser.js         |   6 +-
 .../datasets/stopwords-en/test/test.js        |   6 +-
 .../test/test.browser.js                      |   6 +-
 .../test/test.js                              |   6 +-
 .../test/test.browser.js                      |   6 +-
 .../test/test.js                              |   6 +-
 .../@stdlib/datasets/test/test.js             |   6 +-
 .../us-states-abbr/test/test.browser.js       |   8 +-
 .../datasets/us-states-abbr/test/test.js      |   8 +-
 .../test/test.browser.js                      |  10 +-
 .../us-states-capitals-names/test/test.js     |  10 +-
 .../us-states-capitals/test/test.browser.js   |   8 +-
 .../datasets/us-states-capitals/test/test.js  |   8 +-
 .../test/test.browser.js                      |  10 +-
 .../us-states-names-capitals/test/test.js     |  10 +-
 .../us-states-names/test/test.browser.js      |   8 +-
 .../datasets/us-states-names/test/test.js     |   8 +-
 .../@stdlib/fs/exists/test/test.async.js      |  20 +-
 .../@stdlib/fs/exists/test/test.js            |   2 +-
 .../@stdlib/fs/exists/test/test.sync.js       |   8 +-
 lib/node_modules/@stdlib/fs/open/test/test.js |   2 +-
 .../@stdlib/fs/open/test/test.main.js         |  12 +-
 .../@stdlib/fs/open/test/test.sync.js         |  12 +-
 .../@stdlib/fs/read-dir/test/test.async.js    |   2 +-
 .../@stdlib/fs/read-dir/test/test.js          |   2 +-
 .../@stdlib/fs/read-dir/test/test.sync.js     |   2 +-
 .../fs/read-file-list/test/test.async.js      |   6 +-
 .../read-file-list/test/test.clear_pending.js |   2 +-
 .../@stdlib/fs/read-file-list/test/test.js    |   2 +-
 .../fs/read-file-list/test/test.sync.js       |   6 +-
 .../@stdlib/fs/read-file/test/test.js         |   2 +-
 .../@stdlib/fs/read-file/test/test.main.js    |   6 +-
 .../@stdlib/fs/read-file/test/test.sync.js    |   6 +-
 .../fs/resolve-parent-path-by/test/test.js    |   2 +-
 .../test/test.validate.js                     |  10 +-
 .../fs/resolve-parent-path/test/test.js       |   2 +-
 .../resolve-parent-path/test/test.validate.js |  10 +-
 .../fs/resolve-parent-paths/test/test.js      |   2 +-
 .../test/test.validate.js                     |  14 +-
 lib/node_modules/@stdlib/fs/test/test.js      |   2 +-
 .../@stdlib/iter/concat/test/test.js          |  64 +++---
 .../@stdlib/iter/constant/test/test.js        |  54 ++---
 .../@stdlib/iter/counter/test/test.js         |  52 ++---
 .../@stdlib/iter/cuany-by/test/test.js        |  58 +++---
 .../@stdlib/iter/cuany/test/test.js           |  54 ++---
 .../@stdlib/iter/cuevery-by/test/test.js      |  58 +++---
 .../@stdlib/iter/cuevery/test/test.js         |  54 ++---
 .../@stdlib/iter/cunone-by/test/test.js       |  58 +++---
 .../@stdlib/iter/cunone/test/test.js          |  54 ++---
 .../@stdlib/iter/cusome-by/test/test.js       |  78 +++----
 .../@stdlib/iter/cusome/test/test.js          |  54 ++---
 .../@stdlib/iter/datespace/test/test.js       | 132 ++++++------
 .../@stdlib/iter/dedupe-by/test/test.js       |  70 +++----
 .../@stdlib/iter/dedupe/test/test.js          |  60 +++---
 .../@stdlib/iter/do-until-each/test/test.js   |  98 ++++-----
 .../@stdlib/iter/do-while-each/test/test.js   |  98 ++++-----
 .../@stdlib/iter/empty/test/test.js           |  54 ++---
 .../@stdlib/iter/fill/test/test.js            |  90 ++++-----
 .../@stdlib/iter/filter-map/test/test.js      |  64 +++---
 .../@stdlib/iter/filter/test/test.js          |  64 +++---
 .../@stdlib/iter/flow/test/test.js            |  74 +++----
 .../@stdlib/iter/for-each/test/test.js        |  98 ++++-----
 .../@stdlib/iter/head/test/test.js            |  62 +++---
 .../@stdlib/iter/incrspace/test/test.js       |  50 ++---
 .../iter/intersection-by-hash/test/test.js    |  62 +++---
 .../@stdlib/iter/intersection/test/test.js    |  56 +++---
 .../@stdlib/iter/linspace/test/test.js        |  52 ++---
 .../@stdlib/iter/logspace/test/test.js        |  56 +++---
 .../@stdlib/iter/map/test/test.js             |  74 +++----
 .../@stdlib/iter/mapn/test/test.js            |  78 +++----
 .../@stdlib/iter/pop/test/test.js             |  72 +++----
 .../@stdlib/iter/push/test/test.js            |  62 +++---
 .../@stdlib/iter/reject/test/test.js          |  64 +++---
 .../@stdlib/iter/replicate-by/test/test.js    |  72 +++----
 .../@stdlib/iter/replicate/test/test.js       |  58 +++---
 .../@stdlib/iter/shift/test/test.js           |  72 +++----
 .../@stdlib/iter/slice/test/test.js           |  98 ++++-----
 .../@stdlib/iter/step/test/test.js            |  50 ++---
 .../@stdlib/iter/strided-by/test/test.js      | 144 ++++++-------
 .../@stdlib/iter/strided/test/test.js         | 132 ++++++------
 lib/node_modules/@stdlib/iter/test/test.js    |   2 +-
 .../iter/to-array-view-right/test/test.js     |  64 +++---
 .../@stdlib/iter/to-array-view/test/test.js   |  64 +++---
 .../@stdlib/iter/union/test/test.js           |  62 +++---
 .../@stdlib/iter/unique-by-hash/test/test.js  |  66 +++---
 .../@stdlib/iter/unique-by/test/test.js       |  66 +++---
 .../@stdlib/iter/unique/test/test.js          |  60 +++---
 .../@stdlib/iter/unitspace/test/test.js       |  50 ++---
 .../@stdlib/iter/unshift/test/test.js         |  62 +++---
 .../@stdlib/iter/until-each/test/test.js      |  98 ++++-----
 .../@stdlib/iter/while-each/test/test.js      |  98 ++++-----
 .../test/test.validate.js                     |  20 +-
 .../ml/incr/sgd-regression/test/test.dot.js   |   2 +-
 .../sgd-regression/test/test.eta_factory.js   |  18 +-
 .../ml/incr/sgd-regression/test/test.main.js  |   6 +-
 .../incr/sgd-regression/test/test.validate.js |  16 +-
 .../sgd-regression/test/test.weight_vector.js |  16 +-
 lib/node_modules/@stdlib/ml/incr/test/test.js |   2 +-
 lib/node_modules/@stdlib/ml/test/test.js      |   2 +-
 .../@stdlib/ndarray/iter/test/test.js         |   2 +-
 .../ndarray/iter/to-array-each/test/test.js   |   2 +-
 lib/node_modules/@stdlib/proxy/test/test.js   |   2 +-
 .../@stdlib/simulate/iter/awgn/test/test.js   | 152 +++++++-------
 .../@stdlib/simulate/iter/awln/test/test.js   | 152 +++++++-------
 .../@stdlib/simulate/iter/awun/test/test.js   | 152 +++++++-------
 .../iter/bartlett-hann-pulse/test/test.js     | 122 +++++------
 .../simulate/iter/bartlett-pulse/test/test.js | 122 +++++------
 .../simulate/iter/cosine-wave/test/test.js    | 104 +++++-----
 .../simulate/iter/dirac-comb/test/test.js     |  60 +++---
 .../simulate/iter/flat-top-pulse/test/test.js | 122 +++++------
 .../simulate/iter/hann-pulse/test/test.js     | 122 +++++------
 .../simulate/iter/lanczos-pulse/test/test.js  | 122 +++++------
 .../simulate/iter/periodic-sinc/test/test.js  | 190 +++++++++---------
 .../@stdlib/simulate/iter/pulse/test/test.js  |  64 +++---
 .../simulate/iter/sawtooth-wave/test/test.js  | 110 +++++-----
 .../simulate/iter/sine-wave/test/test.js      | 104 +++++-----
 .../simulate/iter/square-wave/test/test.js    |  62 +++---
 .../@stdlib/simulate/iter/test/test.js        |   2 +-
 .../simulate/iter/triangle-wave/test/test.js  | 110 +++++-----
 .../node/debug-sink/test/test.factory.js      |  10 +-
 .../streams/node/debug-sink/test/test.js      |   4 +-
 .../streams/node/debug-sink/test/test.main.js |  28 +--
 .../node/debug-sink/test/test.object_mode.js  |   2 +-
 .../node/debug-sink/test/test.validate.js     |  14 +-
 .../streams/node/debug/test/test.factory.js   |  10 +-
 .../@stdlib/streams/node/debug/test/test.js   |   4 +-
 .../streams/node/debug/test/test.main.js      |  26 +--
 .../node/debug/test/test.object_mode.js       |   2 +-
 .../streams/node/debug/test/test.validate.js  |  14 +-
 .../streams/node/empty/test/test.factory.js   |   8 +-
 .../@stdlib/streams/node/empty/test/test.js   |   4 +-
 .../streams/node/empty/test/test.main.js      |  10 +-
 .../node/empty/test/test.object_mode.js       |   2 +-
 .../streams/node/empty/test/test.validate.js  |   8 +-
 .../node/from-array/test/test.factory.js      |   8 +-
 .../streams/node/from-array/test/test.js      |   4 +-
 .../streams/node/from-array/test/test.main.js |  66 +++---
 .../node/from-array/test/test.object_mode.js  |   8 +-
 .../node/from-array/test/test.validate.js     |  18 +-
 .../from-circular-array/test/test.factory.js  |   8 +-
 .../node/from-circular-array/test/test.js     |   4 +-
 .../from-circular-array/test/test.main.js     |  66 +++---
 .../test/test.object_mode.js                  |   8 +-
 .../from-circular-array/test/test.validate.js |  20 +-
 .../node/from-constant/test/test.factory.js   |  18 +-
 .../streams/node/from-constant/test/test.js   |   4 +-
 .../node/from-constant/test/test.main.js      |  42 ++--
 .../from-constant/test/test.object_mode.js    |   8 +-
 .../node/from-constant/test/test.validate.js  |  16 +-
 .../node/from-iterator/test/test.factory.js   |   8 +-
 .../streams/node/from-iterator/test/test.js   |   4 +-
 .../node/from-iterator/test/test.main.js      |  96 ++++-----
 .../from-iterator/test/test.object_mode.js    |   8 +-
 .../node/from-iterator/test/test.validate.js  |  16 +-
 .../from-strided-array/test/test.factory.js   |   8 +-
 .../node/from-strided-array/test/test.js      |   4 +-
 .../node/from-strided-array/test/test.main.js |  58 +++---
 .../test/test.object_mode.js                  |   8 +-
 .../from-strided-array/test/test.validate.js  |  16 +-
 .../node/inspect-sink/test/test.factory.js    |   6 +-
 .../streams/node/inspect-sink/test/test.js    |   4 +-
 .../node/inspect-sink/test/test.main.js       |  18 +-
 .../inspect-sink/test/test.object_mode.js     |   2 +-
 .../node/inspect-sink/test/test.validate.js   |  12 +-
 .../streams/node/inspect/test/test.factory.js |   6 +-
 .../@stdlib/streams/node/inspect/test/test.js |   4 +-
 .../streams/node/inspect/test/test.main.js    |  16 +-
 .../node/inspect/test/test.object_mode.js     |   2 +-
 .../node/inspect/test/test.validate.js        |  12 +-
 .../streams/node/join/test/test.factory.js    |   6 +-
 .../@stdlib/streams/node/join/test/test.js    |   4 +-
 .../streams/node/join/test/test.main.js       |  14 +-
 .../node/join/test/test.object_mode.js        |   2 +-
 .../streams/node/join/test/test.validate.js   |  16 +-
 .../streams/node/split/test/test.decode.js    |   8 +-
 .../streams/node/split/test/test.factory.js   |   6 +-
 .../@stdlib/streams/node/split/test/test.js   |   4 +-
 .../streams/node/split/test/test.main.js      |   8 +-
 .../node/split/test/test.object_mode.js       |   2 +-
 .../streams/node/split/test/test.validate.js  |  16 +-
 .../@stdlib/streams/node/stderr/test/test.js  |   2 +-
 .../@stdlib/streams/node/stdin/test/test.js   |   2 +-
 .../@stdlib/streams/node/stdout/test/test.js  |   2 +-
 .../@stdlib/streams/node/test/test.js         |   2 +-
 .../streams/node/transform/test/test.ctor.js  |  16 +-
 .../node/transform/test/test.factory.js       |  10 +-
 .../streams/node/transform/test/test.js       |   6 +-
 .../streams/node/transform/test/test.main.js  |  16 +-
 .../node/transform/test/test.object_mode.js   |   4 +-
 .../node/transform/test/test.validate.js      |  18 +-
 lib/node_modules/@stdlib/streams/test/test.js |   2 +-
 284 files changed, 3682 insertions(+), 3681 deletions(-)

diff --git a/lib/node_modules/@stdlib/datasets/afinn-96/test/test.browser.js b/lib/node_modules/@stdlib/datasets/afinn-96/test/test.browser.js
index b66a684c5bce..980322fe89c9 100644
--- a/lib/node_modules/@stdlib/datasets/afinn-96/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/afinn-96/test/test.browser.js
@@ -37,10 +37,10 @@ tape( 'the function returns an array of 2-element arrays', function test( t ) {
 	var list;
 	var i;
 	list = afinn96();
-	t.equal( isArray( list ), true, 'returns an array' );
+	t.strictEqual( isArray( list ), true, 'returns an array' );
 	for ( i = 0; i < list.length; i++ ) {
-		t.equal( isArray( list[i] ), true, 'element '+i+' is an array' );
-		t.equal( list[i].length, 2, 'element '+i+' is a 2-element array' );
+		t.strictEqual( isArray( list[i] ), true, 'element '+i+' is an array' );
+		t.strictEqual( list[i].length, 2, 'element '+i+' is a 2-element array' );
 	}
 	t.end();
 });
@@ -58,9 +58,9 @@ tape( 'the function returns a deep copy', function test( t ) {
 	v = d2[ 5 ][ 0 ];
 	d1[ 5 ][ 0 ] = 'beep';
 
-	t.equal( d1[ 5 ][ 0 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ][ 0 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ][ 0 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ][ 0 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/berndt-cps-wages-1985/test/test.browser.js b/lib/node_modules/@stdlib/datasets/berndt-cps-wages-1985/test/test.browser.js
index 997b160009d2..51efa3459dff 100644
--- a/lib/node_modules/@stdlib/datasets/berndt-cps-wages-1985/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/berndt-cps-wages-1985/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'returns an array of objects' );
+	t.strictEqual( isObjectArray( data ), true, 'returns an array of objects' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ].education;
 	d1[ 5 ].education = 'beep';
 
-	t.equal( d1[ 5 ].education, 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ].education, 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ].education, v, 'expected element' );
+	t.strictEqual( d2[ 5 ].education, v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/berndt-cps-wages-1985/test/test.js b/lib/node_modules/@stdlib/datasets/berndt-cps-wages-1985/test/test.js
index bceb815b8bde..8aa6543ffe13 100644
--- a/lib/node_modules/@stdlib/datasets/berndt-cps-wages-1985/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/berndt-cps-wages-1985/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', opts, function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'returns an array of objects' );
+	t.strictEqual( isObjectArray( data ), true, 'returns an array of objects' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ].education;
 	d1[ 5 ].education = 'beep';
 
-	t.equal( d1[ 5 ].education, 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ].education, 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ].education, v, 'expected element' );
+	t.strictEqual( d2[ 5 ].education, v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1969-1988/test/test.browser.js b/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1969-1988/test/test.browser.js
index 95fbecf919fa..655d022b6138 100644
--- a/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1969-1988/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1969-1988/test/test.browser.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'returns expected value' );
-	t.equal( data.length > 0, true, 'is not empty' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
+	t.strictEqual( data.length > 0, true, 'is not empty' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns a copy', function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1969-1988/test/test.js b/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1969-1988/test/test.js
index 90758183742a..8f39c553d30f 100644
--- a/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1969-1988/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1969-1988/test/test.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array', opts, function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'returns expected value' );
-	t.equal( data.length > 0, true, 'is not empty' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
+	t.strictEqual( data.length > 0, true, 'is not empty' );
 	t.end();
 });
 
@@ -59,7 +59,7 @@ tape( 'the function returns a copy', opts, function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1994-2003/test/test.browser.js b/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1994-2003/test/test.browser.js
index 95fbecf919fa..655d022b6138 100644
--- a/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1994-2003/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1994-2003/test/test.browser.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'returns expected value' );
-	t.equal( data.length > 0, true, 'is not empty' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
+	t.strictEqual( data.length > 0, true, 'is not empty' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns a copy', function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1994-2003/test/test.js b/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1994-2003/test/test.js
index 90758183742a..8f39c553d30f 100644
--- a/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1994-2003/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/cdc-nchs-us-births-1994-2003/test/test.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array', opts, function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'returns expected value' );
-	t.equal( data.length > 0, true, 'is not empty' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
+	t.strictEqual( data.length > 0, true, 'is not empty' );
 	t.end();
 });
 
@@ -59,7 +59,7 @@ tape( 'the function returns a copy', opts, function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013/test/test.browser.js b/lib/node_modules/@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013/test/test.browser.js
index 3f171b044183..39ab61996499 100644
--- a/lib/node_modules/@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013/test/test.browser.js
@@ -38,16 +38,16 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns an object containing arrays', function test( t ) {
 	var data = dataset();
 
-	t.equal( isPlainObject( data ), true, 'is an object' );
+	t.strictEqual( isPlainObject( data ), true, 'is an object' );
 
-	t.equal( hasOwnProp( data, 'black' ), true, 'has property' );
-	t.equal( hasOwnProp( data, 'white' ), true, 'has property' );
+	t.strictEqual( hasOwnProp( data, 'black' ), true, 'has property' );
+	t.strictEqual( hasOwnProp( data, 'white' ), true, 'has property' );
 
-	t.equal( isArray( data.black ), true, 'returns expected value' );
-	t.equal( data.black.length > 0, true, 'is not empty' );
+	t.strictEqual( isArray( data.black ), true, 'returns expected value' );
+	t.strictEqual( data.black.length > 0, true, 'is not empty' );
 
-	t.equal( isArray( data.white ), true, 'returns expected value' );
-	t.equal( data.white.length > 0, true, 'is not empty' );
+	t.strictEqual( isArray( data.white ), true, 'returns expected value' );
+	t.strictEqual( data.white.length > 0, true, 'is not empty' );
 	t.end();
 });
 
@@ -62,7 +62,7 @@ tape( 'the function returns a copy', function test( t ) {
 
 	l1.black[ 5 ] = 'beep';
 
-	t.equal( l1.black[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1.black[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1.black[ 5 ], l2.black[ 5 ], 'no shared state' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013/test/test.js b/lib/node_modules/@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013/test/test.js
index 8d8b31aa2595..3f4341e075d2 100644
--- a/lib/node_modules/@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/cdc-nchs-us-infant-mortality-bw-1915-2013/test/test.js
@@ -46,16 +46,16 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns an object containing arrays', opts, function test( t ) {
 	var data = dataset();
 
-	t.equal( isPlainObject( data ), true, 'is an object' );
+	t.strictEqual( isPlainObject( data ), true, 'is an object' );
 
-	t.equal( hasOwnProp( data, 'black' ), true, 'has property' );
-	t.equal( hasOwnProp( data, 'white' ), true, 'has property' );
+	t.strictEqual( hasOwnProp( data, 'black' ), true, 'has property' );
+	t.strictEqual( hasOwnProp( data, 'white' ), true, 'has property' );
 
-	t.equal( isArray( data.black ), true, 'returns expected value' );
-	t.equal( data.black.length > 0, true, 'is not empty' );
+	t.strictEqual( isArray( data.black ), true, 'returns expected value' );
+	t.strictEqual( data.black.length > 0, true, 'is not empty' );
 
-	t.equal( isArray( data.white ), true, 'returns expected value' );
-	t.equal( data.white.length > 0, true, 'is not empty' );
+	t.strictEqual( isArray( data.white ), true, 'returns expected value' );
+	t.strictEqual( data.white.length > 0, true, 'is not empty' );
 	t.end();
 });
 
@@ -70,7 +70,7 @@ tape( 'the function returns a copy', opts, function test( t ) {
 
 	l1.black[ 5 ] = 'beep';
 
-	t.equal( l1.black[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1.black[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1.black[ 5 ], l2.black[ 5 ], 'no shared state' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/datasets/cmudict/test/test.browser.js b/lib/node_modules/@stdlib/datasets/cmudict/test/test.browser.js
index d9832343b441..a68cc5666ca5 100644
--- a/lib/node_modules/@stdlib/datasets/cmudict/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/cmudict/test/test.browser.js
@@ -107,11 +107,11 @@ tape( 'if not provided a `data` option, the function returns an `object`', funct
 	var d2;
 
 	data = cmudict();
-	t.equal( isObject( data ), true, 'returns an object' );
-	t.equal( hasOwnProp( data, 'dict' ), true, 'has `dict` property' );
-	t.equal( hasOwnProp( data, 'phones' ), true, 'has `phones` property' );
-	t.equal( hasOwnProp( data, 'symbols' ), true, 'has `symbols` property' );
-	t.equal( hasOwnProp( data, 'vp' ), true, 'has `vp` property' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( hasOwnProp( data, 'dict' ), true, 'has `dict` property' );
+	t.strictEqual( hasOwnProp( data, 'phones' ), true, 'has `phones` property' );
+	t.strictEqual( hasOwnProp( data, 'symbols' ), true, 'has `symbols` property' );
+	t.strictEqual( hasOwnProp( data, 'vp' ), true, 'has `vp` property' );
 
 	// Should return a copy...
 	d2 = cmudict();
@@ -129,11 +129,11 @@ tape( 'if not provided a `data` option, the function returns an `object` (option
 	var d2;
 
 	data = cmudict( {} );
-	t.equal( isObject( data ), true, 'returns an object' );
-	t.equal( hasOwnProp( data, 'dict' ), true, 'has `dict` property' );
-	t.equal( hasOwnProp( data, 'phones' ), true, 'has `phones` property' );
-	t.equal( hasOwnProp( data, 'symbols' ), true, 'has `symbols` property' );
-	t.equal( hasOwnProp( data, 'vp' ), true, 'has `vp` property' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( hasOwnProp( data, 'dict' ), true, 'has `dict` property' );
+	t.strictEqual( hasOwnProp( data, 'phones' ), true, 'has `phones` property' );
+	t.strictEqual( hasOwnProp( data, 'symbols' ), true, 'has `symbols` property' );
+	t.strictEqual( hasOwnProp( data, 'vp' ), true, 'has `vp` property' );
 
 	// Should return a copy...
 	d2 = cmudict( {} );
@@ -156,7 +156,7 @@ tape( 'if the `data` option is `dict`, the function returns an object', function
 	};
 	data = cmudict( opts );
 
-	t.equal( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
@@ -174,7 +174,7 @@ tape( 'if the `data` option is `phones`, the function returns an object', functi
 	};
 	data = cmudict( opts );
 
-	t.equal( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
@@ -192,7 +192,7 @@ tape( 'if the `data` option is `symbols`, the function returns an array of strin
 	};
 	data = cmudict( opts );
 
-	t.equal( isStringArray( data ), true, 'returns an array of strings' );
+	t.strictEqual( isStringArray( data ), true, 'returns an array of strings' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
@@ -210,7 +210,7 @@ tape( 'if the `data` option is `vp`, the function returns an object', function t
 	};
 	data = cmudict( opts );
 
-	t.equal( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
diff --git a/lib/node_modules/@stdlib/datasets/cmudict/test/test.js b/lib/node_modules/@stdlib/datasets/cmudict/test/test.js
index 8e37d5e5ae58..16a4cac05966 100644
--- a/lib/node_modules/@stdlib/datasets/cmudict/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/cmudict/test/test.js
@@ -115,11 +115,11 @@ tape( 'if not provided a `data` option, the function returns an `object`', opts,
 	var d2;
 
 	data = cmudict();
-	t.equal( isObject( data ), true, 'returns an object' );
-	t.equal( hasOwnProp( data, 'dict' ), true, 'has `dict` property' );
-	t.equal( hasOwnProp( data, 'phones' ), true, 'has `phones` property' );
-	t.equal( hasOwnProp( data, 'symbols' ), true, 'has `symbols` property' );
-	t.equal( hasOwnProp( data, 'vp' ), true, 'has `vp` property' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( hasOwnProp( data, 'dict' ), true, 'has `dict` property' );
+	t.strictEqual( hasOwnProp( data, 'phones' ), true, 'has `phones` property' );
+	t.strictEqual( hasOwnProp( data, 'symbols' ), true, 'has `symbols` property' );
+	t.strictEqual( hasOwnProp( data, 'vp' ), true, 'has `vp` property' );
 
 	// Should return a copy...
 	d2 = cmudict();
@@ -137,11 +137,11 @@ tape( 'if not provided a `data` option, the function returns an `object` (option
 	var d2;
 
 	data = cmudict( {} );
-	t.equal( isObject( data ), true, 'returns an object' );
-	t.equal( hasOwnProp( data, 'dict' ), true, 'has `dict` property' );
-	t.equal( hasOwnProp( data, 'phones' ), true, 'has `phones` property' );
-	t.equal( hasOwnProp( data, 'symbols' ), true, 'has `symbols` property' );
-	t.equal( hasOwnProp( data, 'vp' ), true, 'has `vp` property' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( hasOwnProp( data, 'dict' ), true, 'has `dict` property' );
+	t.strictEqual( hasOwnProp( data, 'phones' ), true, 'has `phones` property' );
+	t.strictEqual( hasOwnProp( data, 'symbols' ), true, 'has `symbols` property' );
+	t.strictEqual( hasOwnProp( data, 'vp' ), true, 'has `vp` property' );
 
 	// Should return a copy...
 	d2 = cmudict( {} );
@@ -164,7 +164,7 @@ tape( 'if the `data` option is `dict`, the function returns an object', opts, fu
 	};
 	data = cmudict( opts );
 
-	t.equal( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
@@ -182,7 +182,7 @@ tape( 'if the `data` option is `phones`, the function returns an object', opts,
 	};
 	data = cmudict( opts );
 
-	t.equal( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
@@ -200,7 +200,7 @@ tape( 'if the `data` option is `symbols`, the function returns an array of strin
 	};
 	data = cmudict( opts );
 
-	t.equal( isStringArray( data ), true, 'returns an array of strings' );
+	t.strictEqual( isStringArray( data ), true, 'returns an array of strings' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
@@ -218,7 +218,7 @@ tape( 'if the `data` option is `vp`, the function returns an object', opts, func
 	};
 	data = cmudict( opts );
 
-	t.equal( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
diff --git a/lib/node_modules/@stdlib/datasets/cmudict/test/test.validate.js b/lib/node_modules/@stdlib/datasets/cmudict/test/test.validate.js
index 88fd1cb4c43c..dd07d8d40569 100644
--- a/lib/node_modules/@stdlib/datasets/cmudict/test/test.validate.js
+++ b/lib/node_modules/@stdlib/datasets/cmudict/test/test.validate.js
@@ -75,7 +75,7 @@ tape( 'the function returns an error if provided a `data` option which is not a
 		err = validate( {}, {
 			'data': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -96,7 +96,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'sets option values' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.browser.js b/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.browser.js
index 09faefbba483..652d852410bc 100644
--- a/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.browser.js
@@ -36,19 +36,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var tbl = table();
-	t.equal( isPlainObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( tbl ), true, 'returns an object' );
 	t.end();
 });
 
 tape( 'the returned object has keys', function test( t ) {
 	var tbl = table();
-	t.equal( objectKeys( tbl ).length > 0, true, 'has keys' );
+	t.strictEqual( objectKeys( tbl ).length > 0, true, 'has keys' );
 	t.end();
 });
 
 tape( 'the returned object maps emoji codes to pictographs', function test( t ) {
 	var tbl = table();
-	t.equal( tbl[ ':smile:' ], '😄', 'returns expected value' );
-	t.equal( tbl[ ':unicorn:' ], '🦄', 'returns expected value' );
+	t.strictEqual( tbl[ ':smile:' ], '😄', 'returns expected value' );
+	t.strictEqual( tbl[ ':unicorn:' ], '🦄', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.js b/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.js
index a1c99435a93e..2d5577eafa3d 100644
--- a/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.js
@@ -44,19 +44,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', opts, function test( t ) {
 	var tbl = table();
-	t.equal( isPlainObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( tbl ), true, 'returns an object' );
 	t.end();
 });
 
 tape( 'the returned object has keys', opts, function test( t ) {
 	var tbl = table();
-	t.equal( objectKeys( tbl ).length > 0, true, 'has keys' );
+	t.strictEqual( objectKeys( tbl ).length > 0, true, 'has keys' );
 	t.end();
 });
 
 tape( 'the returned object maps emoji codes to pictographs', function test( t ) {
 	var tbl = table();
-	t.equal( tbl[ ':smile:' ], '😄', 'returns expected value' );
-	t.equal( tbl[ ':unicorn:' ], '🦄', 'returns expected value' );
+	t.strictEqual( tbl[ ':smile:' ], '😄', 'returns expected value' );
+	t.strictEqual( tbl[ ':unicorn:' ], '🦄', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.browser.js b/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.browser.js
index 3a33117fe907..4270b9f97d6b 100644
--- a/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.browser.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var tbl = table();
-	t.equal( isPlainObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( tbl ), true, 'returns an object' );
 	t.end();
 });
 
 tape( 'the returned object has keys', function test( t ) {
 	var tbl = table();
-	t.equal( objectKeys( tbl ).length > 0, true, 'has keys' );
+	t.strictEqual( objectKeys( tbl ).length > 0, true, 'has keys' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.js b/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.js
index 01e74581f3a9..b7ca8f157320 100644
--- a/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.js
@@ -44,13 +44,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', opts, function test( t ) {
 	var tbl = table();
-	t.equal( isPlainObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( tbl ), true, 'returns an object' );
 	t.end();
 });
 
 tape( 'the returned object has keys', opts, function test( t ) {
 	var tbl = table();
-	t.equal( objectKeys( tbl ).length > 0, true, 'has keys' );
+	t.strictEqual( objectKeys( tbl ).length > 0, true, 'has keys' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/datasets/emoji/test/test.browser.js b/lib/node_modules/@stdlib/datasets/emoji/test/test.browser.js
index 95fbecf919fa..655d022b6138 100644
--- a/lib/node_modules/@stdlib/datasets/emoji/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/emoji/test/test.browser.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'returns expected value' );
-	t.equal( data.length > 0, true, 'is not empty' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
+	t.strictEqual( data.length > 0, true, 'is not empty' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns a copy', function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/datasets/emoji/test/test.js b/lib/node_modules/@stdlib/datasets/emoji/test/test.js
index 90758183742a..8f39c553d30f 100644
--- a/lib/node_modules/@stdlib/datasets/emoji/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/emoji/test/test.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array', opts, function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'returns expected value' );
-	t.equal( data.length > 0, true, 'is not empty' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
+	t.strictEqual( data.length > 0, true, 'is not empty' );
 	t.end();
 });
 
@@ -59,7 +59,7 @@ tape( 'the function returns a copy', opts, function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/datasets/female-first-names-en/test/test.browser.js b/lib/node_modules/@stdlib/datasets/female-first-names-en/test/test.browser.js
index fe59516f5ca2..fcdc4ebb0d47 100644
--- a/lib/node_modules/@stdlib/datasets/female-first-names-en/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/female-first-names-en/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var data = names();
-	t.equal( isStringArray( data ), true, 'returns an array of strings' );
+	t.strictEqual( isStringArray( data ), true, 'returns an array of strings' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/female-first-names-en/test/test.js b/lib/node_modules/@stdlib/datasets/female-first-names-en/test/test.js
index 391f079de595..f7e7462d85f9 100644
--- a/lib/node_modules/@stdlib/datasets/female-first-names-en/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/female-first-names-en/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var data = names();
-	t.equal( isStringArray( data ), true, 'returns an array of strings' );
+	t.strictEqual( isStringArray( data ), true, 'returns an array of strings' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/fivethirtyeight-ffq/test/test.browser.js b/lib/node_modules/@stdlib/datasets/fivethirtyeight-ffq/test/test.browser.js
index 95fbecf919fa..655d022b6138 100644
--- a/lib/node_modules/@stdlib/datasets/fivethirtyeight-ffq/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/fivethirtyeight-ffq/test/test.browser.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'returns expected value' );
-	t.equal( data.length > 0, true, 'is not empty' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
+	t.strictEqual( data.length > 0, true, 'is not empty' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns a copy', function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/datasets/fivethirtyeight-ffq/test/test.js b/lib/node_modules/@stdlib/datasets/fivethirtyeight-ffq/test/test.js
index 90758183742a..8f39c553d30f 100644
--- a/lib/node_modules/@stdlib/datasets/fivethirtyeight-ffq/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/fivethirtyeight-ffq/test/test.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array', opts, function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'returns expected value' );
-	t.equal( data.length > 0, true, 'is not empty' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
+	t.strictEqual( data.length > 0, true, 'is not empty' );
 	t.end();
 });
 
@@ -59,7 +59,7 @@ tape( 'the function returns a copy', opts, function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/datasets/frb-sf-wage-rigidity/test/test.browser.js b/lib/node_modules/@stdlib/datasets/frb-sf-wage-rigidity/test/test.browser.js
index f006b78b28c2..105cd07fd89c 100644
--- a/lib/node_modules/@stdlib/datasets/frb-sf-wage-rigidity/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/frb-sf-wage-rigidity/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', function test( t ) {
 	var data = wages();
-	t.equal( isObjectArray( data ), true, 'returns an array of objects' );
+	t.strictEqual( isObjectArray( data ), true, 'returns an array of objects' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/frb-sf-wage-rigidity/test/test.js b/lib/node_modules/@stdlib/datasets/frb-sf-wage-rigidity/test/test.js
index b6b50f583cd8..c64560d1460e 100644
--- a/lib/node_modules/@stdlib/datasets/frb-sf-wage-rigidity/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/frb-sf-wage-rigidity/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', opts, function test( t ) {
 	var data = wages();
-	t.equal( isObjectArray( data ), true, 'returns an array of objects' );
+	t.strictEqual( isObjectArray( data ), true, 'returns an array of objects' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-acanthus-mollis/test/test.browser.js b/lib/node_modules/@stdlib/datasets/img-acanthus-mollis/test/test.browser.js
index e44d26ed93e5..0f171f5018b1 100644
--- a/lib/node_modules/@stdlib/datasets/img-acanthus-mollis/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/img-acanthus-mollis/test/test.browser.js
@@ -35,6 +35,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-acanthus-mollis/test/test.js b/lib/node_modules/@stdlib/datasets/img-acanthus-mollis/test/test.js
index 6e85ba4d56c1..c4e1c818b118 100644
--- a/lib/node_modules/@stdlib/datasets/img-acanthus-mollis/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/img-acanthus-mollis/test/test.js
@@ -43,6 +43,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', opts, function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-airplane-from-above/test/test.browser.js b/lib/node_modules/@stdlib/datasets/img-airplane-from-above/test/test.browser.js
index e44d26ed93e5..0f171f5018b1 100644
--- a/lib/node_modules/@stdlib/datasets/img-airplane-from-above/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/img-airplane-from-above/test/test.browser.js
@@ -35,6 +35,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-airplane-from-above/test/test.js b/lib/node_modules/@stdlib/datasets/img-airplane-from-above/test/test.js
index 6e85ba4d56c1..c4e1c818b118 100644
--- a/lib/node_modules/@stdlib/datasets/img-airplane-from-above/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/img-airplane-from-above/test/test.js
@@ -43,6 +43,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', opts, function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-allium-oreophilum/test/test.browser.js b/lib/node_modules/@stdlib/datasets/img-allium-oreophilum/test/test.browser.js
index e44d26ed93e5..0f171f5018b1 100644
--- a/lib/node_modules/@stdlib/datasets/img-allium-oreophilum/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/img-allium-oreophilum/test/test.browser.js
@@ -35,6 +35,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-allium-oreophilum/test/test.js b/lib/node_modules/@stdlib/datasets/img-allium-oreophilum/test/test.js
index 6e85ba4d56c1..c4e1c818b118 100644
--- a/lib/node_modules/@stdlib/datasets/img-allium-oreophilum/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/img-allium-oreophilum/test/test.js
@@ -43,6 +43,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', opts, function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-black-canyon/test/test.browser.js b/lib/node_modules/@stdlib/datasets/img-black-canyon/test/test.browser.js
index e44d26ed93e5..0f171f5018b1 100644
--- a/lib/node_modules/@stdlib/datasets/img-black-canyon/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/img-black-canyon/test/test.browser.js
@@ -35,6 +35,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-black-canyon/test/test.js b/lib/node_modules/@stdlib/datasets/img-black-canyon/test/test.js
index 6e85ba4d56c1..c4e1c818b118 100644
--- a/lib/node_modules/@stdlib/datasets/img-black-canyon/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/img-black-canyon/test/test.js
@@ -43,6 +43,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', opts, function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-dust-bowl-home/test/test.browser.js b/lib/node_modules/@stdlib/datasets/img-dust-bowl-home/test/test.browser.js
index e44d26ed93e5..0f171f5018b1 100644
--- a/lib/node_modules/@stdlib/datasets/img-dust-bowl-home/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/img-dust-bowl-home/test/test.browser.js
@@ -35,6 +35,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-dust-bowl-home/test/test.js b/lib/node_modules/@stdlib/datasets/img-dust-bowl-home/test/test.js
index 6e85ba4d56c1..c4e1c818b118 100644
--- a/lib/node_modules/@stdlib/datasets/img-dust-bowl-home/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/img-dust-bowl-home/test/test.js
@@ -43,6 +43,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', opts, function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-french-alpine-landscape/test/test.browser.js b/lib/node_modules/@stdlib/datasets/img-french-alpine-landscape/test/test.browser.js
index e44d26ed93e5..0f171f5018b1 100644
--- a/lib/node_modules/@stdlib/datasets/img-french-alpine-landscape/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/img-french-alpine-landscape/test/test.browser.js
@@ -35,6 +35,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-french-alpine-landscape/test/test.js b/lib/node_modules/@stdlib/datasets/img-french-alpine-landscape/test/test.js
index 6e85ba4d56c1..c4e1c818b118 100644
--- a/lib/node_modules/@stdlib/datasets/img-french-alpine-landscape/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/img-french-alpine-landscape/test/test.js
@@ -43,6 +43,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', opts, function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-locomotion-house-cat/test/test.browser.js b/lib/node_modules/@stdlib/datasets/img-locomotion-house-cat/test/test.browser.js
index e44d26ed93e5..0f171f5018b1 100644
--- a/lib/node_modules/@stdlib/datasets/img-locomotion-house-cat/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/img-locomotion-house-cat/test/test.browser.js
@@ -35,6 +35,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-locomotion-house-cat/test/test.js b/lib/node_modules/@stdlib/datasets/img-locomotion-house-cat/test/test.js
index 6e85ba4d56c1..c4e1c818b118 100644
--- a/lib/node_modules/@stdlib/datasets/img-locomotion-house-cat/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/img-locomotion-house-cat/test/test.js
@@ -43,6 +43,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', opts, function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-locomotion-nude-male/test/test.browser.js b/lib/node_modules/@stdlib/datasets/img-locomotion-nude-male/test/test.browser.js
index e44d26ed93e5..0f171f5018b1 100644
--- a/lib/node_modules/@stdlib/datasets/img-locomotion-nude-male/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/img-locomotion-nude-male/test/test.browser.js
@@ -35,6 +35,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-locomotion-nude-male/test/test.js b/lib/node_modules/@stdlib/datasets/img-locomotion-nude-male/test/test.js
index 6e85ba4d56c1..c4e1c818b118 100644
--- a/lib/node_modules/@stdlib/datasets/img-locomotion-nude-male/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/img-locomotion-nude-male/test/test.js
@@ -43,6 +43,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', opts, function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-march-pastoral/test/test.browser.js b/lib/node_modules/@stdlib/datasets/img-march-pastoral/test/test.browser.js
index e44d26ed93e5..0f171f5018b1 100644
--- a/lib/node_modules/@stdlib/datasets/img-march-pastoral/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/img-march-pastoral/test/test.browser.js
@@ -35,6 +35,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-march-pastoral/test/test.js b/lib/node_modules/@stdlib/datasets/img-march-pastoral/test/test.js
index 6e85ba4d56c1..c4e1c818b118 100644
--- a/lib/node_modules/@stdlib/datasets/img-march-pastoral/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/img-march-pastoral/test/test.js
@@ -43,6 +43,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', opts, function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-nagasaki-boats/test/test.browser.js b/lib/node_modules/@stdlib/datasets/img-nagasaki-boats/test/test.browser.js
index e44d26ed93e5..0f171f5018b1 100644
--- a/lib/node_modules/@stdlib/datasets/img-nagasaki-boats/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/img-nagasaki-boats/test/test.browser.js
@@ -35,6 +35,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/img-nagasaki-boats/test/test.js b/lib/node_modules/@stdlib/datasets/img-nagasaki-boats/test/test.js
index 6e85ba4d56c1..c4e1c818b118 100644
--- a/lib/node_modules/@stdlib/datasets/img-nagasaki-boats/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/img-nagasaki-boats/test/test.js
@@ -43,6 +43,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a buffer object', opts, function test( t ) {
 	var data = image();
-	t.equal( isBuffer( data ), true, 'returns a buffer object' );
+	t.strictEqual( isBuffer( data ), true, 'returns a buffer object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/liu-negative-opinion-words-en/test/test.browser.js b/lib/node_modules/@stdlib/datasets/liu-negative-opinion-words-en/test/test.browser.js
index 6dd2863dafec..621d4ff73254 100644
--- a/lib/node_modules/@stdlib/datasets/liu-negative-opinion-words-en/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/liu-negative-opinion-words-en/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var list = words();
-	t.equal( isStringArray( list ), true, 'returns an array of strings' );
+	t.strictEqual( isStringArray( list ), true, 'returns an array of strings' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/liu-negative-opinion-words-en/test/test.js b/lib/node_modules/@stdlib/datasets/liu-negative-opinion-words-en/test/test.js
index 666b183fb2d1..806603bd3097 100644
--- a/lib/node_modules/@stdlib/datasets/liu-negative-opinion-words-en/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/liu-negative-opinion-words-en/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var list = words();
-	t.equal( isStringArray( list ), true, 'returns an array of strings' );
+	t.strictEqual( isStringArray( list ), true, 'returns an array of strings' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/liu-positive-opinion-words-en/test/test.browser.js b/lib/node_modules/@stdlib/datasets/liu-positive-opinion-words-en/test/test.browser.js
index 6dd2863dafec..621d4ff73254 100644
--- a/lib/node_modules/@stdlib/datasets/liu-positive-opinion-words-en/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/liu-positive-opinion-words-en/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var list = words();
-	t.equal( isStringArray( list ), true, 'returns an array of strings' );
+	t.strictEqual( isStringArray( list ), true, 'returns an array of strings' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/liu-positive-opinion-words-en/test/test.js b/lib/node_modules/@stdlib/datasets/liu-positive-opinion-words-en/test/test.js
index 666b183fb2d1..806603bd3097 100644
--- a/lib/node_modules/@stdlib/datasets/liu-positive-opinion-words-en/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/liu-positive-opinion-words-en/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var list = words();
-	t.equal( isStringArray( list ), true, 'returns an array of strings' );
+	t.strictEqual( isStringArray( list ), true, 'returns an array of strings' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/male-first-names-en/test/test.browser.js b/lib/node_modules/@stdlib/datasets/male-first-names-en/test/test.browser.js
index fe59516f5ca2..fcdc4ebb0d47 100644
--- a/lib/node_modules/@stdlib/datasets/male-first-names-en/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/male-first-names-en/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var data = names();
-	t.equal( isStringArray( data ), true, 'returns an array of strings' );
+	t.strictEqual( isStringArray( data ), true, 'returns an array of strings' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/male-first-names-en/test/test.js b/lib/node_modules/@stdlib/datasets/male-first-names-en/test/test.js
index 391f079de595..f7e7462d85f9 100644
--- a/lib/node_modules/@stdlib/datasets/male-first-names-en/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/male-first-names-en/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var data = names();
-	t.equal( isStringArray( data ), true, 'returns an array of strings' );
+	t.strictEqual( isStringArray( data ), true, 'returns an array of strings' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.browser.js b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.browser.js
index d60da2bbdb3d..4b4e15150dbb 100644
--- a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.browser.js
@@ -107,12 +107,12 @@ tape( 'if not provided a `data` option, the function returns an `object`', funct
 	var d2;
 
 	data = minard();
-	t.equal( isObject( data ), true, 'returns an object' );
-	t.equal( hasOwnProp( data, 'army' ), true, 'has `army` property' );
-	t.equal( hasOwnProp( data, 'cities' ), true, 'has `cities` property' );
-	t.equal( hasOwnProp( data, 'labels' ), true, 'has `labels` property' );
-	t.equal( hasOwnProp( data, 'rivers' ), true, 'has `rivers` property' );
-	t.equal( hasOwnProp( data, 'temperature' ), true, 'has `temperature` property' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( hasOwnProp( data, 'army' ), true, 'has `army` property' );
+	t.strictEqual( hasOwnProp( data, 'cities' ), true, 'has `cities` property' );
+	t.strictEqual( hasOwnProp( data, 'labels' ), true, 'has `labels` property' );
+	t.strictEqual( hasOwnProp( data, 'rivers' ), true, 'has `rivers` property' );
+	t.strictEqual( hasOwnProp( data, 'temperature' ), true, 'has `temperature` property' );
 
 	// Should return a deep copy...
 	d2 = minard();
@@ -131,12 +131,12 @@ tape( 'if not provided a `data` option, the function returns an `object` (option
 	var d2;
 
 	data = minard( {} );
-	t.equal( isObject( data ), true, 'returns an object' );
-	t.equal( hasOwnProp( data, 'army' ), true, 'has `army` property' );
-	t.equal( hasOwnProp( data, 'cities' ), true, 'has `cities` property' );
-	t.equal( hasOwnProp( data, 'labels' ), true, 'has `labels` property' );
-	t.equal( hasOwnProp( data, 'rivers' ), true, 'has `rivers` property' );
-	t.equal( hasOwnProp( data, 'temperature' ), true, 'has `temperature` property' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( hasOwnProp( data, 'army' ), true, 'has `army` property' );
+	t.strictEqual( hasOwnProp( data, 'cities' ), true, 'has `cities` property' );
+	t.strictEqual( hasOwnProp( data, 'labels' ), true, 'has `labels` property' );
+	t.strictEqual( hasOwnProp( data, 'rivers' ), true, 'has `rivers` property' );
+	t.strictEqual( hasOwnProp( data, 'temperature' ), true, 'has `temperature` property' );
 
 	// Should return a deep copy...
 	d2 = minard( {} );
@@ -160,7 +160,7 @@ tape( 'if the `data` option is `army`, the function returns an array of objects'
 	};
 	data = minard( opts );
 
-	t.equal( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -180,7 +180,7 @@ tape( 'if the `data` option is `cities`, the function returns an array of object
 	};
 	data = minard( opts );
 
-	t.equal( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -200,7 +200,7 @@ tape( 'if the `data` option is `labels`, the function returns an array of object
 	};
 	data = minard( opts );
 
-	t.equal( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -220,7 +220,7 @@ tape( 'if the `data` option is `rivers`, the function returns an object', functi
 	};
 	data = minard( opts );
 
-	t.equal( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -240,7 +240,7 @@ tape( 'if the `data` option is `temperature`, the function returns an array of o
 	};
 	data = minard( opts );
 
-	t.equal( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
diff --git a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.js b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.js
index c6341d7586df..5206c3509d4d 100644
--- a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.js
@@ -115,12 +115,12 @@ tape( 'if not provided a `data` option, the function returns an `object`', opts,
 	var d2;
 
 	data = minard();
-	t.equal( isObject( data ), true, 'returns an object' );
-	t.equal( hasOwnProp( data, 'army' ), true, 'has `army` property' );
-	t.equal( hasOwnProp( data, 'cities' ), true, 'has `cities` property' );
-	t.equal( hasOwnProp( data, 'labels' ), true, 'has `labels` property' );
-	t.equal( hasOwnProp( data, 'rivers' ), true, 'has `rivers` property' );
-	t.equal( hasOwnProp( data, 'temperature' ), true, 'has `temperature` property' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( hasOwnProp( data, 'army' ), true, 'has `army` property' );
+	t.strictEqual( hasOwnProp( data, 'cities' ), true, 'has `cities` property' );
+	t.strictEqual( hasOwnProp( data, 'labels' ), true, 'has `labels` property' );
+	t.strictEqual( hasOwnProp( data, 'rivers' ), true, 'has `rivers` property' );
+	t.strictEqual( hasOwnProp( data, 'temperature' ), true, 'has `temperature` property' );
 
 	// Should return a deep copy...
 	d2 = minard();
@@ -139,12 +139,12 @@ tape( 'if not provided a `data` option, the function returns an `object` (option
 	var d2;
 
 	data = minard( {} );
-	t.equal( isObject( data ), true, 'returns an object' );
-	t.equal( hasOwnProp( data, 'army' ), true, 'has `army` property' );
-	t.equal( hasOwnProp( data, 'cities' ), true, 'has `cities` property' );
-	t.equal( hasOwnProp( data, 'labels' ), true, 'has `labels` property' );
-	t.equal( hasOwnProp( data, 'rivers' ), true, 'has `rivers` property' );
-	t.equal( hasOwnProp( data, 'temperature' ), true, 'has `temperature` property' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( hasOwnProp( data, 'army' ), true, 'has `army` property' );
+	t.strictEqual( hasOwnProp( data, 'cities' ), true, 'has `cities` property' );
+	t.strictEqual( hasOwnProp( data, 'labels' ), true, 'has `labels` property' );
+	t.strictEqual( hasOwnProp( data, 'rivers' ), true, 'has `rivers` property' );
+	t.strictEqual( hasOwnProp( data, 'temperature' ), true, 'has `temperature` property' );
 
 	// Should return a deep copy...
 	d2 = minard( {} );
@@ -168,7 +168,7 @@ tape( 'if the `data` option is `army`, the function returns an array of objects'
 	};
 	data = minard( opts );
 
-	t.equal( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -188,7 +188,7 @@ tape( 'if the `data` option is `cities`, the function returns an array of object
 	};
 	data = minard( opts );
 
-	t.equal( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -208,7 +208,7 @@ tape( 'if the `data` option is `labels`, the function returns an array of object
 	};
 	data = minard( opts );
 
-	t.equal( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -228,7 +228,7 @@ tape( 'if the `data` option is `rivers`, the function returns an object', opts,
 	};
 	data = minard( opts );
 
-	t.equal( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns an object' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -248,7 +248,7 @@ tape( 'if the `data` option is `temperature`, the function returns an array of o
 	};
 	data = minard( opts );
 
-	t.equal( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
diff --git a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.validate.js b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.validate.js
index b2f1e44da671..7ab2438a2dde 100644
--- a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.validate.js
+++ b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.validate.js
@@ -75,7 +75,7 @@ tape( 'the function returns an error if provided a `data` option which is not a
 		err = validate( {}, {
 			'data': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -96,7 +96,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'sets option values' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/month-names-en/test/test.browser.js b/lib/node_modules/@stdlib/datasets/month-names-en/test/test.browser.js
index 0d6f1edac4d1..155cc1eb00d9 100644
--- a/lib/node_modules/@stdlib/datasets/month-names-en/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/month-names-en/test/test.browser.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var list = months();
-	t.equal( isStringArray( list ), true, 'returns an array of strings' );
-	t.equal( list.length, 12, 'has length of 12' );
+	t.strictEqual( isStringArray( list ), true, 'returns an array of strings' );
+	t.strictEqual( list.length, 12, 'has length of 12' );
 	t.end();
 });
 
@@ -51,9 +51,9 @@ tape( 'the function returns a copy', function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
-	t.equal( l2[ 5 ], 'June', 'expected element' );
+	t.strictEqual( l2[ 5 ], 'June', 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/month-names-en/test/test.js b/lib/node_modules/@stdlib/datasets/month-names-en/test/test.js
index 66020b5e1ef3..f4aa2f42adb9 100644
--- a/lib/node_modules/@stdlib/datasets/month-names-en/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/month-names-en/test/test.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var list = months();
-	t.equal( isStringArray( list ), true, 'returns an array of strings' );
-	t.equal( list.length, 12, 'has length of 12' );
+	t.strictEqual( isStringArray( list ), true, 'returns an array of strings' );
+	t.strictEqual( list.length, 12, 'has length of 12' );
 	t.end();
 });
 
@@ -59,9 +59,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
-	t.equal( l2[ 5 ], 'June', 'expected element' );
+	t.strictEqual( l2[ 5 ], 'June', 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/nightingales-rose/test/test.browser.js b/lib/node_modules/@stdlib/datasets/nightingales-rose/test/test.browser.js
index a48a32668611..6ac8e43c0956 100644
--- a/lib/node_modules/@stdlib/datasets/nightingales-rose/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/nightingales-rose/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', function test( t ) {
 	var data = rose();
-	t.equal( isObjectArray( data ), true, 'main export is an array of objects' );
+	t.strictEqual( isObjectArray( data ), true, 'main export is an array of objects' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/nightingales-rose/test/test.js b/lib/node_modules/@stdlib/datasets/nightingales-rose/test/test.js
index 2aa0cbd5b7bc..dec7c6077420 100644
--- a/lib/node_modules/@stdlib/datasets/nightingales-rose/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/nightingales-rose/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', opts, function test( t ) {
 	var data = rose();
-	t.equal( isObjectArray( data ), true, 'main export is an array of objects' );
+	t.strictEqual( isObjectArray( data ), true, 'main export is an array of objects' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/primes-100k/test/test.browser.js b/lib/node_modules/@stdlib/datasets/primes-100k/test/test.browser.js
index d579be7908b0..613bdb8d08cc 100644
--- a/lib/node_modules/@stdlib/datasets/primes-100k/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/primes-100k/test/test.browser.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of positive integer primitives', function test( t ) {
 	var list = primes();
-	t.equal( isPositiveIntegerArray( list ), true, 'returns expected value' );
-	t.equal( list.length, 100000, 'has expected length' );
+	t.strictEqual( isPositiveIntegerArray( list ), true, 'returns expected value' );
+	t.strictEqual( list.length, 100000, 'has expected length' );
 	t.end();
 });
 
@@ -51,9 +51,9 @@ tape( 'the function returns a copy', function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
-	t.equal( l2[ 5 ], 13, 'expected element' );
+	t.strictEqual( l2[ 5 ], 13, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/primes-100k/test/test.js b/lib/node_modules/@stdlib/datasets/primes-100k/test/test.js
index 3d993d09d73b..07e6a16040e1 100644
--- a/lib/node_modules/@stdlib/datasets/primes-100k/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/primes-100k/test/test.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of positive integer primitives', opts, function test( t ) {
 	var list = primes();
-	t.equal( isPositiveIntegerArray( list ), true, 'returns expected value' );
-	t.equal( list.length, 100000, 'has expected length' );
+	t.strictEqual( isPositiveIntegerArray( list ), true, 'returns expected value' );
+	t.strictEqual( list.length, 100000, 'has expected length' );
 	t.end();
 });
 
@@ -59,9 +59,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
-	t.equal( l2[ 5 ], 13, 'expected element' );
+	t.strictEqual( l2[ 5 ], 13, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-fin/test/test.browser.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-fin/test/test.browser.js
index 4b6322dbb87b..c76af28dc0cb 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-fin/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-fin/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-fin/test/test.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-fin/test/test.js
index 3abc73296f4c..17322cbc627d 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-fin/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-fin/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-fr/test/test.browser.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-fr/test/test.browser.js
index 4b6322dbb87b..c76af28dc0cb 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-fr/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-fr/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-fr/test/test.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-fr/test/test.js
index 3abc73296f4c..17322cbc627d 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-fr/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-fr/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-ger/test/test.browser.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-ger/test/test.browser.js
index 4b6322dbb87b..c76af28dc0cb 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-ger/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-ger/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-ger/test/test.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-ger/test/test.js
index 3abc73296f4c..17322cbc627d 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-ger/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-ger/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-it/test/test.browser.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-it/test/test.browser.js
index 4b6322dbb87b..c76af28dc0cb 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-it/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-it/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-it/test/test.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-it/test/test.js
index 3abc73296f4c..17322cbc627d 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-it/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-it/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-por/test/test.browser.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-por/test/test.browser.js
index 4b6322dbb87b..c76af28dc0cb 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-por/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-por/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-por/test/test.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-por/test/test.js
index 3abc73296f4c..17322cbc627d 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-por/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-por/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-sp/test/test.browser.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-sp/test/test.browser.js
index 4b6322dbb87b..c76af28dc0cb 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-sp/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-sp/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-sp/test/test.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-sp/test/test.js
index 3abc73296f4c..17322cbc627d 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-sp/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-sp/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-swe/test/test.browser.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-swe/test/test.browser.js
index 4b6322dbb87b..c76af28dc0cb 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-swe/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-swe/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/savoy-stopwords-swe/test/test.js b/lib/node_modules/@stdlib/datasets/savoy-stopwords-swe/test/test.js
index 3abc73296f4c..17322cbc627d 100644
--- a/lib/node_modules/@stdlib/datasets/savoy-stopwords-swe/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/savoy-stopwords-swe/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_db.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_db.js
index f6c347c7a191..d1d95ad78fd6 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_db.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_db.js
@@ -29,11 +29,11 @@ var db = require( './../lib/browser_db.js' );
 
 tape( 'main export is an object array', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( isObjectArray( db ), true, 'main export is an object array' );
+	t.strictEqual( isObjectArray( db ), true, 'main export is an object array' );
 	t.end();
 });
 
 tape( 'as of 2021, export has a length greater than or equal to 233', function test( t ) {
-	t.equal( db.length >= 233, true, 'has length greater than or equal to 233 (as of 2021)' );
+	t.strictEqual( db.length >= 233, true, 'has length greater than or equal to 233 (as of 2021)' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_file_list.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_file_list.js
index 15b92c6285e2..3fe30a8757a9 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_file_list.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_file_list.js
@@ -30,12 +30,12 @@ var FILES = require( './../lib/browser_file_list.js' );
 
 tape( 'main export is a string array', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( isStringArray( FILES ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( FILES ), true, 'main export is a string array' );
 	t.end();
 });
 
 tape( 'as of 2021, the array has a length greater than or equal to 233', function test( t ) {
-	t.equal( FILES.length >= 233, true, 'has length greater than or equal to 233 (as of 2021)' );
+	t.strictEqual( FILES.length >= 233, true, 'has length greater than or equal to 233 (as of 2021)' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_get_file.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_get_file.js
index e3884b720ed2..1be478c7e9cd 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_get_file.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_get_file.js
@@ -47,6 +47,6 @@ tape( 'the function returns an object', function test( t ) {
 			'./db.js': db
 		});
 	}
-	t.equal( isObject( fcn( 0 ) ), true, 'returns an object' );
+	t.strictEqual( isObject( fcn( 0 ) ), true, 'returns an object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.db.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.db.js
index 9cd3bdce9f9e..6b34c764368e 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.db.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.db.js
@@ -37,19 +37,19 @@ var opts = {
 
 tape( 'main export is an array', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( isArray( db ), true, 'main export is an array' );
+	t.strictEqual( isArray( db ), true, 'main export is an array' );
 	t.end();
 });
 
 tape( 'as of 2019, the exported array has a length greater than or equal to 231', opts, function test( t ) {
-	t.equal( db.length >= 231, true, 'has length greater than or equal to 231 (as of 2019)' );
+	t.strictEqual( db.length >= 231, true, 'has length greater than or equal to 231 (as of 2019)' );
 	t.end();
 });
 
 tape( 'the exported array is initialized with empty elements (data is lazily loaded)', opts, function test( t ) {
 	var i;
 	for ( i = 0; i < db.length; i++ ) {
-		t.equal( db[i], void 0, 'element '+i+' is empty' );
+		t.strictEqual( db[i], void 0, 'element '+i+' is empty' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.file_list.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.file_list.js
index d34166aab9a9..09508df92bab 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.file_list.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.file_list.js
@@ -39,12 +39,12 @@ var opts = {
 
 tape( 'main export is a string array', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.equal( isStringArray( FILES ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( FILES ), true, 'main export is a string array' );
 	t.end();
 });
 
 tape( 'as of 2019, export has a length greater than or equal to 231', opts, function test( t ) {
-	t.equal( FILES.length >= 231, true, 'has length greater than or equal to 231 (as of 2019)' );
+	t.strictEqual( FILES.length >= 231, true, 'has length greater than or equal to 231 (as of 2019)' );
 	t.end();
 });
 
@@ -65,7 +65,7 @@ tape( 'the implementation guards against directories having the data filename si
 			'statSync': statSync
 		}
 	});
-	t.equal( files.length < FILES.length && files.length > 0, true, 'does not include directories' );
+	t.strictEqual( files.length < FILES.length && files.length > 0, true, 'does not include directories' );
 	t.end();
 
 	function statSync() {
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.get_file.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.get_file.js
index 9295d526e643..2c3e71985fd9 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.get_file.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.get_file.js
@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
+var filled = require( '@stdlib/array/base/filled' );
 var isObject = require( '@stdlib/assert/is-plain-object' );
 var getFile = require( './../lib/get_file.js' );
 
@@ -40,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.equal( isObject( getFile( 0 ) ), true, 'returns an object' );
+	t.strictEqual( isObject( getFile( 0 ) ), true, 'returns an object' );
 	t.end();
 });
 
@@ -50,7 +51,7 @@ tape( 'if file data does not exist in the database, the data is synchronously lo
 	var file;
 	var db;
 
-	db = new Array( 10 );
+	db = filled( void 0, 10 );
 	data = {
 		'beep': 'boop'
 	};
@@ -59,7 +60,7 @@ tape( 'if file data does not exist in the database, the data is synchronously lo
 		'./db.js': db,
 		'./load_json.js': load
 	});
-	t.equal( db[ 5 ], void 0, 'db[5] has empty value' );
+	t.strictEqual( db[ 5 ], void 0, 'db[5] has empty value' );
 
 	file = getFile( 5 );
 	t.deepEqual( file, data, 'returns file data' );
@@ -80,7 +81,7 @@ tape( 'if data has been previously loaded, the function returns a value from a c
 	var db;
 	var i;
 
-	db = new Array( 10 );
+	db = filled( void 0, 10 );
 	data = {
 		'beep': 'boop'
 	};
@@ -89,7 +90,7 @@ tape( 'if data has been previously loaded, the function returns a value from a c
 		'./db.js': db,
 		'./load_json.js': load
 	});
-	t.equal( db[ 5 ], void 0, 'db[5] has empty value' );
+	t.strictEqual( db[ 5 ], void 0, 'db[5] has empty value' );
 
 	for ( i = 0; i < 10; i++ ) {
 		file = getFile( 5 );
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.index_name.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.index_name.js
index 1e2e0ab11cb3..0b3f54aa5424 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.index_name.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.index_name.js
@@ -30,11 +30,11 @@ var index = require( './../lib/index_name.js' );
 
 tape( 'main export is a object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( isObject( index ), true, 'main export is an object' );
+	t.strictEqual( isObject( index ), true, 'main export is an object' );
 	t.end();
 });
 
 tape( 'export maps President names to data file indices', function test( t ) {
-	t.equal( isPositiveIntegerArray( index[ 'Barack Obama' ] ), true, 'returns an array of indices' );
+	t.strictEqual( isPositiveIntegerArray( index[ 'Barack Obama' ] ), true, 'returns an array of indices' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.index_party.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.index_party.js
index da1cd029646b..bf07c422d2b5 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.index_party.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.index_party.js
@@ -30,11 +30,11 @@ var index = require( './../lib/index_party.js' );
 
 tape( 'main export is a object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( isObject( index ), true, 'main export is an object' );
+	t.strictEqual( isObject( index ), true, 'main export is an object' );
 	t.end();
 });
 
 tape( 'export maps political parties to data file indices', function test( t ) {
-	t.equal( isPositiveIntegerArray( index[ 'Democratic' ] ), true, 'returns an array of indices' );
+	t.strictEqual( isPositiveIntegerArray( index[ 'Democratic' ] ), true, 'returns an array of indices' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.index_year.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.index_year.js
index 275e6384a1c6..ea6d3de79976 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.index_year.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.index_year.js
@@ -30,11 +30,11 @@ var index = require( './../lib/index_year.js' );
 
 tape( 'main export is a object', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( isObject( index ), true, 'main export is an object' );
+	t.strictEqual( isObject( index ), true, 'main export is an object' );
 	t.end();
 });
 
 tape( 'export maps years to data file indices', function test( t ) {
-	t.equal( isPositiveIntegerArray( index[ 2008 ] ), true, 'returns an array of indices' );
+	t.strictEqual( isPositiveIntegerArray( index[ 2008 ] ), true, 'returns an array of indices' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.js
index 8ab11507853c..bc4d7bad040c 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.js
@@ -130,7 +130,7 @@ tape( 'the function throws an error if provided a unrecognized `party`', functio
 
 tape( 'the function returns an object array', function test( t ) {
 	var out = sotu();
-	t.equal( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
 	t.end();
 });
 
@@ -142,22 +142,22 @@ tape( 'the `name` option can be used to retrieve SOTU addresses by specific Pres
 	out = sotu({
 		'name': 'Barack Obama'
 	});
-	t.equal( isObjectArray( out ), true, 'returns an object array' );
-	t.equal( out.length, 8, 'returns selected speeches' );
+	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( out.length, 8, 'returns selected speeches' );
 
 	for ( i = 0; i < out.length; i++ ) {
-		t.equal( out[ i ].name, 'Barack Obama', 'speech is from expected President' );
+		t.strictEqual( out[ i ].name, 'Barack Obama', 'speech is from expected President' );
 	}
 
 	out = sotu({
 		'name': [ 'William J Clinton', 'Barack Obama' ]
 	});
-	t.equal( isObjectArray( out ), true, 'returns an object array' );
-	t.equal( out.length, 16, 'returns selected speeches' );
+	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( out.length, 16, 'returns selected speeches' );
 
 	for ( i = 0; i < out.length; i++ ) {
 		bool = ( out[ i ].name === 'William J Clinton' || out[ i ].name === 'Barack Obama' );
-		t.equal( bool, true, 'returns a speech by a specified President' );
+		t.strictEqual( bool, true, 'returns a speech by a specified President' );
 	}
 	t.end();
 });
@@ -170,20 +170,20 @@ tape( 'the `party` option can be used to retrieve SOTU addresses from Presidents
 	out = sotu({
 		'party': 'Democratic'
 	});
-	t.equal( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
 
 	for ( i = 0; i < out.length; i++ ) {
-		t.equal( out[ i ].party, 'Democratic', 'speech is from a Democratic President' );
+		t.strictEqual( out[ i ].party, 'Democratic', 'speech is from a Democratic President' );
 	}
 
 	out = sotu({
 		'party': [ 'Democratic', 'Republican' ]
 	});
-	t.equal( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
 
 	for ( i = 0; i < out.length; i++ ) {
 		bool = ( out[ i ].party === 'Democratic' || out[ i ].party === 'Republican' );
-		t.equal( bool, true, 'speech is from a Democratic or Republican President' );
+		t.strictEqual( bool, true, 'speech is from a Democratic or Republican President' );
 	}
 	t.end();
 });
@@ -194,15 +194,15 @@ tape( 'the `year` option can be used to retrieve SOTU addresses from particular
 	out = sotu({
 		'year': 2009
 	});
-	t.equal( isObjectArray( out ), true, 'returns an object array' );
-	t.equal( out[ 0 ].name, 'Barack Obama', 'speech is from expected President' );
+	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( out[ 0 ].name, 'Barack Obama', 'speech is from expected President' );
 
 	out = sotu({
 		'year': [ 1998, 2009 ]
 	});
-	t.equal( isObjectArray( out ), true, 'returns an object array' );
-	t.equal( out[ 0 ].name, 'William J Clinton', 'speech is from expected President' );
-	t.equal( out[ 1 ].name, 'Barack Obama', 'speech is from expected President' );
+	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( out[ 0 ].name, 'William J Clinton', 'speech is from expected President' );
+	t.strictEqual( out[ 1 ].name, 'Barack Obama', 'speech is from expected President' );
 
 	t.end();
 });
@@ -213,26 +213,26 @@ tape( 'the `range` option can be used to retrieve SOTU addresses of a given time
 	out = sotu({
 		'range': [ 1980, 1995 ]
 	});
-	t.equal( isObjectArray( out ), true, 'returns an object array' );
-	t.equal( out.length, 16, 'returns speeches from 1980 to 1995' );
+	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( out.length, 16, 'returns speeches from 1980 to 1995' );
 
 	out = sotu({
 		'range': [ 1880, 1920 ]
 	});
-	t.equal( isObjectArray( out ), true, 'returns an object array' );
-	t.equal( out.length, 41, 'returns speeches from 1880 to 1920' );
+	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( out.length, 41, 'returns speeches from 1880 to 1920' );
 
 	out = sotu({
 		'range': [ 1920, 1970 ]
 	});
-	t.equal( isObjectArray( out ), true, 'returns an object array' );
-	t.equal( out.length, 52, 'returns speeches from 1920 to 1970' );
+	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( out.length, 52, 'returns speeches from 1920 to 1970' );
 
 	out = sotu({
 		'range': [ 1935, 1960 ]
 	});
-	t.equal( isObjectArray( out ), true, 'returns an object array' );
-	t.equal( out.length, 27, 'returns speeches from 1935 to 1960' );
+	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( out.length, 27, 'returns speeches from 1935 to 1960' );
 
 	t.end();
 });
@@ -256,8 +256,8 @@ tape( 'if provided multiple options, the function returns the union', function t
 		'party': 0
 	};
 
-	t.equal( isObjectArray( out ), true, 'returns an object array' );
-	t.equal( out.length, 24, 'returned array has expected length' );
+	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( out.length, 24, 'returned array has expected length' );
 
 	for ( i = 0; i < out.length; i++ ) {
 		if ( out[ i ].name === 'Barack Obama' ) {
@@ -279,10 +279,10 @@ tape( 'if provided multiple options, the function returns the union', function t
 			counters.party += 1;
 		}
 	}
-	t.equal( counters.name, 8, 'returns speeches by name' );
-	t.equal( counters.year, 2, 'returns speeches by year' );
-	t.equal( counters.range, 10, 'returns speeches by range' );
-	t.equal( counters.party, 4, 'returns speeches by party' );
+	t.strictEqual( counters.name, 8, 'returns speeches by name' );
+	t.strictEqual( counters.year, 2, 'returns speeches by year' );
+	t.strictEqual( counters.range, 10, 'returns speeches by range' );
+	t.strictEqual( counters.party, 4, 'returns speeches by party' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.re_filename.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.re_filename.js
index 922b1b8528d8..0163bc92336f 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.re_filename.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.re_filename.js
@@ -29,7 +29,7 @@ var RE = require( './../lib/re_filename.js' );
 
 tape( 'main export is a regular expression', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( isRegExp( RE ), true, 'main export is a regular expression' );
+	t.strictEqual( isRegExp( RE ), true, 'main export is a regular expression' );
 	t.end();
 });
 
@@ -37,16 +37,16 @@ tape( 'the regular expression can be used to test for file name convention for n
 	var bool;
 
 	bool = RE.test( 'beep.txt' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = RE.test( 'beep.json' );
-	t.equal( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns false' );
 
 	bool = RE.test( '2008_barack_obama_d.json' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	bool = RE.test( '2008_barack_obama_d.txt' );
-	t.equal( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns true' );
 
 	t.end();
 });
@@ -58,9 +58,9 @@ tape( 'the regular expression matches the year, President name, and party abbrev
 	str = '2008_barack_obama_d.txt';
 	parts = str.match( RE );
 
-	t.equal( parts[ 1 ], '2008', 'matches the year' );
-	t.equal( parts[ 2 ], 'barack_obama', 'matches the President name' );
-	t.equal( parts[ 3 ], 'd', 'matches the party abbreviation' );
+	t.strictEqual( parts[ 1 ], '2008', 'matches the year' );
+	t.strictEqual( parts[ 2 ], 'barack_obama', 'matches the President name' );
+	t.strictEqual( parts[ 3 ], 'd', 'matches the party abbreviation' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.union.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.union.js
index 34e12a901751..c9e4064f3f7f 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.union.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.union.js
@@ -48,9 +48,9 @@ tape( 'the function computes the union of array elements', function test( t ) {
 	actual = union( arr1, arr2, arr3 );
 	expected = [ '1', '5', '2', '3', '7', '11', '9' ];
 
-	t.equal( actual.length, expected.length, 'has expected length' );
+	t.strictEqual( actual.length, expected.length, 'has expected length' );
 	for ( i = 0; i < expected.length; i++ ) {
-		t.equal( indexOf( actual, expected[ i ] ) !== -1, true, 'has element '+expected[i] );
+		t.strictEqual( indexOf( actual, expected[ i ] ) !== -1, true, 'has element '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.unsnakecase.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.unsnakecase.js
index 5631824ebb40..708ee05bf04d 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.unsnakecase.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.unsnakecase.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function converts a snakecase name to a normal name', function test( t ) {
 	var out = unsnakecase( 'william_j_clinton' );
-	t.equal( out, 'William J Clinton', 'converts snakecase name' );
+	t.strictEqual( out, 'William J Clinton', 'converts snakecase name' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.validate.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.validate.js
index d6e96d472855..fcfb0ae62265 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.validate.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.validate.js
@@ -76,7 +76,7 @@ tape( 'the function returns an error if provided a `name` option which is not a
 		err = validate( {}, {
 			'name': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns an error if provided a `party` option which is not a
 		err = validate( {}, {
 			'party': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function returns an error if provided a `year` option which is not a
 		err = validate( {}, {
 			'year': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the function returns an error if provided a `range` option which is not a
 		err = validate( {}, {
 			'range': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -177,7 +177,7 @@ tape( 'the function returns an error if provided a `range` option whose first va
 		err = validate( {}, {
 			'range': values[ i ]
 		});
-		t.equal( err instanceof RangeError, true, 'returns a range error when provided '+values[i] );
+		t.strictEqual( err instanceof RangeError, true, 'returns a range error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -196,7 +196,7 @@ tape( 'the function returns an error if provided a `range` option whose second v
 		err = validate( {}, {
 			'range': values[ i ]
 		});
-		t.equal( err instanceof RangeError, true, 'returns a range error when provided '+values[i] );
+		t.strictEqual( err instanceof RangeError, true, 'returns a range error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -223,7 +223,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'sets option values' );
 
 	options = {
@@ -242,7 +242,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'sets option values' );
 
 	t.end();
@@ -260,7 +260,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/spache-revised/test/test.browser.js b/lib/node_modules/@stdlib/datasets/spache-revised/test/test.browser.js
index 7b72031b2f28..9e6cc171e725 100644
--- a/lib/node_modules/@stdlib/datasets/spache-revised/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/spache-revised/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var list = words();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/spache-revised/test/test.js b/lib/node_modules/@stdlib/datasets/spache-revised/test/test.js
index f9e246b9bb1a..d30e4c2ab9c1 100644
--- a/lib/node_modules/@stdlib/datasets/spache-revised/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/spache-revised/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var list = words();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/ssa-us-births-2000-2014/test/test.browser.js b/lib/node_modules/@stdlib/datasets/ssa-us-births-2000-2014/test/test.browser.js
index 95fbecf919fa..655d022b6138 100644
--- a/lib/node_modules/@stdlib/datasets/ssa-us-births-2000-2014/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/ssa-us-births-2000-2014/test/test.browser.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'returns expected value' );
-	t.equal( data.length > 0, true, 'is not empty' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
+	t.strictEqual( data.length > 0, true, 'is not empty' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the function returns a copy', function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/datasets/ssa-us-births-2000-2014/test/test.js b/lib/node_modules/@stdlib/datasets/ssa-us-births-2000-2014/test/test.js
index 90758183742a..8f39c553d30f 100644
--- a/lib/node_modules/@stdlib/datasets/ssa-us-births-2000-2014/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/ssa-us-births-2000-2014/test/test.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array', opts, function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'returns expected value' );
-	t.equal( data.length > 0, true, 'is not empty' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
+	t.strictEqual( data.length > 0, true, 'is not empty' );
 	t.end();
 });
 
@@ -59,7 +59,7 @@ tape( 'the function returns a copy', opts, function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/datasets/standard-card-deck/test/test.browser.js b/lib/node_modules/@stdlib/datasets/standard-card-deck/test/test.browser.js
index d8515b73bcce..194c6d9cb8df 100644
--- a/lib/node_modules/@stdlib/datasets/standard-card-deck/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/standard-card-deck/test/test.browser.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var list = cards();
-	t.equal( isStringArray( list ), true, 'returns an array of strings' );
-	t.equal( list.length, 52, 'has length of 52' );
+	t.strictEqual( isStringArray( list ), true, 'returns an array of strings' );
+	t.strictEqual( list.length, 52, 'has length of 52' );
 	t.end();
 });
 
@@ -51,9 +51,9 @@ tape( 'the function returns a copy', function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
-	t.equal( l2[ 5 ], '6C', 'expected element' );
+	t.strictEqual( l2[ 5 ], '6C', 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/standard-card-deck/test/test.js b/lib/node_modules/@stdlib/datasets/standard-card-deck/test/test.js
index 65c90ca6415e..b590de7a8b3f 100644
--- a/lib/node_modules/@stdlib/datasets/standard-card-deck/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/standard-card-deck/test/test.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var list = cards();
-	t.equal( isStringArray( list ), true, 'returns an array of strings' );
-	t.equal( list.length, 52, 'has length of 52' );
+	t.strictEqual( isStringArray( list ), true, 'returns an array of strings' );
+	t.strictEqual( list.length, 52, 'has length of 52' );
 	t.end();
 });
 
@@ -59,9 +59,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 
 	l1[ 5 ] = 'beep';
 
-	t.equal( l1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( l1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( l1[ 5 ], l2[ 5 ], 'no shared state' );
-	t.equal( l2[ 5 ], '6C', 'expected element' );
+	t.strictEqual( l2[ 5 ], '6C', 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/stopwords-en/test/test.browser.js b/lib/node_modules/@stdlib/datasets/stopwords-en/test/test.browser.js
index 4b6322dbb87b..c76af28dc0cb 100644
--- a/lib/node_modules/@stdlib/datasets/stopwords-en/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/stopwords-en/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/stopwords-en/test/test.js b/lib/node_modules/@stdlib/datasets/stopwords-en/test/test.js
index 3abc73296f4c..17322cbc627d 100644
--- a/lib/node_modules/@stdlib/datasets/stopwords-en/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/stopwords-en/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var list = stopwords();
-	t.equal( isStringArray( list ), true, 'main export is a string array' );
+	t.strictEqual( isStringArray( list ), true, 'main export is a string array' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/suthaharan-multi-hop-sensor-network/test/test.browser.js b/lib/node_modules/@stdlib/datasets/suthaharan-multi-hop-sensor-network/test/test.browser.js
index 44cdbd000aa9..ba0817e9c29f 100644
--- a/lib/node_modules/@stdlib/datasets/suthaharan-multi-hop-sensor-network/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/suthaharan-multi-hop-sensor-network/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'main export is an array of objects' );
+	t.strictEqual( isObjectArray( data ), true, 'main export is an array of objects' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/suthaharan-multi-hop-sensor-network/test/test.js b/lib/node_modules/@stdlib/datasets/suthaharan-multi-hop-sensor-network/test/test.js
index 4bdfd669d072..6459117481b1 100644
--- a/lib/node_modules/@stdlib/datasets/suthaharan-multi-hop-sensor-network/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/suthaharan-multi-hop-sensor-network/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', opts, function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'main export is an array of objects' );
+	t.strictEqual( isObjectArray( data ), true, 'main export is an array of objects' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/suthaharan-single-hop-sensor-network/test/test.browser.js b/lib/node_modules/@stdlib/datasets/suthaharan-single-hop-sensor-network/test/test.browser.js
index 44cdbd000aa9..ba0817e9c29f 100644
--- a/lib/node_modules/@stdlib/datasets/suthaharan-single-hop-sensor-network/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/suthaharan-single-hop-sensor-network/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'main export is an array of objects' );
+	t.strictEqual( isObjectArray( data ), true, 'main export is an array of objects' );
 	t.end();
 });
 
@@ -52,9 +52,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/suthaharan-single-hop-sensor-network/test/test.js b/lib/node_modules/@stdlib/datasets/suthaharan-single-hop-sensor-network/test/test.js
index 4bdfd669d072..6459117481b1 100644
--- a/lib/node_modules/@stdlib/datasets/suthaharan-single-hop-sensor-network/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/suthaharan-single-hop-sensor-network/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', opts, function test( t ) {
 	var data = dataset();
-	t.equal( isObjectArray( data ), true, 'main export is an array of objects' );
+	t.strictEqual( isObjectArray( data ), true, 'main export is an array of objects' );
 	t.end();
 });
 
@@ -60,9 +60,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/test/test.js b/lib/node_modules/@stdlib/datasets/test/test.js
index 52a3e80517ea..e3173ecd0aad 100644
--- a/lib/node_modules/@stdlib/datasets/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/test/test.js
@@ -36,8 +36,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns datasets', function test( t ) {
 	var data = datasets( 'MONTH_NAMES_EN' );
-	t.equal( isArray( data ), true, 'returns an array' );
-	t.equal( data.length, 12, 'has length of 12' );
+	t.strictEqual( isArray( data ), true, 'returns an array' );
+	t.strictEqual( data.length, 12, 'has length of 12' );
 	t.end();
 });
 
@@ -50,7 +50,7 @@ tape( 'the function supports dataset options', function tests( t ) {
 	};
 	data = datasets( 'SOTU', opts );
 
-	t.equal( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/datasets/us-states-abbr/test/test.browser.js b/lib/node_modules/@stdlib/datasets/us-states-abbr/test/test.browser.js
index 3eda68012a6f..5517450baedc 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-abbr/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-abbr/test/test.browser.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var data = abbr();
-	t.equal( isStringArray( data ), true, 'returns an array of strings' );
-	t.equal( data.length, 50, 'has length of 50' );
+	t.strictEqual( isStringArray( data ), true, 'returns an array of strings' );
+	t.strictEqual( data.length, 50, 'has length of 50' );
 	t.end();
 });
 
@@ -53,9 +53,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/us-states-abbr/test/test.js b/lib/node_modules/@stdlib/datasets/us-states-abbr/test/test.js
index e61eb106daa7..330630de015c 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-abbr/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-abbr/test/test.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var data = abbr();
-	t.equal( isStringArray( data ), true, 'returns an array of strings' );
-	t.equal( data.length, 50, 'has length of 50' );
+	t.strictEqual( isStringArray( data ), true, 'returns an array of strings' );
+	t.strictEqual( data.length, 50, 'has length of 50' );
 	t.end();
 });
 
@@ -61,9 +61,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.browser.js b/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.browser.js
index 3e2009553a67..86618474dd28 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.browser.js
@@ -36,20 +36,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var tbl = table();
-	t.equal( isObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isObject( tbl ), true, 'returns an object' );
 	t.end();
 });
 
 tape( 'the returned object has 50 keys', function test( t ) {
 	var tbl = table();
-	t.equal( objectKeys( tbl ).length, 50, 'has 50 keys' );
+	t.strictEqual( objectKeys( tbl ).length, 50, 'has 50 keys' );
 	t.end();
 });
 
 tape( 'the returned object maps US state capitals to state names', function test( t ) {
 	var tbl = table();
-	t.equal( tbl[ 'Jefferson City' ], 'Missouri', 'returns Missouri' );
-	t.equal( tbl[ 'Trenton' ], 'New Jersey', 'returns New Jersey' );
-	t.equal( tbl[ 'Sacramento' ], 'California', 'returns California' );
+	t.strictEqual( tbl[ 'Jefferson City' ], 'Missouri', 'returns Missouri' );
+	t.strictEqual( tbl[ 'Trenton' ], 'New Jersey', 'returns New Jersey' );
+	t.strictEqual( tbl[ 'Sacramento' ], 'California', 'returns California' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.js b/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.js
index befcd044447d..7f87b43c2aeb 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', opts, function test( t ) {
 	var tbl = table();
-	t.equal( isObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isObject( tbl ), true, 'returns an object' );
 	t.end();
 });
 
 tape( 'the returned object has 50 keys', opts, function test( t ) {
 	var tbl = table();
-	t.equal( objectKeys( tbl ).length, 50, 'has 50 keys' );
+	t.strictEqual( objectKeys( tbl ).length, 50, 'has 50 keys' );
 	t.end();
 });
 
 tape( 'the returned object maps US state capitals to state names', opts, function test( t ) {
 	var tbl = table();
-	t.equal( tbl[ 'Jefferson City' ], 'Missouri', 'returns Missouri' );
-	t.equal( tbl[ 'Trenton' ], 'New Jersey', 'returns New Jersey' );
-	t.equal( tbl[ 'Sacramento' ], 'California', 'returns California' );
+	t.strictEqual( tbl[ 'Jefferson City' ], 'Missouri', 'returns Missouri' );
+	t.strictEqual( tbl[ 'Trenton' ], 'New Jersey', 'returns New Jersey' );
+	t.strictEqual( tbl[ 'Sacramento' ], 'California', 'returns California' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/us-states-capitals/test/test.browser.js b/lib/node_modules/@stdlib/datasets/us-states-capitals/test/test.browser.js
index 7fac1fc9296c..7502a66d0b7c 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-capitals/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-capitals/test/test.browser.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var data = capitals();
-	t.equal( isStringArray( data ), true, 'returns an array of strings' );
-	t.equal( data.length, 50, 'has length of 50' );
+	t.strictEqual( isStringArray( data ), true, 'returns an array of strings' );
+	t.strictEqual( data.length, 50, 'has length of 50' );
 	t.end();
 });
 
@@ -53,9 +53,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/us-states-capitals/test/test.js b/lib/node_modules/@stdlib/datasets/us-states-capitals/test/test.js
index 1836f38cb744..94416711e6a9 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-capitals/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-capitals/test/test.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var data = capitals();
-	t.equal( isStringArray( data ), true, 'returns an array of strings' );
-	t.equal( data.length, 50, 'has length of 50' );
+	t.strictEqual( isStringArray( data ), true, 'returns an array of strings' );
+	t.strictEqual( data.length, 50, 'has length of 50' );
 	t.end();
 });
 
@@ -61,9 +61,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.browser.js b/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.browser.js
index ec8746d1b889..d309081284f0 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.browser.js
@@ -36,20 +36,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var tbl = table();
-	t.equal( isObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isObject( tbl ), true, 'returns an object' );
 	t.end();
 });
 
 tape( 'the returned object has 50 keys', function test( t ) {
 	var tbl = table();
-	t.equal( objectKeys( tbl ).length, 50, 'has 50 keys' );
+	t.strictEqual( objectKeys( tbl ).length, 50, 'has 50 keys' );
 	t.end();
 });
 
 tape( 'the returned object maps US state names to state capitals', function test( t ) {
 	var tbl = table();
-	t.equal( tbl[ 'Missouri' ], 'Jefferson City', 'returns capital of Missouri' );
-	t.equal( tbl[ 'New Jersey' ], 'Trenton', 'returns capital of New Jersey' );
-	t.equal( tbl[ 'California' ], 'Sacramento', 'returns capital of California' );
+	t.strictEqual( tbl[ 'Missouri' ], 'Jefferson City', 'returns capital of Missouri' );
+	t.strictEqual( tbl[ 'New Jersey' ], 'Trenton', 'returns capital of New Jersey' );
+	t.strictEqual( tbl[ 'California' ], 'Sacramento', 'returns capital of California' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.js b/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.js
index 0c8227517976..7bc853f33d0c 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', opts, function test( t ) {
 	var tbl = table();
-	t.equal( isObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isObject( tbl ), true, 'returns an object' );
 	t.end();
 });
 
 tape( 'the returned object has 50 keys', opts, function test( t ) {
 	var tbl = table();
-	t.equal( objectKeys( tbl ).length, 50, 'has 50 keys' );
+	t.strictEqual( objectKeys( tbl ).length, 50, 'has 50 keys' );
 	t.end();
 });
 
 tape( 'the returned object maps US state names to state capitals', opts, function test( t ) {
 	var tbl = table();
-	t.equal( tbl[ 'Missouri' ], 'Jefferson City', 'returns capital of Missouri' );
-	t.equal( tbl[ 'New Jersey' ], 'Trenton', 'returns capital of New Jersey' );
-	t.equal( tbl[ 'California' ], 'Sacramento', 'returns capital of California' );
+	t.strictEqual( tbl[ 'Missouri' ], 'Jefferson City', 'returns capital of Missouri' );
+	t.strictEqual( tbl[ 'New Jersey' ], 'Trenton', 'returns capital of New Jersey' );
+	t.strictEqual( tbl[ 'California' ], 'Sacramento', 'returns capital of California' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/us-states-names/test/test.browser.js b/lib/node_modules/@stdlib/datasets/us-states-names/test/test.browser.js
index f573dd12176f..fcea7c6b5845 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-names/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-names/test/test.browser.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', function test( t ) {
 	var data = names();
-	t.equal( isStringArray( data ), true, 'returns an array of strings' );
-	t.equal( data.length, 50, 'has length of 50' );
+	t.strictEqual( isStringArray( data ), true, 'returns an array of strings' );
+	t.strictEqual( data.length, 50, 'has length of 50' );
 	t.end();
 });
 
@@ -53,9 +53,9 @@ tape( 'the function returns a copy', function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/us-states-names/test/test.js b/lib/node_modules/@stdlib/datasets/us-states-names/test/test.js
index b0e7104b89d8..4ed5c8d6501b 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-names/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-names/test/test.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of strings', opts, function test( t ) {
 	var data = names();
-	t.equal( isStringArray( data ), true, 'returns an array of strings' );
-	t.equal( data.length, 50, 'has length of 50' );
+	t.strictEqual( isStringArray( data ), true, 'returns an array of strings' );
+	t.strictEqual( data.length, 50, 'has length of 50' );
 	t.end();
 });
 
@@ -61,9 +61,9 @@ tape( 'the function returns a copy', opts, function test( t ) {
 	v = d2[ 5 ];
 	d1[ 5 ] = 'beep';
 
-	t.equal( d1[ 5 ], 'beep', 'expected element' );
+	t.strictEqual( d1[ 5 ], 'beep', 'expected element' );
 	t.notEqual( d1[ 5 ], d2[ 5 ], 'no shared state' );
-	t.equal( d2[ 5 ], v, 'expected element' );
+	t.strictEqual( d2[ 5 ], v, 'expected element' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/exists/test/test.async.js b/lib/node_modules/@stdlib/fs/exists/test/test.async.js
index ca581cb59402..7def4e2287f8 100644
--- a/lib/node_modules/@stdlib/fs/exists/test/test.async.js
+++ b/lib/node_modules/@stdlib/fs/exists/test/test.async.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns true if a path exists', opts, function test( t ) {
 	exists( __filename, onExists );
 	function onExists( bool ) {
-		t.equal( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns true' );
 		t.end();
 	}
 });
@@ -54,7 +54,7 @@ tape( 'the function returns true if a path exists', opts, function test( t ) {
 tape( 'the function returns false if a path does not exist', opts, function test( t ) {
 	exists( 'beepboopbebop', onExists );
 	function onExists( bool ) {
-		t.equal( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns false' );
 		t.end();
 	}
 });
@@ -68,7 +68,7 @@ tape( 'if `fs.access` is not supported, the function uses `fs.stat`', opts, func
 	});
 	exists( __filename, onExists );
 	function onExists( bool ) {
-		t.equal( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns true' );
 		t.end();
 	}
 });
@@ -82,7 +82,7 @@ tape( 'if `fs.access` is not supported, the function uses `fs.stat`', opts, func
 	});
 	exists( 'beepboopbebop', onExists );
 	function onExists( bool ) {
-		t.equal( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns false' );
 		t.end();
 	}
 });
@@ -90,8 +90,8 @@ tape( 'if `fs.access` is not supported, the function uses `fs.stat`', opts, func
 tape( 'the function supports error-first callbacks (success)', opts, function test( t ) {
 	exists( __filename, onExists );
 	function onExists( error, bool ) {
-		t.equal( error, null, 'error is null' );
-		t.equal( bool, true, 'returns true' );
+		t.strictEqual( error, null, 'error is null' );
+		t.strictEqual( bool, true, 'returns true' );
 		t.end();
 	}
 });
@@ -100,7 +100,7 @@ tape( 'the function supports error-first callbacks (failure)', opts, function te
 	exists( 'beepboopbebop', onExists );
 	function onExists( error, bool ) {
 		t.ok( error, 'returns an error' );
-		t.equal( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns false' );
 		t.end();
 	}
 });
@@ -114,8 +114,8 @@ tape( 'the function supports using `fs.stat` with error-first callbacks (success
 	});
 	exists( __filename, onExists );
 	function onExists( error, bool ) {
-		t.equal( error, null, 'error is null' );
-		t.equal( bool, true, 'returns true' );
+		t.strictEqual( error, null, 'error is null' );
+		t.strictEqual( bool, true, 'returns true' );
 		t.end();
 	}
 });
@@ -130,7 +130,7 @@ tape( 'the function supports using `fs.stat` with error-first callbacks (failure
 	exists( 'beepboopbebop', onExists );
 	function onExists( error, bool ) {
 		t.ok( error, 'returns an error' );
-		t.equal( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns false' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/fs/exists/test/test.js b/lib/node_modules/@stdlib/fs/exists/test/test.js
index 231a0b09066e..93ebbf78a3b6 100644
--- a/lib/node_modules/@stdlib/fs/exists/test/test.js
+++ b/lib/node_modules/@stdlib/fs/exists/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'export includes a function to test for existence synchronously', function test( t ) {
-	t.equal( typeof exists.sync, 'function', 'export is a function' );
+	t.strictEqual( typeof exists.sync, 'function', 'export is a function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/exists/test/test.sync.js b/lib/node_modules/@stdlib/fs/exists/test/test.sync.js
index 1671038e24ed..977717f7dd10 100644
--- a/lib/node_modules/@stdlib/fs/exists/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/exists/test/test.sync.js
@@ -44,12 +44,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns true if a path exists', opts, function test( t ) {
-	t.equal( exists( __filename ), true, 'returns true' );
+	t.strictEqual( exists( __filename ), true, 'returns true' );
 	t.end();
 });
 
 tape( 'the function returns false if a path does not exists', opts, function test( t ) {
-	t.equal( exists( 'beepboopbebop' ), false, 'returns false' );
+	t.strictEqual( exists( 'beepboopbebop' ), false, 'returns false' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'if `fs.access` is not supported, the function uses `fs.statSync`', opts,
 			'accessSync': void 0
 		}
 	});
-	t.equal( exists( __filename ), true, 'returns true' );
+	t.strictEqual( exists( __filename ), true, 'returns true' );
 	t.end();
 });
 
@@ -71,6 +71,6 @@ tape( 'the function should negatively test using `statSync`', opts, function tes
 			'accessSync': void 0
 		}
 	});
-	t.equal( exists( 'beepboopbebop' ), false, 'returns false' );
+	t.strictEqual( exists( 'beepboopbebop' ), false, 'returns false' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/open/test/test.js b/lib/node_modules/@stdlib/fs/open/test/test.js
index 3c471358ff95..af1e37e20508 100644
--- a/lib/node_modules/@stdlib/fs/open/test/test.js
+++ b/lib/node_modules/@stdlib/fs/open/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a function to open a file synchronously', function test( t ) {
-	t.equal( typeof open.sync, 'function', 'has method' );
+	t.strictEqual( typeof open.sync, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/open/test/test.main.js b/lib/node_modules/@stdlib/fs/open/test/test.main.js
index 3b91f6f9ca76..5ab6ea29c220 100644
--- a/lib/node_modules/@stdlib/fs/open/test/test.main.js
+++ b/lib/node_modules/@stdlib/fs/open/test/test.main.js
@@ -50,7 +50,7 @@ tape( 'the function opens a file', opts, function test( t ) {
 		if ( error ) {
 			t.fail( error.message );
 		}
-		t.equal( isNonNegativeInteger( fd ), true, 'returns a file descriptor' );
+		t.strictEqual( isNonNegativeInteger( fd ), true, 'returns a file descriptor' );
 		closeSync( fd );
 		t.end();
 	}
@@ -63,7 +63,7 @@ tape( 'the function opens a file (flags)', opts, function test( t ) {
 		if ( error ) {
 			t.fail( error.message );
 		}
-		t.equal( isNonNegativeInteger( fd ), true, 'returns a file descriptor' );
+		t.strictEqual( isNonNegativeInteger( fd ), true, 'returns a file descriptor' );
 		closeSync( fd );
 		t.end();
 	}
@@ -76,7 +76,7 @@ tape( 'the function opens a file (flags+mode)', opts, function test( t ) {
 		if ( error ) {
 			t.fail( error.message );
 		}
-		t.equal( isNonNegativeInteger( fd ), true, 'returns a file descriptor' );
+		t.strictEqual( isNonNegativeInteger( fd ), true, 'returns a file descriptor' );
 		closeSync( fd );
 		t.end();
 	}
@@ -86,7 +86,7 @@ tape( 'if the function encounters an error, the function returns the error', opt
 	open( 'beepboopbapbop', onOpen );
 
 	function onOpen( error ) {
-		t.equal( error instanceof Error, true, error.message );
+		t.strictEqual( error instanceof Error, true, error.message );
 		t.end();
 	}
 });
@@ -95,7 +95,7 @@ tape( 'if the function encounters an error, the function returns the error (flag
 	open( 'beepboopbapbop', 'r+', onOpen );
 
 	function onOpen( error ) {
-		t.equal( error instanceof Error, true, error.message );
+		t.strictEqual( error instanceof Error, true, error.message );
 		t.end();
 	}
 });
@@ -104,7 +104,7 @@ tape( 'if the function encounters an error, the function returns the error (flag
 	open( 'beepboopbapbop', 'r+', 438, onOpen );
 
 	function onOpen( error ) {
-		t.equal( error instanceof Error, true, error.message );
+		t.strictEqual( error instanceof Error, true, error.message );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/fs/open/test/test.sync.js b/lib/node_modules/@stdlib/fs/open/test/test.sync.js
index cc8801ace21c..40f7b90fa2ac 100644
--- a/lib/node_modules/@stdlib/fs/open/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/open/test/test.sync.js
@@ -45,39 +45,39 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function opens a file', opts, function test( t ) {
 	var fd = open( __filename );
-	t.equal( isNonNegativeInteger( fd ), true, 'returns a file descriptor' );
+	t.strictEqual( isNonNegativeInteger( fd ), true, 'returns a file descriptor' );
 	closeSync( fd );
 	t.end();
 });
 
 tape( 'the function opens a file (flags)', opts, function test( t ) {
 	var fd = open( __filename, 'r+' );
-	t.equal( isNonNegativeInteger( fd ), true, 'returns a file descriptor' );
+	t.strictEqual( isNonNegativeInteger( fd ), true, 'returns a file descriptor' );
 	closeSync( fd );
 	t.end();
 });
 
 tape( 'the function opens a file (flags+mode)', opts, function test( t ) {
 	var fd = open( __filename, 'r+', 438 );
-	t.equal( isNonNegativeInteger( fd ), true, 'returns a file descriptor' );
+	t.strictEqual( isNonNegativeInteger( fd ), true, 'returns a file descriptor' );
 	closeSync( fd );
 	t.end();
 });
 
 tape( 'if the function encounters an error, the function returns the error', opts, function test( t ) {
 	var fd = open( 'beepboopbapbop' );
-	t.equal( fd instanceof Error, true, 'returns an error' );
+	t.strictEqual( fd instanceof Error, true, 'returns an error' );
 	t.end();
 });
 
 tape( 'if the function encounters an error, the function returns the error (flags)', opts, function test( t ) {
 	var fd = open( 'beepboopbapbop', 'r+' );
-	t.equal( fd instanceof Error, true, 'returns an error' );
+	t.strictEqual( fd instanceof Error, true, 'returns an error' );
 	t.end();
 });
 
 tape( 'if the function encounters an error, the function returns the error (flags+mode)', opts, function test( t ) {
 	var fd = open( 'beepboopbapbop', 'r+', 438 );
-	t.equal( fd instanceof Error, true, 'returns an error' );
+	t.strictEqual( fd instanceof Error, true, 'returns an error' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/read-dir/test/test.async.js b/lib/node_modules/@stdlib/fs/read-dir/test/test.async.js
index 7fda1db3cb44..02a4a42f18b9 100644
--- a/lib/node_modules/@stdlib/fs/read-dir/test/test.async.js
+++ b/lib/node_modules/@stdlib/fs/read-dir/test/test.async.js
@@ -62,7 +62,7 @@ tape( 'if the function encounters an error, the function returns the error', opt
 	readDir( 'beepboopbapbop', onRead );
 
 	function onRead( error ) {
-		t.equal( error instanceof Error, true, 'returns an error' );
+		t.strictEqual( error instanceof Error, true, 'returns an error' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/fs/read-dir/test/test.js b/lib/node_modules/@stdlib/fs/read-dir/test/test.js
index 8860c0c212fb..97459ea5e1e6 100644
--- a/lib/node_modules/@stdlib/fs/read-dir/test/test.js
+++ b/lib/node_modules/@stdlib/fs/read-dir/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a function to read a directory synchronously', function test( t ) {
-	t.equal( typeof readDir.sync, 'function', 'attached method for synchronously reading a directory' );
+	t.strictEqual( typeof readDir.sync, 'function', 'attached method for synchronously reading a directory' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/read-dir/test/test.sync.js b/lib/node_modules/@stdlib/fs/read-dir/test/test.sync.js
index b7a1a4efcde9..a52f4d1fd122 100644
--- a/lib/node_modules/@stdlib/fs/read-dir/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/read-dir/test/test.sync.js
@@ -57,7 +57,7 @@ tape( 'the function reads a directory', opts, function test( t ) {
 tape( 'if the function encounters an error, the function returns the error', opts, function test( t ) {
 	var out = readDir( 'beepboopbapbop' );
 
-	t.equal( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns an error' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/read-file-list/test/test.async.js b/lib/node_modules/@stdlib/fs/read-file-list/test/test.async.js
index 366a4a1b7e50..fb370dae520c 100644
--- a/lib/node_modules/@stdlib/fs/read-file-list/test/test.async.js
+++ b/lib/node_modules/@stdlib/fs/read-file-list/test/test.async.js
@@ -225,7 +225,7 @@ tape( 'if the function encounters an error, the function returns the error', opt
 	readFileList( [ 'beepboopbapbop' ], onFiles );
 
 	function onFiles( error ) {
-		t.equal( error instanceof Error, true, 'returns an error: '+error.message );
+		t.strictEqual( error instanceof Error, true, 'returns an error: '+error.message );
 
 		t.end();
 	}
@@ -235,7 +235,7 @@ tape( 'if the function encounters an error, the function returns the error (stri
 	readFileList( [ 'beepboopbapbop' ], 'utf8', onFiles );
 
 	function onFiles( error ) {
-		t.equal( error instanceof Error, true, 'returns an error: '+error.message );
+		t.strictEqual( error instanceof Error, true, 'returns an error: '+error.message );
 		t.end();
 	}
 });
@@ -246,7 +246,7 @@ tape( 'if the function encounters an error, the function returns the error (obje
 	}, onFiles );
 
 	function onFiles( error ) {
-		t.equal( error instanceof Error, true, 'returns an error: '+error.message );
+		t.strictEqual( error instanceof Error, true, 'returns an error: '+error.message );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/fs/read-file-list/test/test.clear_pending.js b/lib/node_modules/@stdlib/fs/read-file-list/test/test.clear_pending.js
index 1c823efc1351..35d429266ad0 100644
--- a/lib/node_modules/@stdlib/fs/read-file-list/test/test.clear_pending.js
+++ b/lib/node_modules/@stdlib/fs/read-file-list/test/test.clear_pending.js
@@ -60,7 +60,7 @@ tape( 'the function cancels each timeout present in a provided hash', function t
 	count = 0;
 	clearPending( pending );
 
-	t.equal( count, 3, 'invokes function expected number of times' );
+	t.strictEqual( count, 3, 'invokes function expected number of times' );
 	t.deepEqual( pending, {}, 'should cancel timeouts' );
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/fs/read-file-list/test/test.js b/lib/node_modules/@stdlib/fs/read-file-list/test/test.js
index 7795130f8f0b..d529e1df5f29 100644
--- a/lib/node_modules/@stdlib/fs/read-file-list/test/test.js
+++ b/lib/node_modules/@stdlib/fs/read-file-list/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a function to read files synchronously', function test( t ) {
-	t.equal( typeof readFileList.sync, 'function', 'attached method for synchronously reading file contents' );
+	t.strictEqual( typeof readFileList.sync, 'function', 'attached method for synchronously reading file contents' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/read-file-list/test/test.sync.js b/lib/node_modules/@stdlib/fs/read-file-list/test/test.sync.js
index 7adadcc58321..1cc5fe1f32c1 100644
--- a/lib/node_modules/@stdlib/fs/read-file-list/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/read-file-list/test/test.sync.js
@@ -155,7 +155,7 @@ tape( 'the function reads the contents of each file in a file list using provide
 tape( 'if the function encounters an error, the function returns the error', opts, function test( t ) {
 	var out = readFileList( [ 'beepboopbapbop' ] );
 
-	t.equal( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns an error' );
 
 	t.end();
 });
@@ -165,13 +165,13 @@ tape( 'if the function encounters an error, the function returns the error (opti
 	var out;
 
 	out = readFileList( [ 'beepboopbapbop' ], 'utf8' );
-	t.equal( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns an error' );
 
 	opts = {
 		'encoding': 'utf8'
 	};
 	out = readFileList( [ 'beepboopbapbop' ], opts );
-	t.equal( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns an error' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/read-file/test/test.js b/lib/node_modules/@stdlib/fs/read-file/test/test.js
index 6eb1bbf598f7..6d785dfdbf4a 100644
--- a/lib/node_modules/@stdlib/fs/read-file/test/test.js
+++ b/lib/node_modules/@stdlib/fs/read-file/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a function to read an entire file synchronously', function test( t ) {
-	t.equal( typeof readFile.sync, 'function', 'attached method for synchronously reading file contents' );
+	t.strictEqual( typeof readFile.sync, 'function', 'attached method for synchronously reading file contents' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/read-file/test/test.main.js b/lib/node_modules/@stdlib/fs/read-file/test/test.main.js
index a5333d5a2edf..8cf2c3facd3e 100644
--- a/lib/node_modules/@stdlib/fs/read-file/test/test.main.js
+++ b/lib/node_modules/@stdlib/fs/read-file/test/test.main.js
@@ -93,7 +93,7 @@ tape( 'if the function encounters an error, the function returns the error', opt
 	readFile( 'beepboopbapbop', onFile );
 
 	function onFile( error ) {
-		t.equal( error instanceof Error, true, error.message );
+		t.strictEqual( error instanceof Error, true, error.message );
 		t.end();
 	}
 });
@@ -102,7 +102,7 @@ tape( 'if the function encounters an error, the function returns the error (opti
 	readFile( 'beepboopbapbop', 'utf8', onFile );
 
 	function onFile( error ) {
-		t.equal( error instanceof Error, true, error.message );
+		t.strictEqual( error instanceof Error, true, error.message );
 		t.end();
 	}
 });
@@ -114,7 +114,7 @@ tape( 'if the function encounters an error, the function returns the error (opti
 	readFile( 'beepboopbapbop', opts, onFile );
 
 	function onFile( error ) {
-		t.equal( error instanceof Error, true, error.message );
+		t.strictEqual( error instanceof Error, true, error.message );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/fs/read-file/test/test.sync.js b/lib/node_modules/@stdlib/fs/read-file/test/test.sync.js
index 82b3eb1a9f00..122acb995feb 100644
--- a/lib/node_modules/@stdlib/fs/read-file/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/read-file/test/test.sync.js
@@ -83,13 +83,13 @@ tape( 'the function reads the contents of a file using provided options (option
 
 tape( 'if the function encounters an error, the function returns the error', opts, function test( t ) {
 	var out = readFile( 'beepboopbapbop' );
-	t.equal( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns an error' );
 	t.end();
 });
 
 tape( 'if the function encounters an error, the function returns the error (option string)', opts, function test( t ) {
 	var out = readFile( 'beepboopbapbop', 'utf8' );
-	t.equal( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns an error' );
 	t.end();
 });
 
@@ -101,7 +101,7 @@ tape( 'if the function encounters an error, the function returns the error (opti
 		'encoding': 'utf8'
 	};
 	out = readFile( 'beepboopbapbop', opts );
-	t.equal( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns an error' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.js b/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.js
index 8bb3b79a0b29..58f2e4216aa7 100644
--- a/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.js
+++ b/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a function to resolve a parent path synchronously', function test( t ) {
-	t.equal( typeof resolveParentPathBy.sync, 'function', 'has `sync` method' );
+	t.strictEqual( typeof resolveParentPathBy.sync, 'function', 'has `sync` method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.validate.js b/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.validate.js
index de15ad39f0bc..8f2432fbb6cf 100644
--- a/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -95,8 +95,8 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.js b/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.js
index 3bac8276a712..33f481682f63 100644
--- a/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.js
+++ b/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a function to resolve a parent path synchronously', function test( t ) {
-	t.equal( typeof resolveParentPath.sync, 'function', 'has `sync` method' );
+	t.strictEqual( typeof resolveParentPath.sync, 'function', 'has `sync` method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.validate.js b/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.validate.js
index 719671710301..0128fe87cbd2 100644
--- a/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.validate.js
+++ b/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `dir` option which is not a `string`, the function returns
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -95,8 +95,8 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.dir, opts.dir, 'sets dir option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/fs/resolve-parent-paths/test/test.js b/lib/node_modules/@stdlib/fs/resolve-parent-paths/test/test.js
index 38ab906fcd48..cf21120484b3 100644
--- a/lib/node_modules/@stdlib/fs/resolve-parent-paths/test/test.js
+++ b/lib/node_modules/@stdlib/fs/resolve-parent-paths/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a function to resolve parent paths synchronously', function test( t ) {
-	t.equal( typeof resolveParentPaths.sync, 'function', 'has `sync` method' );
+	t.strictEqual( typeof resolveParentPaths.sync, 'function', 'has `sync` method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/resolve-parent-paths/test/test.validate.js b/lib/node_modules/@stdlib/fs/resolve-parent-paths/test/test.validate.js
index fbb6a8425a2f..280e92755077 100644
--- a/lib/node_modules/@stdlib/fs/resolve-parent-paths/test/test.validate.js
+++ b/lib/node_modules/@stdlib/fs/resolve-parent-paths/test/test.validate.js
@@ -52,7 +52,7 @@ tape( 'if provided an `options` argument which is not an `object`, the function
 	for ( i = 0; i < values.length; i++ ) {
 		opts = {};
 		err = validate( opts, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'if provided a `dir` option which is not a string, the function returns a
 		err = validate( opts, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -107,7 +107,7 @@ tape( 'if provided a `mode` option which is not a valid mode, the function retur
 		err = validate( opts, {
 			'mode': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -124,9 +124,9 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns expected value' );
-	t.equal( obj.dir, opts.dir, 'returns expected value' );
-	t.equal( obj.mode, opts.mode, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
+	t.strictEqual( obj.dir, opts.dir, 'returns expected value' );
+	t.strictEqual( obj.mode, opts.mode, 'returns expected value' );
 
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns expected value' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'returns expected value' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/fs/test/test.js b/lib/node_modules/@stdlib/fs/test/test.js
index d84e777c1346..2c6589858167 100644
--- a/lib/node_modules/@stdlib/fs/test/test.js
+++ b/lib/node_modules/@stdlib/fs/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains utilities for interfacing with the filesystem', function test( t ) {
 	var keys = objectKeys( fs );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/concat/test/test.js b/lib/node_modules/@stdlib/iter/concat/test/test.js
index fdd0dc852beb..ba97edc36552 100644
--- a/lib/node_modules/@stdlib/iter/concat/test/test.js
+++ b/lib/node_modules/@stdlib/iter/concat/test/test.js
@@ -165,12 +165,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterConcat( randu(), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -208,7 +208,7 @@ tape( 'the function returns an iterator protocol-compliant object (2 finite iter
 	];
 
 	it = iterConcat( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values1.length+values2.length; i++ ) {
@@ -263,7 +263,7 @@ tape( 'the function returns an iterator protocol-compliant object (3 finite iter
 	];
 
 	it = iterConcat( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values1.length+values2.length+values3.length; i++ ) {
@@ -310,7 +310,7 @@ tape( 'the function returns an iterator protocol-compliant object (3 finite iter
 	];
 
 	it = iterConcat( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values1.length+values2.length+values3.length; i++ ) {
@@ -334,7 +334,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterConcat( iterEmpty(), iterEmpty(), iterEmpty(), iterEmpty() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -378,7 +378,7 @@ tape( 'the function returns an iterator protocol-compliant object (value+done)',
 	];
 
 	it = iterConcat( createIterator( values1 ), createIterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	N = values1.length + values2.length;
 	actual = [];
@@ -425,20 +425,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterConcat( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -450,20 +450,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterConcat( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -487,16 +487,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterConcat( rand, rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -514,7 +514,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterConcat( randu(), randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -532,7 +532,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterConcat( rand, rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/constant/test/test.js b/lib/node_modules/@stdlib/iter/constant/test/test.js
index 3ec312db8cbc..1175e33fdba4 100644
--- a/lib/node_modules/@stdlib/iter/constant/test/test.js
+++ b/lib/node_modules/@stdlib/iter/constant/test/test.js
@@ -140,7 +140,7 @@ tape( 'the function returns an iterator protocol-compliant object which always r
 	];
 
 	it = iterConstant( 3.14 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -183,7 +183,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterConstant( 3.14, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -230,12 +230,12 @@ tape( 'if provided an object reference, the function returns an iterator protoco
 		'iter': 4
 	};
 	it = iterConstant( v, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
 		actual.push( it.next() );
-		t.equal( actual[ i ].value, v, 'returns expected value' );
+		t.strictEqual( actual[ i ].value, v, 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -250,20 +250,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterConstant( 3.14 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -275,20 +275,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterConstant( 3.14 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -304,16 +304,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterConstant( 3.14 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -327,7 +327,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterConstant( 3.14 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/counter/test/test.js b/lib/node_modules/@stdlib/iter/counter/test/test.js
index c0b525b4d74b..b5e9fc8d79f5 100644
--- a/lib/node_modules/@stdlib/iter/counter/test/test.js
+++ b/lib/node_modules/@stdlib/iter/counter/test/test.js
@@ -72,7 +72,7 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterCounter( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	actual = [];
@@ -118,7 +118,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	];
 
 	it = iterCounter( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
@@ -137,20 +137,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCounter( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -162,20 +162,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCounter( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -199,16 +199,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterCounter( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -226,7 +226,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterCounter( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -244,7 +244,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterCounter( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/cuany-by/test/test.js b/lib/node_modules/@stdlib/iter/cuany-by/test/test.js
index 47a93b6717b1..3605358d5068 100644
--- a/lib/node_modules/@stdlib/iter/cuany-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cuany-by/test/test.js
@@ -120,10 +120,10 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	it = iterCuAnyBy( arr, predicate );
 	for ( i = 0; i < 5; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'boolean', 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
-	t.equal( typeof r.done, 'boolean', 'returns expected value' );
+	t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	t.end();
 });
 
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCuAnyBy( randu(), predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCuAnyBy( randu(), predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'foo' );
-	t.equal( r.value, 'foo', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'foo', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterCuAnyBy( rand, predicate );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterCuAnyBy( randu(), predicate);
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterCuAnyBy( rand, predicate );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -348,14 +348,14 @@ tape( 'the function supports specifying the predicate function execution context
 	];
 
 	it = iterCuAnyBy( array2iterator( values ), predicate, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
 		actual.push( it.next() );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, 3, 'returns expected value' );
+	t.strictEqual( ctx.count, 3, 'returns expected value' );
 	t.end();
 
 	function predicate( v ) {
diff --git a/lib/node_modules/@stdlib/iter/cuany/test/test.js b/lib/node_modules/@stdlib/iter/cuany/test/test.js
index 8f483c5705b7..41fbd12c3661 100644
--- a/lib/node_modules/@stdlib/iter/cuany/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cuany/test/test.js
@@ -75,10 +75,10 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	it = iterCuAny( arr );
 	for ( i = 0; i < 5; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'boolean', 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
-	t.equal( typeof r.done, 'boolean', 'returns expected value' );
+	t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	t.end();
 });
 
@@ -209,20 +209,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCuAny( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -234,20 +234,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCuAny( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -271,16 +271,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterCuAny( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -298,7 +298,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterCuAny( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -316,7 +316,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterCuAny( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/cuevery-by/test/test.js b/lib/node_modules/@stdlib/iter/cuevery-by/test/test.js
index 7b0ae0c7cc6c..1d237c51af1d 100644
--- a/lib/node_modules/@stdlib/iter/cuevery-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cuevery-by/test/test.js
@@ -120,10 +120,10 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	it = iterCuEveryBy( arr, predicate );
 	for ( i = 0; i < 5; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'boolean', 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
-	t.equal( typeof r.done, 'boolean', 'returns expected value' );
+	t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	t.end();
 });
 
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCuEveryBy( randu(), predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCuEveryBy( randu(), predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'foo' );
-	t.equal( r.value, 'foo', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'foo', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterCuEveryBy( rand, predicate );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterCuEveryBy( randu(), predicate);
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterCuEveryBy( rand, predicate );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -347,14 +347,14 @@ tape( 'the function supports specifying the predicate function execution context
 	];
 
 	it = iterCuEveryBy( array2iterator( values ), predicate, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
 		actual.push( it.next() );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, 3, 'returns expected value' );
+	t.strictEqual( ctx.count, 3, 'returns expected value' );
 	t.end();
 
 	function predicate( v ) {
diff --git a/lib/node_modules/@stdlib/iter/cuevery/test/test.js b/lib/node_modules/@stdlib/iter/cuevery/test/test.js
index 8631ec891bbf..7d3329f1965e 100644
--- a/lib/node_modules/@stdlib/iter/cuevery/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cuevery/test/test.js
@@ -75,10 +75,10 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	it = iterCuEvery( arr );
 	for ( i = 0; i < 5; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'boolean', 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
-	t.equal( typeof r.done, 'boolean', 'returns expected value' );
+	t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	t.end();
 });
 
@@ -209,20 +209,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCuEvery( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -234,20 +234,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCuEvery( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -271,16 +271,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterCuEvery( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -298,7 +298,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterCuEvery( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -316,7 +316,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterCuEvery( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/cunone-by/test/test.js b/lib/node_modules/@stdlib/iter/cunone-by/test/test.js
index 5d185d85a965..632c68ab1033 100644
--- a/lib/node_modules/@stdlib/iter/cunone-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cunone-by/test/test.js
@@ -120,10 +120,10 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	it = iterCuNoneBy( arr, predicate );
 	for ( i = 0; i < 5; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'boolean', 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
-	t.equal( typeof r.done, 'boolean', 'returns expected value' );
+	t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	t.end();
 });
 
@@ -196,20 +196,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCuNoneBy( randu(), predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -221,20 +221,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCuNoneBy( randu(), predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'foo' );
-	t.equal( r.value, 'foo', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'foo', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -258,16 +258,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterCuNoneBy( rand, predicate );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -285,7 +285,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterCuNoneBy( randu(), predicate);
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterCuNoneBy( rand, predicate );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -347,14 +347,14 @@ tape( 'the function supports specifying the predicate function execution context
 	];
 
 	it = iterCuNoneBy( array2iterator( values ), predicate, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
 		actual.push( it.next() );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, 3, 'returns expected value' );
+	t.strictEqual( ctx.count, 3, 'returns expected value' );
 	t.end();
 
 	function predicate( v ) {
diff --git a/lib/node_modules/@stdlib/iter/cunone/test/test.js b/lib/node_modules/@stdlib/iter/cunone/test/test.js
index fe739cf2cb80..490ecc9b3842 100644
--- a/lib/node_modules/@stdlib/iter/cunone/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cunone/test/test.js
@@ -75,10 +75,10 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	it = iterCuNone( arr );
 	for ( i = 0; i < 5; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'boolean', 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
-	t.equal( typeof r.done, 'boolean', 'returns expected value' );
+	t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	t.end();
 });
 
@@ -209,20 +209,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCuNone( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -234,20 +234,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCuNone( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -271,16 +271,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterCuNone( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -298,7 +298,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterCuNone( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -316,7 +316,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterCuNone( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/cusome-by/test/test.js b/lib/node_modules/@stdlib/iter/cusome-by/test/test.js
index cc8f1df03d3b..f0cdbeac1edf 100644
--- a/lib/node_modules/@stdlib/iter/cusome-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cusome-by/test/test.js
@@ -145,10 +145,10 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	it = iterCuSomeBy( arr, 3, predicate );
 	for ( i = 0; i < 5; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'boolean', 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
-	t.equal( typeof r.done, 'boolean', 'returns expected value' );
+	t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	t.end();
 });
 
@@ -225,31 +225,31 @@ tape( 'the function returns an iterator which cumulatively tests whether at leas
 	expected = [ false, false, false, true, true, true ];
 
 	it = iterCuSomeBy( array2iterator( values ), 2, predicate );
-	t.equal( typeof it.next, 'function', 'has next method' );
+	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( v.value, expected[i], 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( v.value, expected[i], 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	v = it.next();
-	t.equal( v.value, undefined, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, undefined, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	values = [ 0, 0, 1, 1, 0, 1 ];
 	expected = [ false, false, false, false, false, true ];
 
 	it = iterCuSomeBy( array2iterator( values ), 3, predicate );
-	t.equal( typeof it.next, 'function', 'has next method' );
+	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( v.value, expected[i], 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( v.value, expected[i], 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	v = it.next();
-	t.equal( v.value, undefined, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, undefined, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -265,27 +265,27 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCuSomeBy( array2iterator( [ 1, 1, 1, 0, 0 ] ), 3, predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns a boolean' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns a boolean' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns a boolean' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns a boolean' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -301,24 +301,24 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCuSomeBy( array2iterator( [ 1, 1, 1, 0, 0 ] ), 3, predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns a boolean' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns a boolean' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns a boolean' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns a boolean' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -336,15 +336,15 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	iterCuSomeBy = require( './../lib' );
 
 	it1 = iterCuSomeBy( array2iterator( [ 1, 1, 0, 0, 1 ] ), 3, predicate );
-	t.equal( typeof it1[ Symbol.iterator ], 'function', 'has method' );
+	t.strictEqual( typeof it1[ Symbol.iterator ], 'function', 'has method' );
 
 	it2 = it1[ Symbol.iterator ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 6; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/iter/cusome/test/test.js b/lib/node_modules/@stdlib/iter/cusome/test/test.js
index 2b07b09db760..f3d6c339eef8 100644
--- a/lib/node_modules/@stdlib/iter/cusome/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cusome/test/test.js
@@ -106,10 +106,10 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	it = iterCuSome( arr, 1 );
 	for ( i = 0; i < 5; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'boolean', 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
-	t.equal( typeof r.done, 'boolean', 'returns expected value' );
+	t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	t.end();
 });
 
@@ -230,20 +230,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCuSome( randu(), 2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -255,20 +255,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCuSome( randu(), 2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'boolean', 'returns expected value' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -292,16 +292,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterCuSome( rand, 2 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -319,7 +319,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterCuSome( randu(), 2 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -337,7 +337,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterCuSome( rand, 2 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/datespace/test/test.js b/lib/node_modules/@stdlib/iter/datespace/test/test.js
index 718d1a3355d5..120ad5e18cec 100644
--- a/lib/node_modules/@stdlib/iter/datespace/test/test.js
+++ b/lib/node_modules/@stdlib/iter/datespace/test/test.js
@@ -445,12 +445,12 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	it = iterDatespace( new Date( 0 ), new Date( 99 ), {
 		'beep': 'boop'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length-1; i++ ) {
 		actual = it.next();
-		t.equal( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	actual = it.next();
 	t.deepEqual( actual, expected[ expected.length-1 ], 'returns expected values' );
@@ -475,12 +475,12 @@ tape( 'the function returns an iterator protocol-compliant object which returns,
 	});
 
 	it = iterDatespace( 0, 99 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length-1; i++ ) {
 		actual = it.next();
-		t.equal( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	actual = it.next();
 	t.deepEqual( actual, expected[ expected.length-1 ], 'returns expected values' );
@@ -505,12 +505,12 @@ tape( 'the function returns an iterator protocol-compliant object which returns,
 	});
 
 	it = iterDatespace( new Date( 0 ), new Date( 99 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length-1; i++ ) {
 		actual = it.next();
-		t.equal( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	actual = it.next();
 	t.deepEqual( actual, expected[ expected.length-1 ], 'returns expected values' );
@@ -535,12 +535,12 @@ tape( 'the function returns an iterator protocol-compliant object which returns,
 	});
 
 	it = iterDatespace( ( new Date( 0 ) ).toISOString(), ( new Date( 99 ) ).toISOString() ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length-1; i++ ) {
 		actual = it.next();
-		t.equal( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	actual = it.next();
 	t.deepEqual( actual, expected[ expected.length-1 ], 'returns expected values' );
@@ -555,16 +555,16 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	it = iterDatespace( new Date( 0 ), new Date( 99 ), 10, {
 		'beep': 'boop'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 10; i++ ) {
 		actual = it.next();
-		t.equal( isDateObject( actual.value ), true, 'returns date object' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( isDateObject( actual.value ), true, 'returns date object' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 	t.end();
 });
 
@@ -576,16 +576,16 @@ tape( 'the function ignores unrecognized options (iterations)', function test( t
 	it = iterDatespace( new Date( 0 ), new Date( 99 ), {
 		'beep': 'boop'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		actual = it.next();
-		t.equal( isDateObject( actual.value ), true, 'returns date object' );
-		t.equal( actual.done, false, 'returns expected value' );
+		t.strictEqual( isDateObject( actual.value ), true, 'returns date object' );
+		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 	t.end();
 });
 
@@ -618,12 +618,12 @@ tape( 'the function supports specifying the number of returned Date objects', fu
 	];
 
 	it = iterDatespace( 0, 3, 4 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length-1; i++ ) {
 		actual = it.next();
-		t.equal( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	actual = it.next();
 	t.deepEqual( actual, expected[ expected.length-1 ], 'returns expected values' );
@@ -658,12 +658,12 @@ tape( 'the function supports specifying the rounding mode (floor)', function tes
 	it = iterDatespace( 0, 1, {
 		'round': 'floor'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length-1; i++ ) {
 		actual = it.next();
-		t.equal( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	actual = it.next();
 	t.deepEqual( actual, expected[ expected.length-1 ], 'returns expected values' );
@@ -701,12 +701,12 @@ tape( 'the function supports specifying the rounding mode (floor; iterations)',
 	it = iterDatespace( 0, 5, 4, {
 		'round': 'floor'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length-1; i++ ) {
 		actual = it.next();
-		t.equal( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	actual = it.next();
 	t.deepEqual( actual, expected[ expected.length-1 ], 'returns expected values' );
@@ -741,12 +741,12 @@ tape( 'the function supports specifying the rounding mode (ceil)', function test
 	it = iterDatespace( 0, 1, {
 		'round': 'ceil'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length-1; i++ ) {
 		actual = it.next();
-		t.equal( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	actual = it.next();
 	t.deepEqual( actual, expected[ expected.length-1 ], 'returns expected values' );
@@ -784,12 +784,12 @@ tape( 'the function supports specifying the rounding mode (ceil; iterations)', f
 	it = iterDatespace( 0, 5, 4, {
 		'round': 'ceil'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length-1; i++ ) {
 		actual = it.next();
-		t.equal( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	actual = it.next();
 	t.deepEqual( actual, expected[ expected.length-1 ], 'returns expected values' );
@@ -824,12 +824,12 @@ tape( 'the function supports specifying the rounding mode (round)', function tes
 	it = iterDatespace( 0, 1, {
 		'round': 'round'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length-1; i++ ) {
 		actual = it.next();
-		t.equal( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	actual = it.next();
 	t.deepEqual( actual, expected[ expected.length-1 ], 'returns expected values' );
@@ -867,12 +867,12 @@ tape( 'the function supports specifying the rounding mode (round; iterations)',
 	it = iterDatespace( 0, 5, 4, {
 		'round': 'round'
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length-1; i++ ) {
 		actual = it.next();
-		t.equal( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.value.getTime(), expected[ i ].value.getTime(), 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	actual = it.next();
 	t.deepEqual( actual, expected[ expected.length-1 ], 'returns expected values' );
@@ -886,20 +886,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDatespace( 0, 99, 100 );
 
 	r = it.next();
-	t.equal( isDateObject( r.value ), true, 'returns a Date object' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( isDateObject( r.value ), true, 'returns a Date object' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( isDateObject( r.value ), true, 'returns a Date object' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( isDateObject( r.value ), true, 'returns a Date object' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -911,20 +911,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDatespace( 0, 99, 100 );
 
 	r = it.next();
-	t.equal( isDateObject( r.value), true, 'returns a Date object' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( isDateObject( r.value), true, 'returns a Date object' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( isDateObject( r.value), true, 'returns a Date object' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( isDateObject( r.value), true, 'returns a Date object' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -940,16 +940,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterDatespace( 0, 99, 100 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value.getTime(), it1.next().value.getTime(), 'returns expected value' );
+		t.strictEqual( it2.next().value.getTime(), it1.next().value.getTime(), 'returns expected value' );
 	}
 	t.end();
 });
@@ -963,7 +963,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterDatespace( 0, 99, 100 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/dedupe-by/test/test.js b/lib/node_modules/@stdlib/iter/dedupe-by/test/test.js
index 89494baadb37..9c3849323e0c 100644
--- a/lib/node_modules/@stdlib/iter/dedupe-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/dedupe-by/test/test.js
@@ -201,7 +201,7 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterDedupeBy( iterCounter( randu() ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	actual = [];
@@ -251,7 +251,7 @@ tape( 'the function returns an iterator protocol-compliant object which removes
 	];
 
 	it = iterDedupeBy( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -296,7 +296,7 @@ tape( 'the function returns an iterator protocol-compliant object which removes
 	];
 
 	it = iterDedupeBy( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -345,7 +345,7 @@ tape( 'the function returns an iterator protocol-compliant object which removes
 	];
 
 	it = iterDedupeBy( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -402,7 +402,7 @@ tape( 'the function supports specifying the number of allowed consecutive iterat
 	];
 
 	it = iterDedupeBy( array2iterator( values ), 2, fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -455,7 +455,7 @@ tape( 'the function supports specifying the number of allowed consecutive iterat
 	];
 
 	it = iterDedupeBy( array2iterator( values ), 2, fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -516,7 +516,7 @@ tape( 'the function invokes a provided callback with five arguments', function t
 	];
 
 	it = iterDedupeBy( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual1 = [];
 	actual2 = [];
@@ -528,10 +528,10 @@ tape( 'the function invokes a provided callback with five arguments', function t
 	for ( i = 0; i < expected2.length; i++ ) {
 		x = actual2[ i ];
 		y = expected2[ i ];
-		t.equal( x[ 0 ], y[ 0 ], 'returns expected value' );
-		t.equal( x[ 1 ], y[ 1 ], 'returns expected value' );
-		t.equal( x[ 2 ], y[ 2 ], 'returns expected value' );
-		t.equal( x[ 3 ], y[ 3 ], 'returns expected value' );
+		t.strictEqual( x[ 0 ], y[ 0 ], 'returns expected value' );
+		t.strictEqual( x[ 1 ], y[ 1 ], 'returns expected value' );
+		t.strictEqual( x[ 2 ], y[ 2 ], 'returns expected value' );
+		t.strictEqual( x[ 3 ], y[ 3 ], 'returns expected value' );
 		if ( y[ 4 ] !== y[ 4 ] ) {
 			t.notEqual( x[ 4 ], x[ 4 ], 'returns expected value' );
 		}
@@ -551,20 +551,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDedupeBy( randu(), fcn );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -580,20 +580,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDedupeBy( randu(), fcn );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -621,16 +621,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterDedupeBy( rand, fcn );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -652,7 +652,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterDedupeBy( randu(), fcn );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -674,7 +674,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterDedupeBy( rand, fcn );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/iter/dedupe/test/test.js b/lib/node_modules/@stdlib/iter/dedupe/test/test.js
index 8d16ea5d2796..0ccb4329cf1e 100644
--- a/lib/node_modules/@stdlib/iter/dedupe/test/test.js
+++ b/lib/node_modules/@stdlib/iter/dedupe/test/test.js
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterDedupe( iterCounter( randu() ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	actual = [];
@@ -150,7 +150,7 @@ tape( 'the function returns an iterator protocol-compliant object which removes
 	];
 
 	it = iterDedupe( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -191,7 +191,7 @@ tape( 'the function returns an iterator protocol-compliant object which removes
 	];
 
 	it = iterDedupe( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -236,7 +236,7 @@ tape( 'the function returns an iterator protocol-compliant object which removes
 	];
 
 	it = iterDedupe( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -289,7 +289,7 @@ tape( 'the function supports specifying the number of allowed consecutive duplic
 	];
 
 	it = iterDedupe( array2iterator( values ), 2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -338,7 +338,7 @@ tape( 'the function supports specifying the number of allowed consecutive duplic
 	];
 
 	it = iterDedupe( array2iterator( values ), 2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -355,20 +355,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDedupe( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -380,20 +380,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDedupe( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -417,16 +417,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterDedupe( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -444,7 +444,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterDedupe( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -462,7 +462,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterDedupe( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/do-until-each/test/test.js b/lib/node_modules/@stdlib/iter/do-until-each/test/test.js
index e9d25466688c..9720e55ff21c 100644
--- a/lib/node_modules/@stdlib/iter/do-until-each/test/test.js
+++ b/lib/node_modules/@stdlib/iter/do-until-each/test/test.js
@@ -130,28 +130,28 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterDoUntilEach( randu(), predicate, assert );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	count = -1;
 	i = 0;
 	do {
 		r = it.next();
 		if ( typeof r.value !== 'undefined' ) {
-			t.equal( typeof r.value, 'number', 'returns a number' );
+			t.strictEqual( typeof r.value, 'number', 'returns a number' );
 		}
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 		if ( r.done ) {
 			count += 1;
 		}
 		i += 1;
 	} while ( r.done === false );
-	t.equal( count, i, 'returns expected value' );
+	t.strictEqual( count, i, 'returns expected value' );
 	t.end();
 
 	function assert( v, i ) {
 		count += 1;
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -172,31 +172,31 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 	};
 	rand = randu( opts );
 	it = iterDoUntilEach( rand, predicate, assert );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	i = 0;
 	do {
 		r = it.next();
 		if ( typeof r.value !== 'undefined' ) {
-			t.equal( i, expected[ i ][ 1 ], 'provides expected value' );
-			t.equal( r.value, expected[ i ][ 0 ], 'returns expected value' );
+			t.strictEqual( i, expected[ i ][ 1 ], 'provides expected value' );
+			t.strictEqual( r.value, expected[ i ][ 0 ], 'returns expected value' );
 		}
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 		i += 1;
 	} while ( r.done === false );
-	t.equal( expected.length, i, 'has expected length' );
+	t.strictEqual( expected.length, i, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
 		expected.push( [ v, i ] );
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -211,26 +211,26 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDoUntilEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -245,26 +245,26 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDoUntilEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -291,16 +291,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterDoUntilEach( rand, predicate, assert );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -309,8 +309,8 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	}
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -327,13 +327,13 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterDoUntilEach( randu(), predicate, assert );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -354,12 +354,12 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterDoUntilEach( rand, predicate, assert );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
diff --git a/lib/node_modules/@stdlib/iter/do-while-each/test/test.js b/lib/node_modules/@stdlib/iter/do-while-each/test/test.js
index 0d7e3fea31f2..df0cdc62941a 100644
--- a/lib/node_modules/@stdlib/iter/do-while-each/test/test.js
+++ b/lib/node_modules/@stdlib/iter/do-while-each/test/test.js
@@ -130,28 +130,28 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterDoWhileEach( randu(), predicate, assert );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	count = 0;
 	i = 0;
 	do {
 		r = it.next();
 		if ( typeof r.value !== 'undefined' ) {
-			t.equal( typeof r.value, 'number', 'returns a number' );
+			t.strictEqual( typeof r.value, 'number', 'returns a number' );
 		}
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 		if ( r.done ) {
 			count += 1;
 		}
 		i += 1;
 	} while ( r.done === false );
-	t.equal( count, i+1, 'returns expected value' );
+	t.strictEqual( count, i+1, 'returns expected value' );
 	t.end();
 
 	function assert( v, i ) {
 		count += 1;
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -172,7 +172,7 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 	};
 	rand = randu( opts );
 	it = iterDoWhileEach( rand, predicate, assert );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	i = 0;
@@ -180,23 +180,23 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 		r = it.next();
 		if ( typeof r.value !== 'undefined' ) {
 			expected.push( [ r.value, i ] );
-			t.equal( i, expected[ i ][ 1 ], 'provides expected value' );
-			t.equal( r.value, expected[ i ][ 0 ], 'returns expected value' );
+			t.strictEqual( i, expected[ i ][ 1 ], 'provides expected value' );
+			t.strictEqual( r.value, expected[ i ][ 0 ], 'returns expected value' );
 		}
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 		i += 1;
 	} while ( r.done === false );
-	t.equal( expected.length, i-1, 'has expected length' );
+	t.strictEqual( expected.length, i-1, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -211,26 +211,26 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDoWhileEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -245,26 +245,26 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDoWhileEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -291,16 +291,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterDoWhileEach( rand, predicate, assert );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -309,8 +309,8 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	}
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -327,13 +327,13 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterDoWhileEach( randu(), predicate, assert );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -354,12 +354,12 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterDoWhileEach( rand, predicate, assert );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
diff --git a/lib/node_modules/@stdlib/iter/empty/test/test.js b/lib/node_modules/@stdlib/iter/empty/test/test.js
index b106035bfb23..1d4335197739 100644
--- a/lib/node_modules/@stdlib/iter/empty/test/test.js
+++ b/lib/node_modules/@stdlib/iter/empty/test/test.js
@@ -40,12 +40,12 @@ tape( 'the function returns an iterator protocol-compliant object which is "empt
 	var i;
 
 	it = iterEmpty();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( v.value, void 0, 'returns expected value' );
-		t.equal( v.done, true, 'returns expected value' );
+		t.strictEqual( v.value, void 0, 'returns expected value' );
+		t.strictEqual( v.done, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -57,20 +57,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterEmpty();
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns undefined' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns undefined' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns undefined' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns undefined' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,20 +82,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterEmpty();
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns undefined' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns undefined' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns undefined' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns undefined' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -112,18 +112,18 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterEmpty();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
 		v = it2.next().value;
-		t.equal( v, void 0, 'returns expected value' );
-		t.equal( v, it1.next().value, 'returns expected value' );
+		t.strictEqual( v, void 0, 'returns expected value' );
+		t.strictEqual( v, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterEmpty();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/fill/test/test.js b/lib/node_modules/@stdlib/iter/fill/test/test.js
index 68c08a127ea4..1ed23a8d5fd0 100644
--- a/lib/node_modules/@stdlib/iter/fill/test/test.js
+++ b/lib/node_modules/@stdlib/iter/fill/test/test.js
@@ -226,12 +226,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterFill( randu(), 3.14, 10, 20 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( r.done, false, 'returns expected value' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( r.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -267,7 +267,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	];
 
 	it = iterFill( array2iterator( values ), 3.14 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -332,7 +332,7 @@ tape( 'the function returns an iterator protocol-compliant object (begin+<last>)
 	];
 
 	it = iterFill( array2iterator( values ), 3.14, 6 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -397,7 +397,7 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end)',
 	];
 
 	it = iterFill( array2iterator( values ), 3.14, 3, 7 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -434,7 +434,7 @@ tape( 'the function returns an iterator protocol-compliant object which "fills"
 	];
 
 	it = iterFill( array2iterator( values ), 3.14, 0, 10 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -499,7 +499,7 @@ tape( 'the function returns un-"filled" iterated values if the third argument is
 	];
 
 	it = iterFill( array2iterator( values ), 3.14, 3, 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -564,7 +564,7 @@ tape( 'the function returns un-"filled" iterated values if the third argument is
 	];
 
 	it = iterFill( array2iterator( values ), 3.14, 3, 0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -581,20 +581,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFill( randu(), 3.14 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -606,20 +606,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFill( randu(), 3.14 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -643,16 +643,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterFill( rand, 3.14 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -680,16 +680,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterFill( rand, 3.14, 10 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -717,16 +717,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterFill( rand, 3.14, 10, 20 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -744,7 +744,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterFill( randu(), 3.14 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterFill( rand, 3.14 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/filter-map/test/test.js b/lib/node_modules/@stdlib/iter/filter-map/test/test.js
index 98b45f6662ba..2dc346c321cd 100644
--- a/lib/node_modules/@stdlib/iter/filter-map/test/test.js
+++ b/lib/node_modules/@stdlib/iter/filter-map/test/test.js
@@ -100,12 +100,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterFilterMap( randu(), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 
@@ -139,7 +139,7 @@ tape( 'the function returns an iterator protocol-compliant object which filters
 	];
 
 	it = iterFilterMap( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -170,7 +170,7 @@ tape( 'the function returns an iterator protocol-compliant object which filters
 	];
 
 	it = iterFilterMap( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -221,7 +221,7 @@ tape( 'the function returns an iterator protocol-compliant object which filters
 	];
 
 	it = iterFilterMap( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -276,14 +276,14 @@ tape( 'the function supports specifying the callback function execution context'
 	];
 
 	it = iterFilterMap( array2iterator( values ), fcn, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
 		actual.push( it.next() );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, values.length, 'returns expected value' );
+	t.strictEqual( ctx.count, values.length, 'returns expected value' );
 	t.end();
 
 	function fcn( v ) {
@@ -301,20 +301,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFilterMap( randu(), fcn );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -332,20 +332,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFilterMap( randu(), fcn );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -375,16 +375,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterFilterMap( rand, fcn );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -408,7 +408,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterFilterMap( randu(), fcn );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -432,7 +432,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterFilterMap( rand, fcn );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/iter/filter/test/test.js b/lib/node_modules/@stdlib/iter/filter/test/test.js
index 6b554d9a8937..76c94f11ad96 100644
--- a/lib/node_modules/@stdlib/iter/filter/test/test.js
+++ b/lib/node_modules/@stdlib/iter/filter/test/test.js
@@ -100,12 +100,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterFilter( randu(), predicate );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 
@@ -137,7 +137,7 @@ tape( 'the function returns an iterator protocol-compliant object which filters
 	];
 
 	it = iterFilter( array2iterator( values ), predicate );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -166,7 +166,7 @@ tape( 'the function returns an iterator protocol-compliant object which filters
 	];
 
 	it = iterFilter( array2iterator( values ), predicate );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -215,7 +215,7 @@ tape( 'the function returns an iterator protocol-compliant object which filters
 	];
 
 	it = iterFilter( array2iterator( values ), predicate );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -268,14 +268,14 @@ tape( 'the function supports specifying the predicate function execution context
 	];
 
 	it = iterFilter( array2iterator( values ), predicate, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
 		actual.push( it.next() );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, values.length, 'returns expected value' );
+	t.strictEqual( ctx.count, values.length, 'returns expected value' );
 	t.end();
 
 	function predicate( v ) {
@@ -291,20 +291,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFilter( randu(), predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -320,20 +320,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFilter( randu(), predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -361,16 +361,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterFilter( rand, predicate );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -392,7 +392,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterFilter( randu(), predicate );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -414,7 +414,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterFilter( rand, predicate );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/iter/flow/test/test.js b/lib/node_modules/@stdlib/iter/flow/test/test.js
index 9a5bc2d4b31e..58472eea3d4a 100644
--- a/lib/node_modules/@stdlib/iter/flow/test/test.js
+++ b/lib/node_modules/@stdlib/iter/flow/test/test.js
@@ -175,12 +175,12 @@ tape( 'the function returns a constructor which returns an iterator protocol-com
 	Iterator = iterFlow( {} );
 
 	it = new Iterator( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -200,8 +200,8 @@ tape( 'the function returns a constructor which returns an iterator having a flu
 	});
 
 	it1 = new Iterator( randu() );
-	t.equal( typeof it1.head, 'function', 'has method' );
-	t.equal( typeof it1.some, 'function', 'has method' );
+	t.strictEqual( typeof it1.head, 'function', 'has method' );
+	t.strictEqual( typeof it1.some, 'function', 'has method' );
 
 	values = [ 0, 0, 1, 1, 1, 0, 0, 1, 0, 1 ];
 	src = array2iterator( values );
@@ -210,12 +210,12 @@ tape( 'the function returns a constructor which returns an iterator having a flu
 
 	for ( i = 0; i < 5; i++ ) {
 		v = it2.next();
-		t.equal( v.value, values[ i ], 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( v.value, values[ i ], 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	v = it2.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -232,18 +232,18 @@ tape( 'the function returns a constructor which returns an iterator having a flu
 	});
 
 	it = new Iterator( randu() );
-	t.equal( typeof it.head, 'function', 'has method' );
-	t.equal( typeof it.some, 'function', 'has method' );
+	t.strictEqual( typeof it.head, 'function', 'has method' );
+	t.strictEqual( typeof it.some, 'function', 'has method' );
 
 	src = array2iterator( [ 0, 0, 1, 1, 1, 0, 0, 1, 0, 1 ] );
 	it = new Iterator( src );
 	bool = it.head( 5 ).some( 3 );
-	t.equal( bool, true, 'returns expected value' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	src = array2iterator( [ 0, 0, 1, 0, 1, 0, 0, 1, 0, 1 ] );
 	it = new Iterator( src );
 	bool = it.head( 5 ).some( 3 );
-	t.equal( bool, false, 'returns expected value' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -337,20 +337,20 @@ tape( 'the function returns a constructor which returns an iterator having a `re
 	it = new Iterator( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -368,20 +368,20 @@ tape( 'the function returns a constructor which returns an iterator having a `re
 	it = new Iterator( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -480,18 +480,18 @@ tape( 'if an environment supports `Symbol.iterator`, the function returns a cons
 	});
 
 	it1 = new Iterator( randu() );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it2.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -511,7 +511,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the function return
 	});
 
 	it = new Iterator( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/for-each/test/test.js b/lib/node_modules/@stdlib/iter/for-each/test/test.js
index 72015d38d3b0..841219c18c29 100644
--- a/lib/node_modules/@stdlib/iter/for-each/test/test.js
+++ b/lib/node_modules/@stdlib/iter/for-each/test/test.js
@@ -101,21 +101,21 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterForEach( randu(), assert );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	count = 0;
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( count, 100, 'returns expected value' );
+	t.strictEqual( count, 100, 'returns expected value' );
 	t.end();
 
 	function assert( v, i ) {
 		count += 1;
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 });
 
@@ -132,27 +132,27 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 	};
 	rand = randu( opts );
 	it = iterForEach( rand, assert );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < opts.iter; i++ ) {
 		r = it.next();
-		t.equal( i, expected[ i ][ 1 ], 'provides expected value' );
-		t.equal( r.value, expected[ i ][ 0 ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( i, expected[ i ][ 1 ], 'provides expected value' );
+		t.strictEqual( r.value, expected[ i ][ 0 ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, opts.iter, 'has expected length' );
+	t.strictEqual( expected.length, opts.iter, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
 		expected.push( [ v, i ] );
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 });
 
@@ -163,26 +163,26 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterForEach( randu(), assert );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 });
 
@@ -193,26 +193,26 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterForEach( randu(), assert );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 });
 
@@ -235,16 +235,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterForEach( rand, assert );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -253,8 +253,8 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	}
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 });
 
@@ -267,13 +267,13 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterForEach( randu(), assert );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 });
 
@@ -290,12 +290,12 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterForEach( rand, assert );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 });
diff --git a/lib/node_modules/@stdlib/iter/head/test/test.js b/lib/node_modules/@stdlib/iter/head/test/test.js
index 061fc8122459..8191ab6dc968 100644
--- a/lib/node_modules/@stdlib/iter/head/test/test.js
+++ b/lib/node_modules/@stdlib/iter/head/test/test.js
@@ -102,16 +102,16 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterHead( randu(), 100 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( r.done, false, 'returns expected value' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( r.done, false, 'returns expected value' );
 	}
 	r = it.next();
-	t.equal( hasOwnProp( r, 'value' ), false, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( hasOwnProp( r, 'value' ), false, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	];
 
 	it = iterHead( array2iterator( values ), 4 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < 4; i++ ) {
@@ -186,7 +186,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterHead( array2iterator( values ), 4 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < 4; i++ ) {
@@ -203,20 +203,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterHead( randu(), 10 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -228,20 +228,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterHead( randu(), 10 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -265,16 +265,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterHead( rand, 10 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -292,7 +292,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterHead( randu(), 10 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -310,7 +310,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterHead( rand, 10 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/incrspace/test/test.js b/lib/node_modules/@stdlib/iter/incrspace/test/test.js
index a4a2208c76da..ed281d0e29c9 100644
--- a/lib/node_modules/@stdlib/iter/incrspace/test/test.js
+++ b/lib/node_modules/@stdlib/iter/incrspace/test/test.js
@@ -192,7 +192,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns,
 	});
 
 	it = iterIncrspace( 0, 100 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -239,7 +239,7 @@ tape( 'the function supports specifying an increment', function test( t ) {
 	];
 
 	it = iterIncrspace( 0, 11, 2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -256,20 +256,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterIncrspace( 0, 100, 2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -281,20 +281,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterIncrspace( 0, 100, 2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -310,16 +310,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterIncrspace( 0, 100, 2 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 50; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -333,7 +333,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterIncrspace( 0, 100, 2 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/intersection-by-hash/test/test.js b/lib/node_modules/@stdlib/iter/intersection-by-hash/test/test.js
index 2790b58da2c7..56f399ea9ac1 100644
--- a/lib/node_modules/@stdlib/iter/intersection-by-hash/test/test.js
+++ b/lib/node_modules/@stdlib/iter/intersection-by-hash/test/test.js
@@ -410,7 +410,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	it2 = array2iterator( values2 );
 
 	it = iterIntersectionByHash( it1, it2, hashFcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -436,7 +436,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterIntersectionByHash( iterEmpty(), iterEmpty(), iterEmpty(), iterEmpty(), hashFcn ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -483,7 +483,7 @@ tape( 'the function returns an iterator which returns the intersection of two it
 	it2 = array2iterator( values2 );
 
 	it = iterIntersectionByHash( it1, it2, hashFcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -550,7 +550,7 @@ tape( 'the function returns an iterator which returns the intersection of two it
 	it2 = array2iterator( values2 );
 
 	it = iterIntersectionByHash( it1, it2, hashFcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -598,7 +598,7 @@ tape( 'the function returns an iterator which returns the intersection of three
 	it3 = array2iterator( values3 );
 
 	it = iterIntersectionByHash( it1, it2, it3, hashFcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -655,14 +655,14 @@ tape( 'the function supports specifying a function execution context', function
 	it2 = array2iterator( values2 );
 
 	it = iterIntersectionByHash( it1, it2, hashFcn, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
 		actual.push( it.next() );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, values1.length+values2.length, 'returns expected value' );
+	t.strictEqual( ctx.count, values1.length+values2.length, 'returns expected value' );
 	t.end();
 
 	function hashFcn( v ) {
@@ -686,20 +686,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterIntersectionByHash( rand1, rand2, hashFcn );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -723,20 +723,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterIntersectionByHash( rand1, rand2, hashFcn );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -770,16 +770,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand2[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterIntersectionByHash( rand1, rand2, hashFcn );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -810,7 +810,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	rand2 = discreteUniform( 0, 10, opts );
 
 	it = iterIntersectionByHash( rand1, rand2, hashFcn );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -840,7 +840,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand2[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterIntersectionByHash( rand1, rand2, hashFcn );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/iter/intersection/test/test.js b/lib/node_modules/@stdlib/iter/intersection/test/test.js
index 58eb6c49b9c8..0d98071dc532 100644
--- a/lib/node_modules/@stdlib/iter/intersection/test/test.js
+++ b/lib/node_modules/@stdlib/iter/intersection/test/test.js
@@ -230,7 +230,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	it2 = array2iterator( values2 );
 
 	it = iterIntersection( it1, it2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -252,7 +252,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterIntersection( iterEmpty(), iterEmpty(), iterEmpty(), iterEmpty() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -295,7 +295,7 @@ tape( 'the function returns an iterator which returns the intersection of two it
 	it2 = array2iterator( values2 );
 
 	it = iterIntersection( it1, it2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -339,7 +339,7 @@ tape( 'the function returns an iterator which returns the intersection of three
 	it3 = array2iterator( values3 );
 
 	it = iterIntersection( it1, it2, it3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -364,20 +364,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterIntersection( rand1, rand2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -397,20 +397,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterIntersection( rand1, rand2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -440,16 +440,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand2[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterIntersection( rand1, rand2 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -476,7 +476,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	rand2 = discreteUniform( 0, 10, opts );
 
 	it = iterIntersection( rand1, rand2 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -502,7 +502,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand2[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterIntersection( rand1, rand2 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/linspace/test/test.js b/lib/node_modules/@stdlib/iter/linspace/test/test.js
index b876bb0dca58..04283aef2b61 100644
--- a/lib/node_modules/@stdlib/iter/linspace/test/test.js
+++ b/lib/node_modules/@stdlib/iter/linspace/test/test.js
@@ -194,7 +194,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns,
 	});
 
 	it = iterLinspace( 0, 99 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -233,7 +233,7 @@ tape( 'the function supports specifying the number of returned numbers', functio
 	];
 
 	it = iterLinspace( 0, 3, 4 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -297,7 +297,7 @@ tape( 'the function supports denormalized numbers', function test( t ) {
 	];
 
 	it = iterLinspace( 0.0, 2.2e-323, 10 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -314,20 +314,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLinspace( 0, 99, 100 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -339,20 +339,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLinspace( 0, 99, 100 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -368,16 +368,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterLinspace( 0, 99, 100 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -391,7 +391,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterLinspace( 0, 99, 100 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/logspace/test/test.js b/lib/node_modules/@stdlib/iter/logspace/test/test.js
index 4050267896ac..b04cf104a13c 100644
--- a/lib/node_modules/@stdlib/iter/logspace/test/test.js
+++ b/lib/node_modules/@stdlib/iter/logspace/test/test.js
@@ -425,7 +425,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns,
 	});
 
 	it = iterLogspace( 0, 99 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -453,7 +453,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns,
 	});
 
 	it = iterLogspace( 0, 99, {} );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -492,7 +492,7 @@ tape( 'the function supports specifying the number of returned numbers', functio
 	];
 
 	it = iterLogspace( 0, 3, 4 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -524,7 +524,7 @@ tape( 'the function supports returning an iterator protocol-compliant object whi
 		'base': 2
 	};
 	it = iterLogspace( 0, 99, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -556,7 +556,7 @@ tape( 'the function supports returning an iterator protocol-compliant object whi
 		'base': 2
 	};
 	it = iterLogspace( 0, 999, 1000, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -573,20 +573,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLogspace( 0, 3, 4 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -598,20 +598,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLogspace( 0, 3, 4 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -627,16 +627,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterLogspace( 0, 3, 4 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 4; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -650,7 +650,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterLogspace( 0, 3, 4 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/map/test/test.js b/lib/node_modules/@stdlib/iter/map/test/test.js
index f5270f8c636d..97f958fb5efb 100644
--- a/lib/node_modules/@stdlib/iter/map/test/test.js
+++ b/lib/node_modules/@stdlib/iter/map/test/test.js
@@ -99,12 +99,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterMap( randu(), scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 
@@ -126,19 +126,19 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 	};
 	rand = randu( opts );
 	it = iterMap( rand, scale );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	for ( i = 0; i < opts.iter; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ], 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( expected.length, opts.iter, 'has expected length' );
+	t.strictEqual( expected.length, opts.iter, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -159,14 +159,14 @@ tape( 'the function supports specifying the callback execution context', functio
 		'count': 0
 	};
 	it = iterMap( randu(), scale, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
-	t.equal( ctx.count, 100, 'returns expected value' );
+	t.strictEqual( ctx.count, 100, 'returns expected value' );
 	t.end();
 
 	function scale( v, i ) {
@@ -182,20 +182,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMap( randu(), scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -211,20 +211,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMap( randu(), scale );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -252,16 +252,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterMap( rand, scale );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -283,7 +283,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterMap( randu(), scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -305,7 +305,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterMap( rand, scale );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/iter/mapn/test/test.js b/lib/node_modules/@stdlib/iter/mapn/test/test.js
index d378d9940d06..7e3d0f04d235 100644
--- a/lib/node_modules/@stdlib/iter/mapn/test/test.js
+++ b/lib/node_modules/@stdlib/iter/mapn/test/test.js
@@ -367,12 +367,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterMapN( randu(), randu(), transform );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 
@@ -406,7 +406,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	];
 
 	it = iterMapN( array2iterator( values1 ), array2iterator( values2 ), transform ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -445,7 +445,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	];
 
 	it = iterMapN( array2iterator( values1 ), array2iterator( values2 ), transform ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -484,7 +484,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	];
 
 	it = iterMapN( array2iterator( values1 ), array2iterator( values2 ), transform ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -525,7 +525,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	];
 
 	it = iterMapN( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ), transform ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -566,7 +566,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	];
 
 	it = iterMapN( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ), transform ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -607,7 +607,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	];
 
 	it = iterMapN( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ), transform ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -648,7 +648,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	];
 
 	it = iterMapN( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ), transform ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -680,7 +680,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	];
 
 	it = iterMapN( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ), transform ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -705,7 +705,7 @@ tape( 'the function returns an iterator protocol-compliant object which applies
 	];
 
 	it = iterMapN( iterEmpty(), iterEmpty(), iterEmpty(), iterEmpty(), transform ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -743,7 +743,7 @@ tape( 'the function invokes a provided callback with iterated values and the ite
 	];
 
 	it = iterMapN( array2iterator( values1 ), array2iterator( values2 ), transform ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -786,14 +786,14 @@ tape( 'the function supports specifying the callback execution context', functio
 	];
 
 	it = iterMapN( array2iterator( values1 ), array2iterator( values2 ), transform, ctx ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
 		actual.push( it.next() );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, expected.length-1 );
+	t.strictEqual( ctx.count, expected.length-1 );
 	t.end();
 
 	function transform( x, y ) {
@@ -809,20 +809,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMapN( randu(), randu(), transform );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -838,20 +838,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMapN( randu(), randu(), transform );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -884,16 +884,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	rand2[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterMapN( rand1, rand2, transform );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -915,7 +915,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterMapN( randu(), randu(), transform );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -937,7 +937,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterMapN( rand, rand, transform );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/iter/pop/test/test.js b/lib/node_modules/@stdlib/iter/pop/test/test.js
index e0e555d1565a..fb5b0e62901a 100644
--- a/lib/node_modules/@stdlib/iter/pop/test/test.js
+++ b/lib/node_modules/@stdlib/iter/pop/test/test.js
@@ -187,12 +187,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterPop( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -224,7 +224,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	];
 
 	it = iterPop( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -247,7 +247,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterPop( iterEmpty() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -270,7 +270,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterPop( iterEmpty(), clbk );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -312,7 +312,7 @@ tape( 'the function returns an iterator protocol-compliant object (callback)', f
 	];
 
 	it = iterPop( array2iterator( values ), clbk );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -320,12 +320,12 @@ tape( 'the function returns an iterator protocol-compliant object (callback)', f
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
 
-	t.equal( FLG, true, 'returns expected value' );
+	t.strictEqual( FLG, true, 'returns expected value' );
 	t.end();
 
 	function clbk( v ) {
 		FLG = true;
-		t.equal( v, values[ values.length-1 ], 'returns expected value' );
+		t.strictEqual( v, values[ values.length-1 ], 'returns expected value' );
 	}
 });
 
@@ -360,7 +360,7 @@ tape( 'the function supports specifying the callback execution context', functio
 		'FLG': false
 	};
 	it = iterPop( array2iterator( values ), clbk, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -368,12 +368,12 @@ tape( 'the function supports specifying the callback execution context', functio
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
 
-	t.equal( ctx.FLG, true, 'returns expected value' );
+	t.strictEqual( ctx.FLG, true, 'returns expected value' );
 	t.end();
 
 	function clbk( v ) {
 		this.FLG = true; // eslint-disable-line no-invalid-this
-		t.equal( v, values[ values.length-1 ], 'returns expected value' );
+		t.strictEqual( v, values[ values.length-1 ], 'returns expected value' );
 	}
 });
 
@@ -384,20 +384,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPop( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -409,20 +409,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPop( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -446,16 +446,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterPop( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -473,7 +473,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterPop( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -491,7 +491,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterPop( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/push/test/test.js b/lib/node_modules/@stdlib/iter/push/test/test.js
index 5121ce7f9696..363cba987fb5 100644
--- a/lib/node_modules/@stdlib/iter/push/test/test.js
+++ b/lib/node_modules/@stdlib/iter/push/test/test.js
@@ -155,12 +155,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterPush( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -204,7 +204,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	];
 
 	it = iterPush( array2iterator( values ), 5, 6 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -235,7 +235,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterPush( iterEmpty(), 5, 6 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -258,7 +258,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterPush( iterEmpty() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -299,7 +299,7 @@ tape( 'the function returns an iterator protocol-compliant object (no additional
 	];
 
 	it = iterPush( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -316,20 +316,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPush( randu(), 1, 2, 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -341,20 +341,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPush( randu(), 1, 2, 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -378,16 +378,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterPush( rand, 1, 2, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -405,7 +405,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterPush( randu(), 1, 2, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -423,7 +423,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterPush( rand, 1, 2, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/reject/test/test.js b/lib/node_modules/@stdlib/iter/reject/test/test.js
index dfffaa6f3034..6365d0cee8b3 100644
--- a/lib/node_modules/@stdlib/iter/reject/test/test.js
+++ b/lib/node_modules/@stdlib/iter/reject/test/test.js
@@ -100,12 +100,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterReject( randu(), predicate );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 
@@ -137,7 +137,7 @@ tape( 'the function returns an iterator protocol-compliant object which rejects
 	];
 
 	it = iterReject( array2iterator( values ), predicate );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -166,7 +166,7 @@ tape( 'the function returns an iterator protocol-compliant object which rejects
 	];
 
 	it = iterReject( array2iterator( values ), predicate );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -215,7 +215,7 @@ tape( 'the function returns an iterator protocol-compliant object which rejects
 	];
 
 	it = iterReject( array2iterator( values ), predicate );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -268,14 +268,14 @@ tape( 'the function supports specifying the predicate function execution context
 	];
 
 	it = iterReject( array2iterator( values ), predicate, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
 		actual.push( it.next() );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, values.length, 'returns expected value' );
+	t.strictEqual( ctx.count, values.length, 'returns expected value' );
 	t.end();
 
 	function predicate( v ) {
@@ -291,20 +291,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterReject( randu(), predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -320,20 +320,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterReject( randu(), predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -361,16 +361,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterReject( rand, predicate );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -392,7 +392,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterReject( randu(), predicate );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -414,7 +414,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterReject( rand, predicate );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/iter/replicate-by/test/test.js b/lib/node_modules/@stdlib/iter/replicate-by/test/test.js
index 63e0070f9091..7d7a8c13ef8a 100644
--- a/lib/node_modules/@stdlib/iter/replicate-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/replicate-by/test/test.js
@@ -134,7 +134,7 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterReplicateBy( randu(), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < 100; i++ ) {
@@ -143,8 +143,8 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	for ( i = 0; i < actual.length; i += 2 ) {
 		v1 = actual[ i ];
 		v2 = actual[ i+1 ];
-		t.equal( v1.value, v2.value, 'returns expected value' );
-		t.equal( v1.done, v2.done, 'returns expected value' );
+		t.strictEqual( v1.value, v2.value, 'returns expected value' );
+		t.strictEqual( v1.done, v2.done, 'returns expected value' );
 	}
 	t.end();
 
@@ -216,7 +216,7 @@ tape( 'the function returns an iterator protocol-compliant object which replicat
 	];
 
 	it = iterReplicateBy( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -285,7 +285,7 @@ tape( 'the function returns an iterator protocol-compliant object which replicat
 	];
 
 	it = iterReplicateBy( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -354,7 +354,7 @@ tape( 'the function returns an iterator protocol-compliant object which replicat
 	];
 
 	it = iterReplicateBy( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -443,7 +443,7 @@ tape( 'the function returns an iterator protocol-compliant object which replicat
 	];
 
 	it = iterReplicateBy( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -488,7 +488,7 @@ tape( 'the function returns an iterator protocol-compliant object which replicat
 	];
 
 	it = iterReplicateBy( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -517,7 +517,7 @@ tape( 'the function returns an iterator protocol-compliant object which replicat
 	];
 
 	it = iterReplicateBy( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -546,7 +546,7 @@ tape( 'the function returns an iterator protocol-compliant object which replicat
 	];
 
 	it = iterReplicateBy( array2iterator( values ), fcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -595,14 +595,14 @@ tape( 'the function supports specifying the callback execution context', functio
 	];
 
 	it = iterReplicateBy( array2iterator( values ), fcn, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
 		actual.push( it.next() );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, 4, 'returns expected value' );
+	t.strictEqual( ctx.count, 4, 'returns expected value' );
 	t.end();
 
 	function fcn() {
@@ -618,20 +618,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterReplicateBy( randu(), fcn );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -647,20 +647,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterReplicateBy( randu(), fcn );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -688,16 +688,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterReplicateBy( rand, fcn );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -719,7 +719,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterReplicateBy( randu(), fcn );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -741,7 +741,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterReplicateBy( rand, fcn );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/iter/replicate/test/test.js b/lib/node_modules/@stdlib/iter/replicate/test/test.js
index 4f3265b109ce..8e507122e6b4 100644
--- a/lib/node_modules/@stdlib/iter/replicate/test/test.js
+++ b/lib/node_modules/@stdlib/iter/replicate/test/test.js
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterReplicate( randu(), 2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < 100; i++ ) {
@@ -113,8 +113,8 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	for ( i = 0; i < actual.length; i += 2 ) {
 		v1 = actual[ i ];
 		v2 = actual[ i+1 ];
-		t.equal( v1.value, v2.value, 'returns expected value' );
-		t.equal( v1.done, v2.done, 'returns expected value' );
+		t.strictEqual( v1.value, v2.value, 'returns expected value' );
+		t.strictEqual( v1.done, v2.done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -182,7 +182,7 @@ tape( 'the function returns an iterator protocol-compliant object which replicat
 	];
 
 	it = iterReplicate( array2iterator( values ), 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -223,7 +223,7 @@ tape( 'the function returns an iterator protocol-compliant object which replicat
 	];
 
 	it = iterReplicate( array2iterator( values ), 1 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -240,20 +240,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterReplicate( randu(), 2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -265,20 +265,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterReplicate( randu(), 2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -302,16 +302,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterReplicate( rand, 2 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -329,7 +329,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterReplicate( randu(), 2 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -347,7 +347,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterReplicate( rand, 2 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/shift/test/test.js b/lib/node_modules/@stdlib/iter/shift/test/test.js
index 374eaee2bbd8..c436fc4ba55a 100644
--- a/lib/node_modules/@stdlib/iter/shift/test/test.js
+++ b/lib/node_modules/@stdlib/iter/shift/test/test.js
@@ -187,12 +187,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterShift( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -224,7 +224,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	];
 
 	it = iterShift( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -247,7 +247,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterShift( iterEmpty() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -270,7 +270,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterShift( iterEmpty(), clbk );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -312,7 +312,7 @@ tape( 'the function returns an iterator protocol-compliant object (callback)', f
 	];
 
 	it = iterShift( array2iterator( values ), clbk );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -320,12 +320,12 @@ tape( 'the function returns an iterator protocol-compliant object (callback)', f
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
 
-	t.equal( FLG, true, 'returns expected value' );
+	t.strictEqual( FLG, true, 'returns expected value' );
 	t.end();
 
 	function clbk( v ) {
 		FLG = true;
-		t.equal( v, values[ 0 ], 'returns expected value' );
+		t.strictEqual( v, values[ 0 ], 'returns expected value' );
 	}
 });
 
@@ -360,7 +360,7 @@ tape( 'the function supports specifying the callback execution context', functio
 		'FLG': false
 	};
 	it = iterShift( array2iterator( values ), clbk, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -368,12 +368,12 @@ tape( 'the function supports specifying the callback execution context', functio
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
 
-	t.equal( ctx.FLG, true, 'returns expected value' );
+	t.strictEqual( ctx.FLG, true, 'returns expected value' );
 	t.end();
 
 	function clbk( v ) {
 		this.FLG = true; // eslint-disable-line no-invalid-this
-		t.equal( v, values[ 0 ], 'returns expected value' );
+		t.strictEqual( v, values[ 0 ], 'returns expected value' );
 	}
 });
 
@@ -384,20 +384,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterShift( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -409,20 +409,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterShift( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -446,16 +446,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterShift( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -473,7 +473,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterShift( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -491,7 +491,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterShift( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/slice/test/test.js b/lib/node_modules/@stdlib/iter/slice/test/test.js
index cd9de390e3ce..7ffdadde541b 100644
--- a/lib/node_modules/@stdlib/iter/slice/test/test.js
+++ b/lib/node_modules/@stdlib/iter/slice/test/test.js
@@ -217,16 +217,16 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterSlice( randu(), 100, 200 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( r.done, false, 'returns expected value' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( r.done, false, 'returns expected value' );
 	}
 	r = it.next();
-	t.equal( hasOwnProp( r, 'value' ), false, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( hasOwnProp( r, 'value' ), false, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -262,7 +262,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	];
 
 	it = iterSlice( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -303,7 +303,7 @@ tape( 'the function returns an iterator protocol-compliant object (begin+<last>)
 	];
 
 	it = iterSlice( array2iterator( values ), 6 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -344,7 +344,7 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end)',
 	];
 
 	it = iterSlice( array2iterator( values ), 3, 7 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -377,7 +377,7 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end)',
 	];
 
 	it = iterSlice( array2iterator( values ), 1, 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -414,7 +414,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSlice( array2iterator( values ), 0, 10 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -439,7 +439,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	];
 
 	it = iterSlice( array2iterator( values ), values.length+1, values.length+10 ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -464,7 +464,7 @@ tape( 'the function returns an "empty" iterator if the third argument is less th
 	];
 
 	it = iterSlice( array2iterator( values ), 3, 3 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -489,7 +489,7 @@ tape( 'the function returns an "empty" iterator if the third argument is less th
 	];
 
 	it = iterSlice( array2iterator( values ), 3, 0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -506,20 +506,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSlice( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -531,20 +531,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSlice( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -568,16 +568,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterSlice( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -605,16 +605,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterSlice( rand, 10 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -642,16 +642,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterSlice( rand, 10, 20 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -669,7 +669,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterSlice( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -687,7 +687,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterSlice( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/step/test/test.js b/lib/node_modules/@stdlib/iter/step/test/test.js
index c01232313774..fb197f310e24 100644
--- a/lib/node_modules/@stdlib/iter/step/test/test.js
+++ b/lib/node_modules/@stdlib/iter/step/test/test.js
@@ -190,7 +190,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		});
 	}
 	it = iterStep( 0, 2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -237,7 +237,7 @@ tape( 'the function supports specifying the number of returned values', function
 	];
 
 	it = iterStep( 0, 2, 6 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -254,20 +254,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterStep( 0, 2, 10 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -279,20 +279,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterStep( 0, 2, 10 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -308,16 +308,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterStep( 0, 2, 10 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -331,7 +331,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterStep( 0, 2, 10 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/strided-by/test/test.js b/lib/node_modules/@stdlib/iter/strided-by/test/test.js
index bb62ef2d5934..6adc207d5a6e 100644
--- a/lib/node_modules/@stdlib/iter/strided-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/strided-by/test/test.js
@@ -392,12 +392,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterStridedBy( randu(), stride );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 
@@ -434,16 +434,16 @@ tape( 'the function returns an iterator protocol-compliant object which steps ac
 	];
 
 	it = iterStridedBy( array2iterator( values ), stride );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ].value, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ].value, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -480,16 +480,16 @@ tape( 'the function supports specifying an offset', function test( t ) {
 	];
 
 	it = iterStridedBy( array2iterator( values ), stride, 1 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ].value, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ].value, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -506,11 +506,11 @@ tape( 'the function supports specifying an offset (offset > iterator length', fu
 	values = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
 
 	it = iterStridedBy( array2iterator( values ), stride, values.length+10 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -547,16 +547,16 @@ tape( 'the function supports specifying whether to eagerly advance the input ite
 	];
 
 	it = iterStridedBy( array2iterator( values ), stride, 1, true );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ].value, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ].value, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -573,11 +573,11 @@ tape( 'the function supports specifying whether to eagerly advance the input ite
 	values = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
 
 	it = iterStridedBy( array2iterator( values ), stride, values.length+10, true ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -621,14 +621,14 @@ tape( 'the function supports specifying the callback execution context', functio
 	];
 
 	it = iterStridedBy( array2iterator( values ), stride, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
 		actual.push( it.next() );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, 4, 'returns expected value' );
+	t.strictEqual( ctx.count, 4, 'returns expected value' );
 	t.end();
 
 	function stride() {
@@ -668,14 +668,14 @@ tape( 'the function supports specifying the callback execution context (offset)'
 	];
 
 	it = iterStridedBy( array2iterator( values ), stride, 1, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
 		actual.push( it.next() );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, 3, 'returns expected value' );
+	t.strictEqual( ctx.count, 3, 'returns expected value' );
 	t.end();
 
 	function stride() {
@@ -715,14 +715,14 @@ tape( 'the function supports specifying the callback execution context (offset+e
 	];
 
 	it = iterStridedBy( array2iterator( values ), stride, 1, true, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
 		actual.push( it.next() );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, 3, 'returns expected value' );
+	t.strictEqual( ctx.count, 3, 'returns expected value' );
 	t.end();
 
 	function stride() {
@@ -738,20 +738,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterStridedBy( randu(), stride );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -767,20 +767,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterStridedBy( randu(), stride );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -806,16 +806,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	arr[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterStridedBy( arr, stride );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < src.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -845,16 +845,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	arr[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterStridedBy( arr, stride );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < src.length/2; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -884,16 +884,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	arr[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterStridedBy( arr, stride, 1 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < src.length/2; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -923,16 +923,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	arr[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterStridedBy( arr, stride, 1, true );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < src.length/2; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -954,7 +954,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterStridedBy( randu(), stride );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -976,7 +976,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterStridedBy( rand, stride );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/iter/strided/test/test.js b/lib/node_modules/@stdlib/iter/strided/test/test.js
index 04a03aec5747..d43ebf0f68a3 100644
--- a/lib/node_modules/@stdlib/iter/strided/test/test.js
+++ b/lib/node_modules/@stdlib/iter/strided/test/test.js
@@ -309,12 +309,12 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterStrided( randu(), 10 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.equal( typeof r.value, 'number', 'returns a number' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	t.end();
 });
@@ -347,16 +347,16 @@ tape( 'the function returns an iterator protocol-compliant object which steps by
 	];
 
 	it = iterStrided( array2iterator( values ), 2 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ].value, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ].value, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -389,16 +389,16 @@ tape( 'the function supports specifying an offset', function test( t ) {
 	];
 
 	it = iterStrided( array2iterator( values ), 2, 1 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ].value, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ].value, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -411,11 +411,11 @@ tape( 'the function supports specifying an offset (offset > iterator length', fu
 	values = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
 
 	it = iterStrided( array2iterator( values ), 2, values.length+10 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -448,16 +448,16 @@ tape( 'the function supports specifying whether to eagerly advance the input ite
 	];
 
 	it = iterStrided( array2iterator( values ), 2, 1, true );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		r = it.next();
-		t.equal( r.value, expected[ i ].value, 'returns expected value' );
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( r.value, expected[ i ].value, 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 	}
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -470,11 +470,11 @@ tape( 'the function supports specifying whether to eagerly advance the input ite
 	values = [ 1, 2, 3, 4, 5, 6, 7, 8 ];
 
 	it = iterStrided( array2iterator( values ), 2, values.length+10, true );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -486,20 +486,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterStrided( randu(), 10 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -511,20 +511,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterStrided( randu(), 10 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -546,16 +546,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	arr[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterStrided( arr, 1 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < src.length; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -581,16 +581,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	arr[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterStrided( arr, 2 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < src.length/2; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -616,16 +616,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	arr[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterStrided( arr, 2, 1 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < src.length/2; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -651,16 +651,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	arr[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterStrided( arr, 2, 1, true );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < src.length/2; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -678,7 +678,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterStrided( randu(), 10 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -696,7 +696,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterStrided( rand, 10 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/test/test.js b/lib/node_modules/@stdlib/iter/test/test.js
index 49c70edaa8d1..5835f5bb0428 100644
--- a/lib/node_modules/@stdlib/iter/test/test.js
+++ b/lib/node_modules/@stdlib/iter/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains iterator utilities', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/to-array-view-right/test/test.js b/lib/node_modules/@stdlib/iter/to-array-view-right/test/test.js
index a27b14fe4303..7a7ec120cab0 100644
--- a/lib/node_modules/@stdlib/iter/to-array-view-right/test/test.js
+++ b/lib/node_modules/@stdlib/iter/to-array-view-right/test/test.js
@@ -510,7 +510,7 @@ tape( 'the function fills an array-like object with values returned from an iter
 	actual = iterator2arrayviewRight( it, out );
 	expected = new Float64Array( [ 4, 3, 2, 1 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -534,7 +534,7 @@ tape( 'the function fills an array-like object with values returned from an iter
 	actual = iterator2arrayviewRight( it, out );
 	expected = new Float64Array( [ 7.0, 8.0, 5.0, 6.0, 3.0, 4.0, 1.0, 2.0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( reinterpret128( actual, 0 ), expected, 'returns expected value' );
 	t.end();
 });
@@ -553,7 +553,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayviewRight( it, out, 2 );
 	expected = new Float64Array( [ 0, 0, 6, 5, 4, 3, 2, 1 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -572,7 +572,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayviewRight( it, out, 6 );
 	expected = new Float64Array( [ 0, 0, 0, 0, 0, 0, 2, 1 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -591,7 +591,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayviewRight( it, out, -6 );
 	expected = new Float64Array( [ 0, 0, 6, 5, 4, 3, 2, 1 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -610,7 +610,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayviewRight( it, out, 2, 4 );
 	expected = new Float64Array( [ 0, 0, 2, 1, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -629,7 +629,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayviewRight( it, out, 2, 4000 );
 	expected = new Float64Array( [ 0, 0, 6, 5, 4, 3, 2, 1 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -648,7 +648,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayviewRight( it, out, -6, 4 );
 	expected = new Float64Array( [ 0, 0, 2, 1, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -667,7 +667,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayviewRight( it, out, 2, -4 );
 	expected = new Float64Array( [ 0, 0, 2, 1, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -686,7 +686,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayviewRight( it, out, -6, -4 );
 	expected = new Float64Array( [ 0, 0, 2, 1, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -705,7 +705,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayviewRight( it, out, -1000 );
 	expected = new Float64Array( [ 0, 0, 0, 0, 4, 3, 2, 1 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -724,7 +724,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayviewRight( it, out, 0, -100 );
 	expected = new Float64Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -743,7 +743,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayviewRight( it, out, scale );
 	expected = new Float64Array( [ 4, 6, 6, 4 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -766,7 +766,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayviewRight( it, out, clbk );
 	expected = new Float64Array( [ 4, 0, 3, 1, 2, 2, 1, 3 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( reinterpret128( actual, 0 ), expected, 'returns expected value' );
 	t.end();
 
@@ -789,7 +789,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayviewRight( it, out, 2, scale );
 	expected = new Float64Array( [ 0, 0, 36, 25, 16, 9, 4, 1 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -812,7 +812,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayviewRight( it, out, -6, scale );
 	expected = new Float64Array( [ 0, 0, 36, 25, 16, 9, 4, 1 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -835,7 +835,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayviewRight( it, out, 2, 4, scale );
 	expected = new Float64Array( [ 0, 0, 4, 1, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -858,7 +858,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayviewRight( it, out, 2, 4000, scale );
 	expected = new Float64Array( [ 0, 0, 36, 25, 16, 9, 4, 1 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -881,7 +881,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayviewRight( it, out, -6, 4, scale );
 	expected = new Float64Array( [ 0, 0, 4, 1, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -904,7 +904,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayviewRight( it, out, 2, -4, scale );
 	expected = new Float64Array( [ 0, 0, 4, 1, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -927,7 +927,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayviewRight( it, out, -6, -4, scale );
 	expected = new Float64Array( [ 0, 0, 4, 1, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -950,7 +950,7 @@ tape( 'the function stops filling an array-like object once an iterator ends', f
 	actual = iterator2arrayviewRight( it, out );
 	expected = new Float64Array( [ 0, 0, 2, 1 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -969,7 +969,7 @@ tape( 'the function stops filling an array-like object once an iterator ends (ca
 	actual = iterator2arrayviewRight( it, out, scale );
 	expected = new Float64Array( [ 0, 0, 4, 1 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -996,7 +996,7 @@ tape( 'the function supports specifying the evaluation context of a provided cal
 	actual = iterator2arrayviewRight( it, out, scale, ctx );
 	expected = new Float64Array( [ 16, 9, 4, 1 ] );
 
-	t.equal( ctx.count, 4, 'returns expected value' );
+	t.strictEqual( ctx.count, 4, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -1024,7 +1024,7 @@ tape( 'the function supports specifying the evaluation context of a provided cal
 	actual = iterator2arrayviewRight( it, out, 2, scale, ctx );
 	expected = new Float64Array( [ 0, 0, 0, 0, 16, 9, 4, 1 ] );
 
-	t.equal( ctx.count, 4, 'returns expected value' );
+	t.strictEqual( ctx.count, 4, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -1052,7 +1052,7 @@ tape( 'the function supports specifying the evaluation context of a provided cal
 	actual = iterator2arrayviewRight( it, out, 2, 4, scale, ctx );
 	expected = new Float64Array( [ 0, 0, 4, 1, 0, 0, 0, 0 ] );
 
-	t.equal( ctx.count, 2, 'returns expected value' );
+	t.strictEqual( ctx.count, 2, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -1064,25 +1064,25 @@ tape( 'the function supports specifying the evaluation context of a provided cal
 
 tape( 'the function supports infinite iterators', function test( t ) {
 	var out = iterator2arrayviewRight( randu(), new Float64Array( 10 ) );
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 });
 
 tape( 'the function supports infinite iterators (begin)', function test( t ) {
 	var out = iterator2arrayviewRight( randu(), new Float64Array( 10 ), 5 );
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 });
 
 tape( 'the function supports infinite iterators (begin + end)', function test( t ) {
 	var out = iterator2arrayviewRight( randu(), new Float64Array( 10 ), 2, 6 );
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 });
 
 tape( 'the function supports infinite iterators (callback)', function test( t ) {
 	var out = iterator2arrayviewRight( randu(), new Float64Array( 10 ), scale );
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 
 	function scale( v, i ) {
@@ -1092,7 +1092,7 @@ tape( 'the function supports infinite iterators (callback)', function test( t )
 
 tape( 'the function supports infinite iterators (begin + callback)', function test( t ) {
 	var out = iterator2arrayviewRight( randu(), new Float64Array( 10 ), 5, scale ); // eslint-disable-line max-len
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 
 	function scale( v, i ) {
@@ -1102,7 +1102,7 @@ tape( 'the function supports infinite iterators (begin + callback)', function te
 
 tape( 'the function supports infinite iterators (begin + end + callback)', function test( t ) {
 	var out = iterator2arrayviewRight( randu(), new Float64Array( 10 ), 2, 6, scale ); // eslint-disable-line max-len
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 
 	function scale( v, i ) {
diff --git a/lib/node_modules/@stdlib/iter/to-array-view/test/test.js b/lib/node_modules/@stdlib/iter/to-array-view/test/test.js
index b3a25b7bd5dc..71b23c3247d5 100644
--- a/lib/node_modules/@stdlib/iter/to-array-view/test/test.js
+++ b/lib/node_modules/@stdlib/iter/to-array-view/test/test.js
@@ -507,7 +507,7 @@ tape( 'the function fills an array-like object with values returned from an iter
 	actual = iterator2arrayview( it, out );
 	expected = new Float64Array( values );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -531,7 +531,7 @@ tape( 'the function fills an array-like object with values returned from an iter
 	actual = iterator2arrayview( it, out );
 	expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( reinterpret128( actual, 0 ), expected, 'returns expected value' );
 	t.end();
 });
@@ -550,7 +550,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayview( it, out, 2 );
 	expected = new Float64Array( [ 0, 0, 1, 2, 3, 4, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -569,7 +569,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayview( it, out, 6 );
 	expected = new Float64Array( [ 0, 0, 0, 0, 0, 0, 1, 2 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -588,7 +588,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayview( it, out, -6 );
 	expected = new Float64Array( [ 0, 0, 1, 2, 3, 4, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -607,7 +607,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayview( it, out, 2, 4 );
 	expected = new Float64Array( [ 0, 0, 1, 2, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -626,7 +626,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayview( it, out, 2, 4000 );
 	expected = new Float64Array( [ 0, 0, 1, 2, 3, 4, 5, 6 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -645,7 +645,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayview( it, out, -6, 4 );
 	expected = new Float64Array( [ 0, 0, 1, 2, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -664,7 +664,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayview( it, out, 2, -4 );
 	expected = new Float64Array( [ 0, 0, 1, 2, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -683,7 +683,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayview( it, out, -6, -4 );
 	expected = new Float64Array( [ 0, 0, 1, 2, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -702,7 +702,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayview( it, out, -1000 );
 	expected = new Float64Array( [ 1, 2, 3, 4, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -721,7 +721,7 @@ tape( 'the function fills an array-like object view with values returned from an
 	actual = iterator2arrayview( it, out, 0, -100 );
 	expected = new Float64Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayview( it, out, scale );
 	expected = new Float64Array( [ 1, 4, 9, 16 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -763,7 +763,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayview( it, out, clbk );
 	expected = new Float64Array( [ 1, 0, 2, 1, 3, 2, 4, 3 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( reinterpret128( actual, 0 ), expected, 'returns expected value' );
 	t.end();
 
@@ -786,7 +786,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayview( it, out, 2, scale );
 	expected = new Float64Array( [ 0, 0, 1, 4, 9, 16, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -809,7 +809,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayview( it, out, -6, scale );
 	expected = new Float64Array( [ 0, 0, 1, 4, 9, 16, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -832,7 +832,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayview( it, out, 2, 4, scale );
 	expected = new Float64Array( [ 0, 0, 1, 4, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -855,7 +855,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayview( it, out, 2, 4000, scale );
 	expected = new Float64Array( [ 0, 0, 1, 4, 9, 16, 25, 36 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -878,7 +878,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayview( it, out, -6, 4, scale );
 	expected = new Float64Array( [ 0, 0, 1, 4, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -901,7 +901,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayview( it, out, 2, -4, scale );
 	expected = new Float64Array( [ 0, 0, 1, 4, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -924,7 +924,7 @@ tape( 'the function supports providing a callback to be invoked for each iterate
 	actual = iterator2arrayview( it, out, -6, -4, scale );
 	expected = new Float64Array( [ 0, 0, 1, 4, 0, 0, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -947,7 +947,7 @@ tape( 'the function stops filling an array-like object once an iterator ends', f
 	actual = iterator2arrayview( it, out );
 	expected = new Float64Array( [ 1, 2, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -966,7 +966,7 @@ tape( 'the function stops filling an array-like object once an iterator ends (ca
 	actual = iterator2arrayview( it, out, scale );
 	expected = new Float64Array( [ 1, 4, 0, 0 ] );
 
-	t.equal( actual, out, 'returns expected value' );
+	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -993,7 +993,7 @@ tape( 'the function supports specifying the evaluation context of a provided cal
 	actual = iterator2arrayview( it, out, scale, ctx );
 	expected = new Float64Array( [ 1, 4, 9, 16 ] );
 
-	t.equal( ctx.count, 4, 'returns expected value' );
+	t.strictEqual( ctx.count, 4, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -1021,7 +1021,7 @@ tape( 'the function supports specifying the evaluation context of a provided cal
 	actual = iterator2arrayview( it, out, 2, scale, ctx );
 	expected = new Float64Array( [ 0, 0, 1, 4, 9, 16, 0, 0 ] );
 
-	t.equal( ctx.count, 4, 'returns expected value' );
+	t.strictEqual( ctx.count, 4, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -1049,7 +1049,7 @@ tape( 'the function supports specifying the evaluation context of a provided cal
 	actual = iterator2arrayview( it, out, 2, 4, scale, ctx );
 	expected = new Float64Array( [ 0, 0, 1, 4, 0, 0, 0, 0 ] );
 
-	t.equal( ctx.count, 2, 'returns expected value' );
+	t.strictEqual( ctx.count, 2, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 
@@ -1061,25 +1061,25 @@ tape( 'the function supports specifying the evaluation context of a provided cal
 
 tape( 'the function supports infinite iterators', function test( t ) {
 	var out = iterator2arrayview( randu(), new Float64Array( 10 ) );
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 });
 
 tape( 'the function supports infinite iterators (begin)', function test( t ) {
 	var out = iterator2arrayview( randu(), new Float64Array( 10 ), 5 );
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 });
 
 tape( 'the function supports infinite iterators (begin + end)', function test( t ) {
 	var out = iterator2arrayview( randu(), new Float64Array( 10 ), 2, 6 );
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 });
 
 tape( 'the function supports infinite iterators (callback)', function test( t ) {
 	var out = iterator2arrayview( randu(), new Float64Array( 10 ), scale );
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 
 	function scale( v, i ) {
@@ -1089,7 +1089,7 @@ tape( 'the function supports infinite iterators (callback)', function test( t )
 
 tape( 'the function supports infinite iterators (begin + callback)', function test( t ) {
 	var out = iterator2arrayview( randu(), new Float64Array( 10 ), 5, scale );
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 
 	function scale( v, i ) {
@@ -1099,7 +1099,7 @@ tape( 'the function supports infinite iterators (begin + callback)', function te
 
 tape( 'the function supports infinite iterators (begin + end + callback)', function test( t ) {
 	var out = iterator2arrayview( randu(), new Float64Array( 10 ), 2, 6, scale ); // eslint-disable-line max-len
-	t.equal( out.length, 10, 'has expected length' );
+	t.strictEqual( out.length, 10, 'has expected length' );
 	t.end();
 
 	function scale( v, i ) {
diff --git a/lib/node_modules/@stdlib/iter/union/test/test.js b/lib/node_modules/@stdlib/iter/union/test/test.js
index 113bb141513a..403bd1986e7d 100644
--- a/lib/node_modules/@stdlib/iter/union/test/test.js
+++ b/lib/node_modules/@stdlib/iter/union/test/test.js
@@ -193,12 +193,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterUnion( randu(), randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -236,7 +236,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	];
 
 	it = iterUnion( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -258,7 +258,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterUnion( iterEmpty(), iterEmpty(), iterEmpty(), iterEmpty() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -300,7 +300,7 @@ tape( 'the function returns an iterator which returns the union of two iterators
 	];
 
 	it = iterUnion( array2iterator( values1 ), array2iterator( values2 ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -349,7 +349,7 @@ tape( 'the function returns an iterator which returns the union of three iterato
 	];
 
 	it = iterUnion( array2iterator( values1 ), array2iterator( values2 ), array2iterator( values3 ) ); // eslint-disable-line max-len
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -366,20 +366,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUnion( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -391,20 +391,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUnion( randu(), randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -428,16 +428,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterUnion( rand, rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -455,7 +455,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterUnion( randu(), randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -473,7 +473,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterUnion( rand, rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/unique-by-hash/test/test.js b/lib/node_modules/@stdlib/iter/unique-by-hash/test/test.js
index 19db011b2b50..7aeaf6094507 100644
--- a/lib/node_modules/@stdlib/iter/unique-by-hash/test/test.js
+++ b/lib/node_modules/@stdlib/iter/unique-by-hash/test/test.js
@@ -99,12 +99,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterUniqueByHash( randu(), hashFcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 
@@ -144,7 +144,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	];
 
 	it = iterUniqueByHash( array2iterator( values ), hashFcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
@@ -174,7 +174,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterUniqueByHash( array2iterator( values ), hashFcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -218,7 +218,7 @@ tape( 'the function returns an iterator which returns unique values', function t
 	];
 
 	it = iterUniqueByHash( array2iterator( values ), hashFcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -293,7 +293,7 @@ tape( 'the function returns an iterator which returns unique values (objects)',
 	];
 
 	it = iterUniqueByHash( array2iterator( values ), hashFcn );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -342,7 +342,7 @@ tape( 'the function supports providing a function evaluation context', function
 	];
 
 	it = iterUniqueByHash( array2iterator( values ), hashFcn, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
@@ -351,7 +351,7 @@ tape( 'the function supports providing a function evaluation context', function
 	actual.push( it.next() );
 
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, 4, 'returns expected value' );
+	t.strictEqual( ctx.count, 4, 'returns expected value' );
 	t.end();
 
 	function hashFcn( v ) {
@@ -367,20 +367,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUniqueByHash( randu(), hashFcn );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -396,20 +396,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUniqueByHash( randu(), hashFcn );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -437,16 +437,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterUniqueByHash( rand, hashFcn );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -468,7 +468,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterUniqueByHash( randu(), hashFcn );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -490,7 +490,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterUniqueByHash( rand, hashFcn );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/iter/unique-by/test/test.js b/lib/node_modules/@stdlib/iter/unique-by/test/test.js
index 6f8a63431295..311d526aa363 100644
--- a/lib/node_modules/@stdlib/iter/unique-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/unique-by/test/test.js
@@ -99,12 +99,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterUniqueBy( randu(), predicate );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 
@@ -144,7 +144,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	];
 
 	it = iterUniqueBy( array2iterator( values ), predicate );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
@@ -174,7 +174,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterUniqueBy( array2iterator( values ), predicate );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -218,7 +218,7 @@ tape( 'the function returns an iterator which returns unique values', function t
 	];
 
 	it = iterUniqueBy( array2iterator( values ), predicate );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -293,7 +293,7 @@ tape( 'the function returns an iterator which returns unique values (objects)',
 	];
 
 	it = iterUniqueBy( array2iterator( values ), predicate );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -342,7 +342,7 @@ tape( 'the function supports providing a function evaluation context', function
 	];
 
 	it = iterUniqueBy( array2iterator( values ), predicate, ctx );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
@@ -351,7 +351,7 @@ tape( 'the function supports providing a function evaluation context', function
 	actual.push( it.next() );
 
 	t.deepEqual( actual, expected, 'returns expected values' );
-	t.equal( ctx.count, 6, 'returns expected value' ); // calls per iterated value: 0+1+2+3
+	t.strictEqual( ctx.count, 6, 'returns expected value' ); // calls per iterated value: 0+1+2+3
 	t.end();
 
 	function predicate( a, b ) {
@@ -367,20 +367,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUniqueBy( randu(), predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -396,20 +396,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUniqueBy( randu(), predicate );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
@@ -437,16 +437,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterUniqueBy( rand, predicate );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -468,7 +468,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterUniqueBy( randu(), predicate );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
@@ -490,7 +490,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterUniqueBy( rand, predicate );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/iter/unique/test/test.js b/lib/node_modules/@stdlib/iter/unique/test/test.js
index b4550d17cd0c..7b12f3714adb 100644
--- a/lib/node_modules/@stdlib/iter/unique/test/test.js
+++ b/lib/node_modules/@stdlib/iter/unique/test/test.js
@@ -70,12 +70,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterUnique( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -111,7 +111,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	];
 
 	it = iterUnique( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
@@ -137,7 +137,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterUnique( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	actual.push( it.next() );
@@ -177,7 +177,7 @@ tape( 'the function returns an iterator which returns unique values', function t
 	];
 
 	it = iterUnique( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -194,20 +194,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUnique( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -219,20 +219,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUnique( randu() );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -256,16 +256,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterUnique( rand );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -283,7 +283,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterUnique( randu() );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -301,7 +301,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterUnique( rand );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/unitspace/test/test.js b/lib/node_modules/@stdlib/iter/unitspace/test/test.js
index edee3e63b9c5..68f6a50366a7 100644
--- a/lib/node_modules/@stdlib/iter/unitspace/test/test.js
+++ b/lib/node_modules/@stdlib/iter/unitspace/test/test.js
@@ -133,7 +133,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 	}
 
 	it = iterUnitspace( 0.5 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -161,7 +161,7 @@ tape( 'the function supports specifying a stopping value', function test( t ) {
 	});
 
 	it = iterUnitspace( 0, 50.5 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -178,20 +178,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUnitspace( 0, 99 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -203,20 +203,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUnitspace( 0, 99 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -232,16 +232,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterUnitspace( 0, 99 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -255,7 +255,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterUnitspace( 0, 99 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/unshift/test/test.js b/lib/node_modules/@stdlib/iter/unshift/test/test.js
index c6ccf5cf0781..382039622fbd 100644
--- a/lib/node_modules/@stdlib/iter/unshift/test/test.js
+++ b/lib/node_modules/@stdlib/iter/unshift/test/test.js
@@ -155,12 +155,12 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 	var i;
 
 	it = iterUnshift( randu() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns expected value' );
-		t.equal( v.done, false, 'returns expected value' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -204,7 +204,7 @@ tape( 'the function returns an iterator protocol-compliant object (finite iterat
 	];
 
 	it = iterUnshift( array2iterator( values ), 5, 6 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -235,7 +235,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterUnshift( iterEmpty(), 5, 6 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -258,7 +258,7 @@ tape( 'the function returns an iterator protocol-compliant object (empty iterato
 	];
 
 	it = iterUnshift( iterEmpty() );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -299,7 +299,7 @@ tape( 'the function returns an iterator protocol-compliant object (no additional
 	];
 
 	it = iterUnshift( array2iterator( values ) );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -316,20 +316,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUnshift( randu(), 1, 2, 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -341,20 +341,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUnshift( randu(), 1, 2, 3 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -378,16 +378,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterUnshift( rand, 1, 2, 3 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -405,7 +405,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterUnshift( randu(), 1, 2, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -423,7 +423,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterUnshift( rand, 1, 2, 3 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/until-each/test/test.js b/lib/node_modules/@stdlib/iter/until-each/test/test.js
index 64569f6dac99..cc5e25283fa8 100644
--- a/lib/node_modules/@stdlib/iter/until-each/test/test.js
+++ b/lib/node_modules/@stdlib/iter/until-each/test/test.js
@@ -130,28 +130,28 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterUntilEach( randu(), predicate, assert );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	count = 0;
 	i = 0;
 	do {
 		r = it.next();
 		if ( typeof r.value !== 'undefined' ) {
-			t.equal( typeof r.value, 'number', 'returns a number' );
+			t.strictEqual( typeof r.value, 'number', 'returns a number' );
 		}
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 		if ( r.done ) {
 			count += 1;
 		}
 		i += 1;
 	} while ( r.done === false );
-	t.equal( count, i, 'returns expected value' );
+	t.strictEqual( count, i, 'returns expected value' );
 	t.end();
 
 	function assert( v, i ) {
 		count += 1;
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -172,31 +172,31 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 	};
 	rand = randu( opts );
 	it = iterUntilEach( rand, predicate, assert );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	i = 0;
 	do {
 		r = it.next();
 		if ( typeof r.value !== 'undefined' ) {
-			t.equal( i, expected[ i ][ 1 ], 'provides expected value' );
-			t.equal( r.value, expected[ i ][ 0 ], 'returns expected value' );
+			t.strictEqual( i, expected[ i ][ 1 ], 'provides expected value' );
+			t.strictEqual( r.value, expected[ i ][ 0 ], 'returns expected value' );
 		}
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 		i += 1;
 	} while ( r.done === false );
-	t.equal( expected.length, i - 1, 'has expected length' );
+	t.strictEqual( expected.length, i - 1, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
 		expected.push( [ v, i ] );
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -211,26 +211,26 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUntilEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -245,26 +245,26 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUntilEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -291,16 +291,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterUntilEach( rand, predicate, assert );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -309,8 +309,8 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	}
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -327,13 +327,13 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterUntilEach( randu(), predicate, assert );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -354,12 +354,12 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterUntilEach( rand, predicate, assert );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
diff --git a/lib/node_modules/@stdlib/iter/while-each/test/test.js b/lib/node_modules/@stdlib/iter/while-each/test/test.js
index af841003fb3f..e4959593c0f5 100644
--- a/lib/node_modules/@stdlib/iter/while-each/test/test.js
+++ b/lib/node_modules/@stdlib/iter/while-each/test/test.js
@@ -130,28 +130,28 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	var i;
 
 	it = iterWhileEach( randu(), predicate, assert );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	count = 0;
 	i = 0;
 	do {
 		r = it.next();
 		if ( typeof r.value !== 'undefined' ) {
-			t.equal( typeof r.value, 'number', 'returns a number' );
+			t.strictEqual( typeof r.value, 'number', 'returns a number' );
 		}
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 		if ( r.done ) {
 			count += 1;
 		}
 		i += 1;
 	} while ( r.done === false );
-	t.equal( count, i, 'returns expected value' );
+	t.strictEqual( count, i, 'returns expected value' );
 	t.end();
 
 	function assert( v, i ) {
 		count += 1;
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -172,31 +172,31 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 	};
 	rand = randu( opts );
 	it = iterWhileEach( rand, predicate, assert );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	expected = [];
 	i = 0;
 	do {
 		r = it.next();
 		if ( typeof r.value !== 'undefined' ) {
-			t.equal( i, expected[ i ][ 1 ], 'provides expected value' );
-			t.equal( r.value, expected[ i ][ 0 ], 'returns expected value' );
+			t.strictEqual( i, expected[ i ][ 1 ], 'provides expected value' );
+			t.strictEqual( r.value, expected[ i ][ 0 ], 'returns expected value' );
 		}
-		t.equal( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
 		i += 1;
 	} while ( r.done === false );
-	t.equal( expected.length, i - 1, 'has expected length' );
+	t.strictEqual( expected.length, i - 1, 'has expected length' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
 		expected.push( [ v, i ] );
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -211,26 +211,26 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterWhileEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -245,26 +245,26 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterWhileEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -291,16 +291,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	rand[ '__ITERATOR_SYMBOL__' ] = factory;
 
 	it1 = iterWhileEach( rand, predicate, assert );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -309,8 +309,8 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	}
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -327,13 +327,13 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterWhileEach( randu(), predicate, assert );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
@@ -354,12 +354,12 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterWhileEach( rand, predicate, assert );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 	t.end();
 
 	function assert( v, i ) {
-		t.equal( isnan( v ), false, 'is not NaN' );
-		t.equal( isnan( i ), false, 'is not NaN' );
+		t.strictEqual( isnan( v ), false, 'is not NaN' );
+		t.strictEqual( isnan( i ), false, 'is not NaN' );
 	}
 
 	function predicate( v, i ) {
diff --git a/lib/node_modules/@stdlib/ml/incr/binary-classification/test/test.validate.js b/lib/node_modules/@stdlib/ml/incr/binary-classification/test/test.validate.js
index bd916c4cbf05..2b165d2a25e7 100644
--- a/lib/node_modules/@stdlib/ml/incr/binary-classification/test/test.validate.js
+++ b/lib/node_modules/@stdlib/ml/incr/binary-classification/test/test.validate.js
@@ -93,7 +93,7 @@ tape( 'the function returns an error if provided an `intercept` option which is
 		err = validate( options(), {
 			'intercept': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -120,7 +120,7 @@ tape( 'the function returns an error if provided an `lambda` option which is not
 		err = validate( options(), {
 			'lambda': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -146,7 +146,7 @@ tape( 'the function returns an error if provided a `learningRate` option which i
 		err = validate( options(), {
 			'learningRate': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -173,7 +173,7 @@ tape( 'the function returns an error if provided a `learningRate` option whose f
 		err = validate( options(), {
 			'learningRate': [ values[ i ] ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,12 +199,12 @@ tape( 'the function returns an error if provided a `learningRate` option whose s
 		err = validate( options(), {
 			'learningRate': [ 'constant', values[ i ] ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 
 		err = validate( options(), {
 			'learningRate': [ 'invscaling', values[ i ] ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -229,7 +229,7 @@ tape( 'the function returns an error if provided a `learningRate` option whose t
 		err = validate( options(), {
 			'learningRate': [ 'invscaling', 4, values[ i ] ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -256,7 +256,7 @@ tape( 'the function returns an error if provided a `loss` option which is not a
 		err = validate( options(), {
 			'loss': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -275,7 +275,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	err = validate( opts1, opts2 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts1, opts2, 'sets option values' );
 
 	t.end();
@@ -293,7 +293,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 	err = validate( opts1, opts2 );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts1, options(), 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.dot.js b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.dot.js
index 6b9db6174017..c36d3547664d 100644
--- a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.dot.js
+++ b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.dot.js
@@ -43,6 +43,6 @@ tape( 'the function calculates the dot product of two arrays', function test( t
 	expected = ( 2*1 ) + ( 3*2 ) + ( 1*3 );
 	actual = dot( x, y );
 
-	t.equal( actual, expected, 'returns the dot product' );
+	t.strictEqual( actual, expected, 'returns the dot product' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.eta_factory.js b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.eta_factory.js
index 6c4e3ba932df..4467aec3af0b 100644
--- a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.eta_factory.js
+++ b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.eta_factory.js
@@ -43,7 +43,7 @@ tape( 'the function throws an error if supplied an unknown `learningRate`', func
 
 tape( 'the function returns a function', function test( t ) {
 	var getEta = factory( 'basic', 0.02, 0.0 );
-	t.equal( typeof getEta, 'function', 'returns a function' );
+	t.strictEqual( typeof getEta, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -56,10 +56,10 @@ tape( 'the function returns eta0 when type is equal to `constant`', function tes
 	getEta = factory( 'constant', eta0, 0.0 );
 
 	eta = getEta();
-	t.equal( eta, eta0, 'returns eta0' );
+	t.strictEqual( eta, eta0, 'returns eta0' );
 
 	eta = getEta();
-	t.equal( eta, eta0, 'returns eta0' );
+	t.strictEqual( eta, eta0, 'returns eta0' );
 
 	t.end();
 });
@@ -77,15 +77,15 @@ tape( 'the function returns 1 over lambda times iteration number when type is eq
 	getEta = factory( 'pegasos', eta0, lambda );
 
 	eta = getEta();
-	t.equal( eta, 1.0 / ( lambda * it ), 'returns correct value' );
+	t.strictEqual( eta, 1.0 / ( lambda * it ), 'returns correct value' );
 	it += 1;
 
 	eta = getEta();
-	t.equal( eta, 1.0 / ( lambda * it ), 'returns correct value' );
+	t.strictEqual( eta, 1.0 / ( lambda * it ), 'returns correct value' );
 	it += 1;
 
 	eta = getEta();
-	t.equal( eta, 1.0 / ( lambda * it ), 'returns correct value' );
+	t.strictEqual( eta, 1.0 / ( lambda * it ), 'returns correct value' );
 	it += 1;
 
 	t.end();
@@ -104,15 +104,15 @@ tape( 'the function returns 1000 / ( 1000 + iteration ) when type is equal to `b
 	getEta = factory( 'basic', eta0, lambda );
 
 	eta = getEta();
-	t.equal( eta, 1000 / ( 1000 + it ), 'returns correct value' );
+	t.strictEqual( eta, 1000 / ( 1000 + it ), 'returns correct value' );
 	it += 1;
 
 	eta = getEta();
-	t.equal( eta, 1000 / ( 1000 + it ), 'returns correct value' );
+	t.strictEqual( eta, 1000 / ( 1000 + it ), 'returns correct value' );
 	it += 1;
 
 	eta = getEta();
-	t.equal( eta, 1000 / ( 1000 + it ), 'returns correct value' );
+	t.strictEqual( eta, 1000 / ( 1000 + it ), 'returns correct value' );
 	it += 1;
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.main.js b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.main.js
index 5db63279bbb4..d6131ff494ea 100644
--- a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.main.js
+++ b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.main.js
@@ -77,7 +77,7 @@ tape( 'the `loss` option of the function specifies the used loss function', func
 		accumulator = incrSGDRegression({
 			'loss': values[ i ]
 		});
-		t.equal( isFunction( accumulator ), true, 'returns a function' );
+		t.strictEqual( isFunction( accumulator ), true, 'returns a function' );
 	}
 
 	t.end();
@@ -130,13 +130,13 @@ tape( 'the function has an `intercept` option determining whether the regression
 		'intercept': true
 	});
 	accumulator( [ 1.0, 1.0, 1.0 ], 2.0 );
-	t.equal( accumulator.coefs.length, 4, 'the model contains a regression coefficient for the intercept' );
+	t.strictEqual( accumulator.coefs.length, 4, 'the model contains a regression coefficient for the intercept' );
 
 	accumulator = incrSGDRegression({
 		'intercept': false
 	});
 	accumulator( [ 1.0, 1.0, 1.0 ], 2.0 );
-	t.equal( accumulator.coefs.length, 3, 'the model does not contain an intercept regression coefficient' );
+	t.strictEqual( accumulator.coefs.length, 3, 'the model does not contain an intercept regression coefficient' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.validate.js b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.validate.js
index 8dc075952a44..3be5b28955c4 100644
--- a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.validate.js
+++ b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.validate.js
@@ -74,7 +74,7 @@ tape( 'the function returns an error if provided a `learningRate` option which i
 		err = validate( {}, {
 			'learningRate': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an error if provided a `loss` option which is not a
 		err = validate( {}, {
 			'loss': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'the function returns an error if provided an `intercept` option which is
 		err = validate( {}, {
 			'intercept': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function returns an error if provided an `eta0` option which is not a
 		err = validate( {}, {
 			'eta0': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -175,7 +175,7 @@ tape( 'the function returns an error if provided an `epsilon` option which is no
 		err = validate( {}, {
 			'epsilon': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -200,7 +200,7 @@ tape( 'the function returns an error if provided an `lambda` option which is not
 		err = validate( {}, {
 			'lambda': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -221,7 +221,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -239,7 +239,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.weight_vector.js b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.weight_vector.js
index 9e999edf3cf8..9579758d22ee 100644
--- a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.weight_vector.js
+++ b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.weight_vector.js
@@ -90,7 +90,7 @@ tape( 'the function throws an error if the `intercept` value is not a boolean va
 
 tape( 'the constructor returns a WeightVector', function test( t ) {
 	var weights = new WeightVector( 20, true );
-	t.equal( weights instanceof WeightVector, true, 'returns a WeightVector' );
+	t.strictEqual( weights instanceof WeightVector, true, 'returns a WeightVector' );
 	t.end();
 });
 
@@ -99,10 +99,10 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var weights;
 
 	weights = WeightVector( 2, false );
-	t.equal( weights instanceof WeightVector, true, 'returns a WeightVector' );
+	t.strictEqual( weights instanceof WeightVector, true, 'returns a WeightVector' );
 
 	weights = WeightVector( 3, true );
-	t.equal( weights instanceof WeightVector, true, 'returns a WeightVector' );
+	t.strictEqual( weights instanceof WeightVector, true, 'returns a WeightVector' );
 	t.end();
 
 	/* eslint-enable new-cap */
@@ -119,7 +119,7 @@ tape( 'the `innerProduct` method calculates the inner product of the weights and
 	weights.add( [ 1, 2, 3 ] );
 	dot = weights.innerProduct( [ 1, 2, 3 ] );
 	expected = 14;
-	t.equal( dot, expected, 'returns the inner product' );
+	t.strictEqual( dot, expected, 'returns the inner product' );
 
 	// With an implicit intercept:
 	weights = new WeightVector( 2, true );
@@ -127,7 +127,7 @@ tape( 'the `innerProduct` method calculates the inner product of the weights and
 
 	dot = weights.innerProduct( [ 1, 2 ] );
 	expected = 6; // => 1*1 + 2*2 + 1*1
-	t.equal( dot, expected, 'returns the inner product' );
+	t.strictEqual( dot, expected, 'returns the inner product' );
 	t.end();
 });
 
@@ -180,8 +180,8 @@ tape( 'the `scaleTo` method scales elements of the weight vector by the supplied
 
 	expectedNorm = weights.norm * 9.0;
 	weights.scaleTo( 3.0 );
-	t.equal( weights.scale, 3.0, 'scale is equal to 3.0' );
-	t.equal( weights.norm, expectedNorm, 'the new norm is equal to ' + expectedNorm );
+	t.strictEqual( weights.scale, 3.0, 'scale is equal to 3.0' );
+	t.strictEqual( weights.norm, expectedNorm, 'the new norm is equal to ' + expectedNorm );
 	t.end();
 });
 
@@ -194,7 +194,7 @@ tape( 'the `scaleTo` method scales the weights to one if the internal scale is s
 
 	weights.scaleTo( 1.0 );
 
-	t.equal( weights.scale, 1.0, 'scale is equal to 1.0' );
+	t.strictEqual( weights.scale, 1.0, 'scale is equal to 1.0' );
 
 	// eslint-disable-next-line no-underscore-dangle
 	t.deepEqual( weights._data, [ 2.0e-13, 2.0e-13, 2.0e-13], '_data array is equal to [2e-13,2e-13,2e-13]' );
diff --git a/lib/node_modules/@stdlib/ml/incr/test/test.js b/lib/node_modules/@stdlib/ml/incr/test/test.js
index 4703875b1edd..e682e93dba4d 100644
--- a/lib/node_modules/@stdlib/ml/incr/test/test.js
+++ b/lib/node_modules/@stdlib/ml/incr/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ml/test/test.js b/lib/node_modules/@stdlib/ml/test/test.js
index 2250fa38033a..2202a0aedda3 100644
--- a/lib/node_modules/@stdlib/ml/test/test.js
+++ b/lib/node_modules/@stdlib/ml/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains machine learning algorithms', function test( t ) {
 	var keys = objectKeys( ml );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/iter/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/test/test.js
index 9fdab6e77188..93a939a5f431 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/iter/to-array-each/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/to-array-each/test/test.js
index 21c7795cf09a..63f382d4a3f5 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/to-array-each/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/to-array-each/test/test.js
@@ -362,7 +362,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	x[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = nditer2arrayEach( x );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/proxy/test/test.js b/lib/node_modules/@stdlib/proxy/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/proxy/test/test.js
+++ b/lib/node_modules/@stdlib/proxy/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/awgn/test/test.js b/lib/node_modules/@stdlib/simulate/iter/awgn/test/test.js
index e9bd9f6758c6..9a2178351e5d 100644
--- a/lib/node_modules/@stdlib/simulate/iter/awgn/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/awgn/test/test.js
@@ -305,17 +305,17 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	values = [ 2.0, 3.0, 2.0, 4.0, 3.0, 4.0 ];
 	it = iterawgn( array2iterator( values ), 1.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 	}
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -328,17 +328,17 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	values = [ 2.0, 3.0, 2.0, 4.0, 3.0, 4.0 ];
 	it = iterawgn( array2iterator( values ), 1.0, {} );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 	}
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -367,20 +367,20 @@ tape( 'the function supports returning a seeded iterator protocol-compliant obje
 	it = iterawgn( array2iterator( values ), 1.0, {
 		'seed': 12345
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -409,20 +409,20 @@ tape( 'the function supports returning a seeded iterator protocol-compliant obje
 	it = iterawgn( array2iterator( values ), 1.0, {
 		'seed': [ 12345, 56789 ]
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -438,17 +438,17 @@ tape( 'the function supports providing a pseudorandom number generator for gener
 	it = iterawgn( array2iterator( values ), 1.0, {
 		'prng': boxMuller
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 	}
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -478,20 +478,20 @@ tape( 'the function supports providing a seeded pseudorandom number generator fo
 			'seed': 12345
 		})
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -517,7 +517,7 @@ tape( 'if an iterated value is a non-numeric value, the returned value is `NaN`'
 	it = iterawgn( array2iterator( values ), 0.2 );
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( isnan( v.value ), true, 'returns expected value' );
+		t.strictEqual( isnan( v.value ), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -557,7 +557,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 	// Use previously generated values...
 	for ( i = 0; i < values.length; i++ ) {
 		expected = values[ i ] + (arr[i]*2.0);
-		t.equal( it.next().value, expected, 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, expected, 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -614,8 +614,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -632,8 +632,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -664,19 +664,19 @@ tape( 'the returned iterator supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is a `PRNG` property', function test( t ) {
 	var it = iterawgn( randu(), 0.2 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterawgn( randu(), 0.2, {
 		'prng': boxMuller
 	});
-	t.equal( it.PRNG, null, 'returns expected value' );
+	t.strictEqual( it.PRNG, null, 'returns expected value' );
 	t.end();
 });
 
@@ -689,13 +689,13 @@ tape( 'attached to the returned iterator is the generator seed (integer seed)',
 	});
 	actual = it.seed;
 
-	t.equal( isUint32Array( actual ), true, 'has property' );
-	t.equal( actual[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( actual[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterawgn( randu(), 0.2, {
 		'prng': boxMuller
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -712,54 +712,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterawgn( randu(), 0.2 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterawgn( randu(), 0.2, {
 		'prng': boxMuller
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterawgn( randu(), 0.2 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterawgn( randu(), 0.2, {
 		'prng': boxMuller
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterawgn( randu(), 0.2 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterawgn( randu(), 0.2, {
 		'prng': boxMuller
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterawgn( randu(), 0.2 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterawgn( randu(), 0.2, {
 		'prng': boxMuller
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -770,20 +770,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterawgn( randu(), 0.2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -795,20 +795,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterawgn( randu(), 0.2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -834,16 +834,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	it1 = iterawgn( rand, 0.2, {
 		'seed': 56789
 	});
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -861,7 +861,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterawgn( randu(), 0.2 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -879,7 +879,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterawgn( rand, 0.2 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/awln/test/test.js b/lib/node_modules/@stdlib/simulate/iter/awln/test/test.js
index 6ee3c5592041..77b0e8b5326b 100644
--- a/lib/node_modules/@stdlib/simulate/iter/awln/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/awln/test/test.js
@@ -306,17 +306,17 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	values = [ 2.0, 3.0, 2.0, 4.0, 3.0, 4.0 ];
 	it = iterawun( array2iterator( values ), 1.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 	}
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -329,17 +329,17 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	values = [ 2.0, 3.0, 2.0, 4.0, 3.0, 4.0 ];
 	it = iterawun( array2iterator( values ), 1.0, {} );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 	}
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -368,20 +368,20 @@ tape( 'the function supports returning a seeded iterator protocol-compliant obje
 	it = iterawun( array2iterator( values ), 1.0, {
 		'seed': 12345
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -410,20 +410,20 @@ tape( 'the function supports returning a seeded iterator protocol-compliant obje
 	it = iterawun( array2iterator( values ), 1.0, {
 		'seed': [ 12345, 56789 ]
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -439,17 +439,17 @@ tape( 'the function supports providing a pseudorandom number generator for gener
 	it = iterawun( array2iterator( values ), 1.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 	}
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -484,20 +484,20 @@ tape( 'the function supports providing a seeded pseudorandom number generator fo
 	it = iterawun( array2iterator( values ), 1.0, {
 		'prng': rand.normalized
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -523,7 +523,7 @@ tape( 'if an iterated value is a non-numeric value, the returned value is `NaN`'
 	it = iterawun( array2iterator( values ), 0.2 );
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( isnan( v.value ), true, 'returns expected value' );
+		t.strictEqual( isnan( v.value ), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -563,7 +563,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 	// Use previously generated values...
 	for ( i = 0; i < values.length; i++ ) {
 		expected = values[ i ] + arr[ i ];
-		t.equal( it.next().value, expected, 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, expected, 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -620,8 +620,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -638,8 +638,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -670,19 +670,19 @@ tape( 'the returned iterator supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is a `PRNG` property', function test( t ) {
 	var it = iterawun( randu(), 0.2 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterawun( randu(), 0.2, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'returns expected value' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'returns expected value' );
 	t.end();
 });
 
@@ -695,13 +695,13 @@ tape( 'attached to the returned iterator is the generator seed (integer seed)',
 	});
 	actual = it.seed;
 
-	t.equal( isUint32Array( actual ), true, 'has property' );
-	t.equal( actual[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( actual[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterawun( randu(), 0.2, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -718,54 +718,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterawun( randu(), 0.2 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterawun( randu(), 0.2, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterawun( randu(), 0.2 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterawun( randu(), 0.2, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterawun( randu(), 0.2 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterawun( randu(), 0.2, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterawun( randu(), 0.2 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterawun( randu(), 0.2, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -776,20 +776,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterawun( randu(), 0.2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -801,20 +801,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterawun( randu(), 0.2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -840,16 +840,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	it1 = iterawun( rand, 0.2, {
 		'seed': 56789
 	});
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -867,7 +867,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterawun( randu(), 0.2 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -885,7 +885,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterawun( rand, 0.2 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/awun/test/test.js b/lib/node_modules/@stdlib/simulate/iter/awun/test/test.js
index a3550cc39e64..abcd7c9bd483 100644
--- a/lib/node_modules/@stdlib/simulate/iter/awun/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/awun/test/test.js
@@ -306,17 +306,17 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	values = [ 2.0, 3.0, 2.0, 4.0, 3.0, 4.0 ];
 	it = iterawun( array2iterator( values ), 1.0 );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 	}
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -329,17 +329,17 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	values = [ 2.0, 3.0, 2.0, 4.0, 3.0, 4.0 ];
 	it = iterawun( array2iterator( values ), 1.0, {} );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 	}
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -368,20 +368,20 @@ tape( 'the function supports returning a seeded iterator protocol-compliant obje
 	it = iterawun( array2iterator( values ), 1.0, {
 		'seed': 12345
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -410,20 +410,20 @@ tape( 'the function supports returning a seeded iterator protocol-compliant obje
 	it = iterawun( array2iterator( values ), 1.0, {
 		'seed': [ 12345, 56789 ]
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -439,17 +439,17 @@ tape( 'the function supports providing a pseudorandom number generator for gener
 	it = iterawun( array2iterator( values ), 1.0, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 	}
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -482,20 +482,20 @@ tape( 'the function supports providing a seeded pseudorandom number generator fo
 	it = iterawun( array2iterator( values ), 1.0, {
 		'prng': rand.normalized
 	});
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( typeof v.value, 'number', 'returns a number' );
-		t.equal( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
 
 	v = it.next();
-	t.equal( v.value, void 0, 'returns expected value' );
-	t.equal( v.done, true, 'returns expected value' );
+	t.strictEqual( v.value, void 0, 'returns expected value' );
+	t.strictEqual( v.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -521,7 +521,7 @@ tape( 'if an iterated value is a non-numeric value, the returned value is `NaN`'
 	it = iterawun( array2iterator( values ), 0.2 );
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.equal( isnan( v.value ), true, 'returns expected value' );
+		t.strictEqual( isnan( v.value ), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -561,7 +561,7 @@ tape( 'the function supports specifying the generator state', function test( t )
 	// Use previously generated values...
 	for ( i = 0; i < values.length; i++ ) {
 		expected = values[ i ] + arr[ i ];
-		t.equal( it.next().value, expected, 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, expected, 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
@@ -618,8 +618,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 
@@ -636,8 +636,8 @@ tape( 'the function supports specifying a shared generator state', function test
 	for ( i = 0; i < 25; i++ ) {
 		v1 = it1.next().value;
 		v2 = it2.next().value;
-		t.equal( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
-		t.equal( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
+		t.strictEqual( v1, arr[ j ], 'returns expected value. i: '+j+'.' );
+		t.strictEqual( v2, arr[ j+1 ], 'returns expected value. i: '+(j+1)+'.' );
 		j += 2; // stride
 	}
 	t.end();
@@ -668,19 +668,19 @@ tape( 'the returned iterator supports setting the generator state', function tes
 
 	// Replay previously generated values...
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( it.next().value, arr[ i ], 'returns expected value. i: '+i+'.' );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is a `PRNG` property', function test( t ) {
 	var it = iterawun( randu(), 0.2 );
-	t.equal( typeof it.PRNG, 'function', 'has property' );
+	t.strictEqual( typeof it.PRNG, 'function', 'has property' );
 
 	it = iterawun( randu(), 0.2, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.PRNG, minstd.normalized, 'returns expected value' );
+	t.strictEqual( it.PRNG, minstd.normalized, 'returns expected value' );
 	t.end();
 });
 
@@ -693,13 +693,13 @@ tape( 'attached to the returned iterator is the generator seed (integer seed)',
 	});
 	actual = it.seed;
 
-	t.equal( isUint32Array( actual ), true, 'has property' );
-	t.equal( actual[ 0 ], 12345, 'equal to provided seed' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( actual[ 0 ], 12345, 'equal to provided seed' );
 
 	it = iterawun( randu(), 0.2, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seed, null, 'equal to `null`' );
+	t.strictEqual( it.seed, null, 'equal to `null`' );
 
 	t.end();
 });
@@ -716,54 +716,54 @@ tape( 'attached to the returned iterator is the generator seed (array seed)', fu
 	});
 
 	actual = it.seed;
-	t.equal( isUint32Array( actual ), true, 'has property' );
+	t.strictEqual( isUint32Array( actual ), true, 'has property' );
 	for ( i = 0; i < seed.length; i++ ) {
-		t.equal( actual[ i ], seed[ i ], 'returns expected value for word '+i );
+		t.strictEqual( actual[ i ], seed[ i ], 'returns expected value for word '+i );
 	}
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator seed length', function test( t ) {
 	var it = iterawun( randu(), 0.2 );
-	t.equal( typeof it.seedLength, 'number', 'has property' );
+	t.strictEqual( typeof it.seedLength, 'number', 'has property' );
 
 	it = iterawun( randu(), 0.2, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.seedLength, null, 'equal to `null`' );
+	t.strictEqual( it.seedLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state', function test( t ) {
 	var it = iterawun( randu(), 0.2 );
-	t.equal( isUint32Array( it.state ), true, 'has property' );
+	t.strictEqual( isUint32Array( it.state ), true, 'has property' );
 
 	it = iterawun( randu(), 0.2, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.state, null, 'equal to `null`' );
+	t.strictEqual( it.state, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state length', function test( t ) {
 	var it = iterawun( randu(), 0.2 );
-	t.equal( typeof it.stateLength, 'number', 'has property' );
+	t.strictEqual( typeof it.stateLength, 'number', 'has property' );
 
 	it = iterawun( randu(), 0.2, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.stateLength, null, 'equal to `null`' );
+	t.strictEqual( it.stateLength, null, 'equal to `null`' );
 	t.end();
 });
 
 tape( 'attached to the returned iterator is the generator state size', function test( t ) {
 	var it = iterawun( randu(), 0.2 );
-	t.equal( typeof it.byteLength, 'number', 'has property' );
+	t.strictEqual( typeof it.byteLength, 'number', 'has property' );
 
 	it = iterawun( randu(), 0.2, {
 		'prng': minstd.normalized
 	});
-	t.equal( it.byteLength, null, 'equal to `null`' );
+	t.strictEqual( it.byteLength, null, 'equal to `null`' );
 	t.end();
 });
 
@@ -774,20 +774,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterawun( randu(), 0.2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -799,20 +799,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterawun( randu(), 0.2 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -838,16 +838,16 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	it1 = iterawun( rand, 0.2, {
 		'seed': 56789
 	});
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 
@@ -865,7 +865,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterawun( randu(), 0.2 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
@@ -883,7 +883,7 @@ tape( 'if a provided iterator is not iterable, the returned iterator is not iter
 	rand[ '__ITERATOR_SYMBOL__' ] = null;
 
 	it = iterawun( rand, 0.2 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/bartlett-hann-pulse/test/test.js b/lib/node_modules/@stdlib/simulate/iter/bartlett-hann-pulse/test/test.js
index 7a1cbd4192c0..c4a106dd12af 100644
--- a/lib/node_modules/@stdlib/simulate/iter/bartlett-hann-pulse/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/bartlett-hann-pulse/test/test.js
@@ -185,17 +185,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	}
 
 	it = iterBartlettHannPulse();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -233,17 +233,17 @@ tape( 'the function supports specifying the pulse period', function test( t ) {
 		'period': T
 	};
 	it = iterBartlettHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -289,17 +289,17 @@ tape( 'the function supports specifying the pulse duration', function test( t )
 		'duration': tau
 	};
 	it = iterBartlettHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -346,17 +346,17 @@ tape( 'the function supports specifying the waveform amplitude', function test(
 		'amplitude': A
 	};
 	it = iterBartlettHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -403,17 +403,17 @@ tape( 'the function supports specifying the phase offset (left shift)', function
 		'offset': phi
 	};
 	it = iterBartlettHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -463,17 +463,17 @@ tape( 'the function supports specifying the phase offset (left shift; mod)', fun
 		'offset': phi
 	};
 	it = iterBartlettHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -523,17 +523,17 @@ tape( 'the function supports specifying the phase offset (right shift)', functio
 		'offset': phi
 	};
 	it = iterBartlettHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -583,17 +583,17 @@ tape( 'the function supports specifying the phase offset (right shift; mod)', fu
 		'offset': phi
 	};
 	it = iterBartlettHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -628,22 +628,22 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterBartlettHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -655,20 +655,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBartlettHannPulse();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -680,20 +680,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBartlettHannPulse();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -709,16 +709,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterBartlettHannPulse();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -732,7 +732,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterBartlettHannPulse();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/bartlett-pulse/test/test.js b/lib/node_modules/@stdlib/simulate/iter/bartlett-pulse/test/test.js
index ddf593e55eb4..b32755bd9081 100644
--- a/lib/node_modules/@stdlib/simulate/iter/bartlett-pulse/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/bartlett-pulse/test/test.js
@@ -183,17 +183,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	}
 
 	it = iterBartlettPulse();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -231,17 +231,17 @@ tape( 'the function supports specifying the pulse period', function test( t ) {
 		'period': T
 	};
 	it = iterBartlettPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -287,17 +287,17 @@ tape( 'the function supports specifying the pulse duration', function test( t )
 		'duration': tau
 	};
 	it = iterBartlettPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -344,17 +344,17 @@ tape( 'the function supports specifying the waveform amplitude', function test(
 		'amplitude': A
 	};
 	it = iterBartlettPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -401,17 +401,17 @@ tape( 'the function supports specifying the phase offset (left shift)', function
 		'offset': phi
 	};
 	it = iterBartlettPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -461,17 +461,17 @@ tape( 'the function supports specifying the phase offset (left shift; mod)', fun
 		'offset': phi
 	};
 	it = iterBartlettPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -521,17 +521,17 @@ tape( 'the function supports specifying the phase offset (right shift)', functio
 		'offset': phi
 	};
 	it = iterBartlettPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -581,17 +581,17 @@ tape( 'the function supports specifying the phase offset (right shift; mod)', fu
 		'offset': phi
 	};
 	it = iterBartlettPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -626,22 +626,22 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterBartlettPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -653,20 +653,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBartlettPulse();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -678,20 +678,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBartlettPulse();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -707,16 +707,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterBartlettPulse();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -730,7 +730,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterBartlettPulse();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/cosine-wave/test/test.js b/lib/node_modules/@stdlib/simulate/iter/cosine-wave/test/test.js
index e35b050eb6e7..73494713522c 100644
--- a/lib/node_modules/@stdlib/simulate/iter/cosine-wave/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/cosine-wave/test/test.js
@@ -157,17 +157,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	];
 
 	it = iterCosineWave();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -237,17 +237,17 @@ tape( 'the function supports specifying the waveform period', function test( t )
 		'period': 4
 	};
 	it = iterCosineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -318,17 +318,17 @@ tape( 'the function supports specifying the wave amplitude', function test( t )
 		'amplitude': 10.0
 	};
 	it = iterCosineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -399,17 +399,17 @@ tape( 'the function supports specifying the phase offset (left shift)', function
 		'offset': -3
 	};
 	it = iterCosineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -480,17 +480,17 @@ tape( 'the function supports specifying the phase offset (left shift; mod)', fun
 		'offset': -13
 	};
 	it = iterCosineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -561,17 +561,17 @@ tape( 'the function supports specifying the phase offset (right shift)', functio
 		'offset': 3
 	};
 	it = iterCosineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -642,17 +642,17 @@ tape( 'the function supports specifying the phase offset (right shift; mod)', fu
 		'offset': 23
 	};
 	it = iterCosineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -692,7 +692,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterCosineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -711,20 +711,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCosineWave();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -736,20 +736,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCosineWave();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -765,16 +765,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterCosineWave();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -788,7 +788,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterCosineWave();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/dirac-comb/test/test.js b/lib/node_modules/@stdlib/simulate/iter/dirac-comb/test/test.js
index bc4e256053b0..46e280784b49 100644
--- a/lib/node_modules/@stdlib/simulate/iter/dirac-comb/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/dirac-comb/test/test.js
@@ -153,7 +153,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	];
 
 	it = iterDiracComb();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
@@ -224,7 +224,7 @@ tape( 'the function supports specifying the waveform period', function test( t )
 		'period': 4
 	};
 	it = iterDiracComb( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
@@ -296,7 +296,7 @@ tape( 'the function supports specifying the phase offset (left shift)', function
 		'offset': -3
 	};
 	it = iterDiracComb( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
@@ -368,7 +368,7 @@ tape( 'the function supports specifying the phase offset (left shift; mod)', fun
 		'offset': -13
 	};
 	it = iterDiracComb( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
@@ -440,7 +440,7 @@ tape( 'the function supports specifying the phase offset (right shift)', functio
 		'offset': 3
 	};
 	it = iterDiracComb( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
@@ -512,7 +512,7 @@ tape( 'the function supports specifying the phase offset (right shift; mod)', fu
 		'offset': 23
 	};
 	it = iterDiracComb( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
@@ -555,7 +555,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterDiracComb( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
@@ -571,20 +571,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDiracComb();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -596,20 +596,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDiracComb();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -625,16 +625,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterDiracComb();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -648,7 +648,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterDiracComb();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/flat-top-pulse/test/test.js b/lib/node_modules/@stdlib/simulate/iter/flat-top-pulse/test/test.js
index 48178d4f64fb..2f3b2b928029 100644
--- a/lib/node_modules/@stdlib/simulate/iter/flat-top-pulse/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/flat-top-pulse/test/test.js
@@ -185,17 +185,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	}
 
 	it = iterFlatTopPulse();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -233,17 +233,17 @@ tape( 'the function supports specifying the pulse period', function test( t ) {
 		'period': T
 	};
 	it = iterFlatTopPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -289,17 +289,17 @@ tape( 'the function supports specifying the pulse duration', function test( t )
 		'duration': tau
 	};
 	it = iterFlatTopPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -346,17 +346,17 @@ tape( 'the function supports specifying the waveform amplitude', function test(
 		'amplitude': A
 	};
 	it = iterFlatTopPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -403,17 +403,17 @@ tape( 'the function supports specifying the phase offset (left shift)', function
 		'offset': phi
 	};
 	it = iterFlatTopPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -463,17 +463,17 @@ tape( 'the function supports specifying the phase offset (left shift; mod)', fun
 		'offset': phi
 	};
 	it = iterFlatTopPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -523,17 +523,17 @@ tape( 'the function supports specifying the phase offset (right shift)', functio
 		'offset': phi
 	};
 	it = iterFlatTopPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -583,17 +583,17 @@ tape( 'the function supports specifying the phase offset (right shift; mod)', fu
 		'offset': phi
 	};
 	it = iterFlatTopPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -628,22 +628,22 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterFlatTopPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -655,20 +655,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFlatTopPulse();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -680,20 +680,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFlatTopPulse();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -709,16 +709,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterFlatTopPulse();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -732,7 +732,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterFlatTopPulse();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/hann-pulse/test/test.js b/lib/node_modules/@stdlib/simulate/iter/hann-pulse/test/test.js
index f763eba541c4..9b40afc8a88b 100644
--- a/lib/node_modules/@stdlib/simulate/iter/hann-pulse/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/hann-pulse/test/test.js
@@ -177,17 +177,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	}
 
 	it = iterHannPulse();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -225,17 +225,17 @@ tape( 'the function supports specifying the pulse period', function test( t ) {
 		'period': T
 	};
 	it = iterHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -281,17 +281,17 @@ tape( 'the function supports specifying the pulse duration', function test( t )
 		'duration': tau
 	};
 	it = iterHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -338,17 +338,17 @@ tape( 'the function supports specifying the waveform amplitude', function test(
 		'amplitude': A
 	};
 	it = iterHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -395,17 +395,17 @@ tape( 'the function supports specifying the phase offset (left shift)', function
 		'offset': phi
 	};
 	it = iterHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -455,17 +455,17 @@ tape( 'the function supports specifying the phase offset (left shift; mod)', fun
 		'offset': phi
 	};
 	it = iterHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -515,17 +515,17 @@ tape( 'the function supports specifying the phase offset (right shift)', functio
 		'offset': phi
 	};
 	it = iterHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -575,17 +575,17 @@ tape( 'the function supports specifying the phase offset (right shift; mod)', fu
 		'offset': phi
 	};
 	it = iterHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -622,22 +622,22 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterHannPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -649,20 +649,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterHannPulse();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -674,20 +674,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterHannPulse();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -703,16 +703,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterHannPulse();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -726,7 +726,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterHannPulse();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/lanczos-pulse/test/test.js b/lib/node_modules/@stdlib/simulate/iter/lanczos-pulse/test/test.js
index 2f771d4edf0b..f304ebb38e24 100644
--- a/lib/node_modules/@stdlib/simulate/iter/lanczos-pulse/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/lanczos-pulse/test/test.js
@@ -184,17 +184,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	}
 
 	it = iterLanczosPulse();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -232,17 +232,17 @@ tape( 'the function supports specifying the pulse period', function test( t ) {
 		'period': T
 	};
 	it = iterLanczosPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -288,17 +288,17 @@ tape( 'the function supports specifying the pulse duration', function test( t )
 		'duration': tau
 	};
 	it = iterLanczosPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -345,17 +345,17 @@ tape( 'the function supports specifying the waveform amplitude', function test(
 		'amplitude': A
 	};
 	it = iterLanczosPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -402,17 +402,17 @@ tape( 'the function supports specifying the phase offset (left shift)', function
 		'offset': phi
 	};
 	it = iterLanczosPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -462,17 +462,17 @@ tape( 'the function supports specifying the phase offset (left shift; mod)', fun
 		'offset': phi
 	};
 	it = iterLanczosPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -522,17 +522,17 @@ tape( 'the function supports specifying the phase offset (right shift)', functio
 		'offset': phi
 	};
 	it = iterLanczosPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -582,17 +582,17 @@ tape( 'the function supports specifying the phase offset (right shift; mod)', fu
 		'offset': phi
 	};
 	it = iterLanczosPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -627,22 +627,22 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterLanczosPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -654,20 +654,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLanczosPulse();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -679,20 +679,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLanczosPulse();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -708,16 +708,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterLanczosPulse();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -731,7 +731,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterLanczosPulse();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/periodic-sinc/test/test.js b/lib/node_modules/@stdlib/simulate/iter/periodic-sinc/test/test.js
index fa1735d93298..8590efea3225 100644
--- a/lib/node_modules/@stdlib/simulate/iter/periodic-sinc/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/periodic-sinc/test/test.js
@@ -207,17 +207,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	}
 
 	it = iterPeriodicSinc( n );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -251,17 +251,17 @@ tape( 'the function supports specifying the waveform period (odd N; even period)
 		'period': tau
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -295,17 +295,17 @@ tape( 'the function supports specifying the waveform period (odd N; odd period)'
 		'period': tau
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -339,17 +339,17 @@ tape( 'the function supports specifying the waveform period (even N; even period
 		'period': tau
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -383,17 +383,17 @@ tape( 'the function supports specifying the waveform period (even N; odd period)
 		'period': tau
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -430,17 +430,17 @@ tape( 'the function supports specifying the wave amplitude (odd N)', function te
 		'amplitude': a
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -477,17 +477,17 @@ tape( 'the function supports specifying the wave amplitude (even N)', function t
 		'amplitude': a
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -522,17 +522,17 @@ tape( 'the function supports specifying the phase offset (left shift; odd N)', f
 		'offset': phi
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -567,17 +567,17 @@ tape( 'the function supports specifying the phase offset (left shift; even N)',
 		'offset': phi
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -612,17 +612,17 @@ tape( 'the function supports specifying the phase offset (left shift; mod; odd N
 		'offset': phi
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -657,17 +657,17 @@ tape( 'the function supports specifying the phase offset (left shift; mod; even
 		'offset': phi
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -702,17 +702,17 @@ tape( 'the function supports specifying the phase offset (right shift; odd N)',
 		'offset': phi
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -747,17 +747,17 @@ tape( 'the function supports specifying the phase offset (right shift; even N)',
 		'offset': phi
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -792,17 +792,17 @@ tape( 'the function supports specifying the phase offset (right shift; mod; odd
 		'offset': phi
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -837,17 +837,17 @@ tape( 'the function supports specifying the phase offset (right shift; mod; even
 		'offset': phi
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -882,22 +882,22 @@ tape( 'the function supports limiting the number of iterations (odd N)', functio
 		'iter': 10
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -931,22 +931,22 @@ tape( 'the function supports limiting the number of iterations (even N)', functi
 		'iter': 10
 	};
 	it = iterPeriodicSinc( n, opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	actual = it.next();
-	t.equal( actual.value, void 0, 'returns expected value' );
-	t.equal( actual.done, true, 'returns expected value' );
+	t.strictEqual( actual.value, void 0, 'returns expected value' );
+	t.strictEqual( actual.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -958,20 +958,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPeriodicSinc( 7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -983,20 +983,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPeriodicSinc( 7 );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -1012,16 +1012,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterPeriodicSinc( 7 );
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -1035,7 +1035,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterPeriodicSinc( 7 );
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/pulse/test/test.js b/lib/node_modules/@stdlib/simulate/iter/pulse/test/test.js
index a4e25b6382a3..c051e7db4610 100644
--- a/lib/node_modules/@stdlib/simulate/iter/pulse/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/pulse/test/test.js
@@ -181,7 +181,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	];
 
 	it = iterPulse();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -253,7 +253,7 @@ tape( 'the function supports specifying the pulse period', function test( t ) {
 		'period': 4
 	};
 	it = iterPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -326,7 +326,7 @@ tape( 'the function supports specifying the pulse duration', function test( t )
 		'duration': 2
 	};
 	it = iterPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -401,7 +401,7 @@ tape( 'the function supports specifying the minimum and maximum amplitude', func
 		'max': 10.0
 	};
 	it = iterPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -475,7 +475,7 @@ tape( 'the function supports specifying the phase offset (left shift)', function
 		'offset': -3
 	};
 	it = iterPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -549,7 +549,7 @@ tape( 'the function supports specifying the phase offset (left shift; mod)', fun
 		'offset': -13
 	};
 	it = iterPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -623,7 +623,7 @@ tape( 'the function supports specifying the phase offset (right shift)', functio
 		'offset': 3
 	};
 	it = iterPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -697,7 +697,7 @@ tape( 'the function supports specifying the phase offset (right shift; mod)', fu
 		'offset': 23
 	};
 	it = iterPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -741,7 +741,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterPulse( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -760,20 +760,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPulse();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -785,20 +785,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPulse();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -814,16 +814,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterPulse();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -837,7 +837,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterPulse();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/sawtooth-wave/test/test.js b/lib/node_modules/@stdlib/simulate/iter/sawtooth-wave/test/test.js
index 0c3371ed4d0a..71ed3f374f67 100644
--- a/lib/node_modules/@stdlib/simulate/iter/sawtooth-wave/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/sawtooth-wave/test/test.js
@@ -160,17 +160,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	];
 
 	it = iterSawtoothWave();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -240,17 +240,17 @@ tape( 'the function supports specifying the waveform period', function test( t )
 		'period': 4
 	};
 	it = iterSawtoothWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -321,17 +321,17 @@ tape( 'the function supports specifying the wave amplitude', function test( t )
 		'amplitude': 10.0
 	};
 	it = iterSawtoothWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -402,17 +402,17 @@ tape( 'the function supports specifying the phase offset (left shift)', function
 		'offset': -3
 	};
 	it = iterSawtoothWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -483,17 +483,17 @@ tape( 'the function supports specifying the phase offset (left shift; mod)', fun
 		'offset': -13
 	};
 	it = iterSawtoothWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -564,17 +564,17 @@ tape( 'the function supports specifying the phase offset (right shift)', functio
 		'offset': 3
 	};
 	it = iterSawtoothWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -645,17 +645,17 @@ tape( 'the function supports specifying the phase offset (right shift; mod)', fu
 		'offset': 23
 	};
 	it = iterSawtoothWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -697,17 +697,17 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterSawtoothWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -720,20 +720,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSawtoothWave();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -745,20 +745,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSawtoothWave();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -774,16 +774,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterSawtoothWave();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -797,7 +797,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterSawtoothWave();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/sine-wave/test/test.js b/lib/node_modules/@stdlib/simulate/iter/sine-wave/test/test.js
index d7543efa6af8..20b783e40081 100644
--- a/lib/node_modules/@stdlib/simulate/iter/sine-wave/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/sine-wave/test/test.js
@@ -157,17 +157,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	];
 
 	it = iterSineWave();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -237,17 +237,17 @@ tape( 'the function supports specifying the waveform period', function test( t )
 		'period': 4
 	};
 	it = iterSineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -318,17 +318,17 @@ tape( 'the function supports specifying the wave amplitude', function test( t )
 		'amplitude': 10.0
 	};
 	it = iterSineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -399,17 +399,17 @@ tape( 'the function supports specifying the phase offset (left shift)', function
 		'offset': -3
 	};
 	it = iterSineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -480,17 +480,17 @@ tape( 'the function supports specifying the phase offset (left shift; mod)', fun
 		'offset': -13
 	};
 	it = iterSineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -561,17 +561,17 @@ tape( 'the function supports specifying the phase offset (right shift)', functio
 		'offset': 3
 	};
 	it = iterSineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -642,17 +642,17 @@ tape( 'the function supports specifying the phase offset (right shift; mod)', fu
 		'offset': 23
 	};
 	it = iterSineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -692,7 +692,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterSineWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -711,20 +711,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSineWave();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -736,20 +736,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSineWave();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -765,16 +765,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterSineWave();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -788,7 +788,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterSineWave();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/square-wave/test/test.js b/lib/node_modules/@stdlib/simulate/iter/square-wave/test/test.js
index a1e982a71e65..8de3ef81509c 100644
--- a/lib/node_modules/@stdlib/simulate/iter/square-wave/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/square-wave/test/test.js
@@ -152,7 +152,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	];
 
 	it = iterSquareWave();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -224,7 +224,7 @@ tape( 'the function supports specifying the waveform period', function test( t )
 		'period': 4
 	};
 	it = iterSquareWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -298,7 +298,7 @@ tape( 'the function supports specifying the minimum and maximum amplitude', func
 		'max': 10.0
 	};
 	it = iterSquareWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -371,7 +371,7 @@ tape( 'the function supports specifying the phase offset (left shift)', function
 		'offset': -3
 	};
 	it = iterSquareWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -444,7 +444,7 @@ tape( 'the function supports specifying the phase offset (left shift; mod)', fun
 		'offset': -13
 	};
 	it = iterSquareWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -517,7 +517,7 @@ tape( 'the function supports specifying the phase offset (right shift)', functio
 		'offset': 3
 	};
 	it = iterSquareWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -590,7 +590,7 @@ tape( 'the function supports specifying the phase offset (right shift; mod)', fu
 		'offset': 23
 	};
 	it = iterSquareWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < expected.length; i++ ) {
@@ -634,7 +634,7 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterSquareWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	actual = [];
 	for ( i = 0; i < opts.iter; i++ ) {
@@ -653,20 +653,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSquareWave();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -678,20 +678,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSquareWave();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -707,16 +707,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterSquareWave();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -730,7 +730,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterSquareWave();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/test/test.js b/lib/node_modules/@stdlib/simulate/iter/test/test.js
index 49eb06763302..a3c40495cb3c 100644
--- a/lib/node_modules/@stdlib/simulate/iter/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/iter/triangle-wave/test/test.js b/lib/node_modules/@stdlib/simulate/iter/triangle-wave/test/test.js
index 3202fde339a3..e6b5a9773d47 100644
--- a/lib/node_modules/@stdlib/simulate/iter/triangle-wave/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/triangle-wave/test/test.js
@@ -159,17 +159,17 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 	];
 
 	it = iterTriangleWave();
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -239,17 +239,17 @@ tape( 'the function supports specifying the waveform period', function test( t )
 		'period': 4
 	};
 	it = iterTriangleWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -320,17 +320,17 @@ tape( 'the function supports specifying the wave amplitude', function test( t )
 		'amplitude': 10.0
 	};
 	it = iterTriangleWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -401,17 +401,17 @@ tape( 'the function supports specifying the phase offset (left shift)', function
 		'offset': -3
 	};
 	it = iterTriangleWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -482,17 +482,17 @@ tape( 'the function supports specifying the phase offset (left shift; mod)', fun
 		'offset': -13
 	};
 	it = iterTriangleWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -563,17 +563,17 @@ tape( 'the function supports specifying the phase offset (right shift)', functio
 		'offset': 3
 	};
 	it = iterTriangleWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -644,17 +644,17 @@ tape( 'the function supports specifying the phase offset (right shift; mod)', fu
 		'offset': 23
 	};
 	it = iterTriangleWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -696,17 +696,17 @@ tape( 'the function supports limiting the number of iterations', function test(
 		'iter': 4
 	};
 	it = iterTriangleWave( opts );
-	t.equal( it.next.length, 0, 'has zero arity' );
+	t.strictEqual( it.next.length, 0, 'has zero arity' );
 
 	for ( i = 0; i < expected.length; i++ ) {
 		actual = it.next();
-		t.equal( actual.done, expected[ i ].done, 'returns expected value' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 		if ( actual.value === expected[ i ].value ) {
-			t.equal( actual.value, expected[ i ].value, 'returns expected value' );
+			t.strictEqual( actual.value, expected[ i ].value, 'returns expected value' );
 		} else {
 			delta = abs( actual.value - expected[ i ].value );
 			tol = 1.0 * EPS * abs( expected[ i ].value );
-			t.equal( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
+			t.strictEqual( delta <= tol, true, 'within tolerance. i: '+i+'. actual: '+actual.value+'. expected: '+expected[ i ].value+'. delta: '+delta+'. tol: '+tol+'.' );
 		}
 	}
 	t.end();
@@ -719,20 +719,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTriangleWave();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -744,20 +744,20 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTriangleWave();
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.equal( typeof r.value, 'number', 'returns a number' );
-	t.equal( r.done, false, 'returns expected value' );
+	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
-	t.equal( r.value, 'finished', 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, 'finished', 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	r = it.next();
-	t.equal( r.value, void 0, 'returns expected value' );
-	t.equal( r.done, true, 'returns expected value' );
+	t.strictEqual( r.value, void 0, 'returns expected value' );
+	t.strictEqual( r.done, true, 'returns expected value' );
 
 	t.end();
 });
@@ -773,16 +773,16 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	});
 
 	it1 = iterTriangleWave();
-	t.equal( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
-	t.equal( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
+	t.strictEqual( typeof it1[ '__ITERATOR_SYMBOL__' ], 'function', 'has method' );
+	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.equal( typeof it2, 'object', 'returns an object' );
-	t.equal( typeof it2.next, 'function', 'has method' );
-	t.equal( typeof it2.return, 'function', 'has method' );
+	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2.next, 'function', 'has method' );
+	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( it2.next().value, it1.next().value, 'returns expected value' );
+		t.strictEqual( it2.next().value, it1.next().value, 'returns expected value' );
 	}
 	t.end();
 });
@@ -796,7 +796,7 @@ tape( 'if an environment does not support `Symbol.iterator`, the returned iterat
 	});
 
 	it = iterTriangleWave();
-	t.equal( it[ iteratorSymbol ], void 0, 'does not have property' );
+	t.strictEqual( it[ iteratorSymbol ], void 0, 'does not have property' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js
index 8673c83981e8..677564935419 100644
--- a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -112,7 +112,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 'beep' ) instanceof DebugSinkStream, true, 'returns stream instances' );
+		t.strictEqual( createStream( 'beep' ) instanceof DebugSinkStream, true, 'returns stream instances' );
 	}
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns a factory function which creates stream instances (c
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 'beep', noop ) instanceof DebugSinkStream, true, 'returns stream instances' );
+		t.strictEqual( createStream( 'beep', noop ) instanceof DebugSinkStream, true, 'returns stream instances' );
 	}
 	t.end();
 });
@@ -139,7 +139,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	});
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 'beep', noop ) instanceof DebugSinkStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 'beep', noop ) instanceof DebugSinkStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.js b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.js
index 01b485586f77..97f1f003a045 100644
--- a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof debugSinkStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof debugSinkStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof debugSinkStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof debugSinkStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.main.js b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.main.js
index 4a87ce7a3167..127e2884d3b6 100644
--- a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.main.js
@@ -124,7 +124,7 @@ tape( 'the constructor throws an error if provided an invalid option (w/ callbac
 
 tape( 'the constructor returns a Writable stream', function test( t ) {
 	var s = new DebugSinkStream( noop );
-	t.equal( s instanceof Writable, true, 'returns a Writable stream' );
+	t.strictEqual( s instanceof Writable, true, 'returns a Writable stream' );
 	t.end();
 });
 
@@ -133,16 +133,16 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = stream();
-	t.equal( s instanceof Writable, true, 'returns a Writable stream' );
+	t.strictEqual( s instanceof Writable, true, 'returns a Writable stream' );
 
 	s = stream( {} );
-	t.equal( s instanceof Writable, true, 'returns a Writable stream' );
+	t.strictEqual( s instanceof Writable, true, 'returns a Writable stream' );
 
 	s = stream( noop );
-	t.equal( s instanceof Writable, true, 'returns a Writable stream' );
+	t.strictEqual( s instanceof Writable, true, 'returns a Writable stream' );
 
 	s = stream( {}, noop );
-	t.equal( s instanceof Writable, true, 'returns a Writable stream' );
+	t.strictEqual( s instanceof Writable, true, 'returns a Writable stream' );
 
 	t.end();
 });
@@ -161,7 +161,7 @@ tape( 'the constructor supports providing a debug namespace', function test( t )
 	stream( opts );
 
 	function debug( name ) {
-		t.equal( name, NAMESPACE+':'+opts.name, 'uses provided debug namespace' );
+		t.strictEqual( name, NAMESPACE+':'+opts.name, 'uses provided debug namespace' );
 		t.end();
 	}
 });
@@ -219,7 +219,7 @@ tape( 'the returned stream invokes a provided callback with streamed data (conve
 
 	function debug() {
 		return function debug( data ) {
-			t.equal( typeof data, 'string', 'logs data' );
+			t.strictEqual( typeof data, 'string', 'logs data' );
 			cnt += 1;
 			if ( cnt === total ) {
 				t.end();
@@ -244,9 +244,9 @@ tape( 'the returned stream invokes a provided callback with streamed data', func
 	s.end();
 
 	function onData( debug, chunk, idx ) {
-		t.equal( typeof debug, 'function', 'first argument is a function' );
-		t.equal( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
-		t.equal( idx, cnt, 'streams expected index' );
+		t.strictEqual( typeof debug, 'function', 'first argument is a function' );
+		t.strictEqual( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( idx, cnt, 'streams expected index' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -274,9 +274,9 @@ tape( 'the returned stream invokes a provided callback with streamed data when i
 	s.end();
 
 	function onData( debug, chunk, idx ) {
-		t.equal( typeof debug, 'function', 'first argument is a function' );
+		t.strictEqual( typeof debug, 'function', 'first argument is a function' );
 		t.deepEqual( chunk, expected[ cnt ], 'streams expected chunk' );
-		t.equal( idx, cnt, 'streams expected index' );
+		t.strictEqual( idx, cnt, 'streams expected index' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -290,7 +290,7 @@ tape( 'the returned stream provides a method to destroy a stream', function test
 
 	s = new DebugSinkStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -323,7 +323,7 @@ tape( 'the returned stream provides a method to destroy a stream (subsequent wri
 
 	s = new DebugSinkStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
diff --git a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.object_mode.js
index fa5c2bdc4e02..f83034b8642c 100644
--- a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.object_mode.js
@@ -144,7 +144,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode();
-	t.equal( stream instanceof DebugSinkStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof DebugSinkStream, true, 'returns a stream instance' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.validate.js
index 17125aa7eca3..f03cdb0fa926 100644
--- a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.validate.js
@@ -75,7 +75,7 @@ tape( 'the function returns an error if provided a `name` option which is not a
 		err = validate( {}, {
 			'name': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns an error if provided a `decodeStrings` option which
 		err = validate( {}, {
 			'decodeStrings': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -151,7 +151,7 @@ tape( 'the function returns an error if provided an `defaultEncoding` option whi
 		err = validate( {}, {
 			'defaultEncoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -176,7 +176,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -196,7 +196,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -214,7 +214,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js
index 718939d59a97..88833450b91e 100644
--- a/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -112,7 +112,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 'beep' ) instanceof DebugStream, true, 'returns stream instances' );
+		t.strictEqual( createStream( 'beep' ) instanceof DebugStream, true, 'returns stream instances' );
 	}
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns a factory function which creates stream instances (c
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 'beep', noop ) instanceof DebugStream, true, 'returns stream instances' );
+		t.strictEqual( createStream( 'beep', noop ) instanceof DebugStream, true, 'returns stream instances' );
 	}
 	t.end();
 });
@@ -140,7 +140,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	});
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 'beep', noop ) instanceof DebugStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 'beep', noop ) instanceof DebugStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/debug/test/test.js b/lib/node_modules/@stdlib/streams/node/debug/test/test.js
index 6eba9e33327f..d3cb4b3063ec 100644
--- a/lib/node_modules/@stdlib/streams/node/debug/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/debug/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof debugStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof debugStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof debugStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof debugStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/debug/test/test.main.js b/lib/node_modules/@stdlib/streams/node/debug/test/test.main.js
index 73a4fe37d5a8..3b3b90ac584b 100644
--- a/lib/node_modules/@stdlib/streams/node/debug/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/debug/test/test.main.js
@@ -124,7 +124,7 @@ tape( 'the constructor throws an error if provided an invalid option (w/ callbac
 
 tape( 'the constructor returns a Transform stream', function test( t ) {
 	var s = new DebugStream( noop );
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 	t.end();
 });
 
@@ -133,16 +133,16 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = stream();
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	s = stream( {} );
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	s = stream( noop );
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	s = stream( {}, noop );
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	t.end();
 });
@@ -161,7 +161,7 @@ tape( 'the constructor supports providing a debug namespace', function test( t )
 	stream( opts );
 
 	function debug( name ) {
-		t.equal( name, NAMESPACE+':'+opts.name, 'uses provided debug namespace' );
+		t.strictEqual( name, NAMESPACE+':'+opts.name, 'uses provided debug namespace' );
 		t.end();
 	}
 });
@@ -219,7 +219,7 @@ tape( 'the returned stream forwards streamed data to a logger (converts buffers
 
 	function debug() {
 		return function debug( data ) {
-			t.equal( typeof data, 'string', 'logs data' );
+			t.strictEqual( typeof data, 'string', 'logs data' );
 			cnt += 1;
 			if ( cnt === total ) {
 				t.end();
@@ -244,9 +244,9 @@ tape( 'the returned stream forwards streamed data to a provided callback', funct
 	s.end();
 
 	function onData( debug, chunk, idx ) {
-		t.equal( typeof debug, 'function', 'first argument is a function' );
-		t.equal( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
-		t.equal( idx, cnt, 'streams expected index' );
+		t.strictEqual( typeof debug, 'function', 'first argument is a function' );
+		t.strictEqual( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( idx, cnt, 'streams expected index' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -274,9 +274,9 @@ tape( 'the returned stream forwards streamed data to a provided callback when in
 	s.end();
 
 	function onData( debug, chunk, idx ) {
-		t.equal( typeof debug, 'function', 'first argument is a function' );
+		t.strictEqual( typeof debug, 'function', 'first argument is a function' );
 		t.deepEqual( chunk, expected[ cnt ], 'streams expected chunk' );
-		t.equal( idx, cnt, 'streams expected index' );
+		t.strictEqual( idx, cnt, 'streams expected index' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -290,7 +290,7 @@ tape( 'the returned stream provides a method to destroy a stream', function test
 
 	s = new DebugStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
diff --git a/lib/node_modules/@stdlib/streams/node/debug/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/debug/test/test.object_mode.js
index 31d6ce1029e7..2aba6d882db3 100644
--- a/lib/node_modules/@stdlib/streams/node/debug/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/debug/test/test.object_mode.js
@@ -142,7 +142,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode();
-	t.equal( stream instanceof DebugStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof DebugStream, true, 'returns a stream instance' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/debug/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/debug/test/test.validate.js
index 906e59a1fef3..7222e5fb3250 100644
--- a/lib/node_modules/@stdlib/streams/node/debug/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/debug/test/test.validate.js
@@ -75,7 +75,7 @@ tape( 'the function returns an error if provided a `name` option which is not a
 		err = validate( {}, {
 			'name': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns an error if provided a `readableObjectMode` option w
 		err = validate( {}, {
 			'readableObjectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -150,7 +150,7 @@ tape( 'the function returns an error if provided an `allowHalfOpen` option which
 		err = validate( {}, {
 			'allowHalfOpen': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -175,7 +175,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -195,7 +195,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -213,7 +213,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/empty/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/empty/test/test.factory.js
index ecc9b205ab8e..8536f90d6f82 100644
--- a/lib/node_modules/@stdlib/streams/node/empty/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/empty/test/test.factory.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -110,7 +110,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof EmptyStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof EmptyStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof EmptyStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof EmptyStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/empty/test/test.js b/lib/node_modules/@stdlib/streams/node/empty/test/test.js
index 4b9ed1260b97..4127c8aa540c 100644
--- a/lib/node_modules/@stdlib/streams/node/empty/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/empty/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof emptyStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof emptyStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof emptyStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof emptyStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/empty/test/test.main.js b/lib/node_modules/@stdlib/streams/node/empty/test/test.main.js
index 8327a1a2980e..758786d35dc3 100644
--- a/lib/node_modules/@stdlib/streams/node/empty/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/empty/test/test.main.js
@@ -96,7 +96,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new EmptyStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -105,13 +105,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = emptyStream();
-	t.equal( s instanceof EmptyStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof EmptyStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = emptyStream();
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -121,7 +121,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = emptyStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -156,7 +156,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = emptyStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
diff --git a/lib/node_modules/@stdlib/streams/node/empty/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/empty/test/test.object_mode.js
index 24acb31801c3..d5c39083166e 100644
--- a/lib/node_modules/@stdlib/streams/node/empty/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/empty/test/test.object_mode.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.equal( s instanceof EmptyStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof EmptyStream, true, 'returns a stream instance' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/empty/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/empty/test/test.validate.js
index a7afa3ad50e4..3222587933cd 100644
--- a/lib/node_modules/@stdlib/streams/node/empty/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/empty/test/test.validate.js
@@ -76,7 +76,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -101,7 +101,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -119,7 +119,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-array/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-array/test/test.factory.js
index 98cb543e7cbd..e514ac6b482b 100644
--- a/lib/node_modules/@stdlib/streams/node/from-array/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-array/test/test.factory.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -172,7 +172,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	arr = [ 1, 2, 3 ];
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( arr ) instanceof ArrayStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( arr ) instanceof ArrayStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -186,7 +186,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	arr = [ 1, 2, 3 ];
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( arr ) instanceof ArrayStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( arr ) instanceof ArrayStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-array/test/test.js b/lib/node_modules/@stdlib/streams/node/from-array/test/test.js
index 042180cb2797..699b42e5eeca 100644
--- a/lib/node_modules/@stdlib/streams/node/from-array/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/from-array/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof arrayStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof arrayStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof arrayStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof arrayStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-array/test/test.main.js b/lib/node_modules/@stdlib/streams/node/from-array/test/test.main.js
index a290bf03391d..4af3bb6d9608 100644
--- a/lib/node_modules/@stdlib/streams/node/from-array/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/from-array/test/test.main.js
@@ -155,7 +155,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new ArrayStream( [ 1, 2, 3 ] );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -164,13 +164,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = arrayStream( [ 1, 2, 3 ] );
-	t.equal( s instanceof ArrayStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof ArrayStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = arrayStream( [ 1, 2, 3 ] );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -180,7 +180,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = arrayStream( [ 1, 2, 3, 4, 5, 6, 7, 8 ] );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -215,7 +215,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = arrayStream( [ 1, 2, 3, 4, 5, 6, 7, 8 ] );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -284,7 +284,7 @@ tape( 'the constructor returns a stream which streams elements of an array-like
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -294,9 +294,9 @@ tape( 'the constructor returns a stream which streams elements of an array-like
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), values[ i ], 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), values[ i ], 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -327,7 +327,7 @@ tape( 'the constructor returns a stream which streams elements of an array-like
 
 	function inspect( v ) {
 		i += 1;
-		t.equal( v, values[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v, values[ i ], 'returns expected value. i: '+i+'.' );
 	}
 
 	function onEnd() {
@@ -364,7 +364,7 @@ tape( 'the constructor returns a stream which streams elements of an array-like
 
 	function inspect( chunk ) {
 		count += 1;
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 		if ( count === 10 ) {
 			s.destroy();
@@ -377,9 +377,9 @@ tape( 'the constructor returns a stream which streams elements of an array-like
 		t.pass( 'stream closed' );
 
 		result = result.split( '\n' );
-		t.equal( result.length >= 10, true, 'has expected length' );
+		t.strictEqual( result.length >= 10, true, 'has expected length' );
 		for ( i = 0; i < 10; i++ ) {
-			t.equal( typeof parseFloat( result[ i ] ), 'number', 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( typeof parseFloat( result[ i ] ), 'number', 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -413,7 +413,7 @@ tape( 'the constructor returns a stream which streams elements of an array-like
 
 	function inspect( v ) {
 		i += 1;
-		t.equal( typeof v, 'number', 'returns expected value. i: '+i+'.' );
+		t.strictEqual( typeof v, 'number', 'returns expected value. i: '+i+'.' );
 		if ( i === 10 ) {
 			return s.destroy();
 		}
@@ -506,7 +506,7 @@ tape( 'the constructor supports specifying the iteration direction (array)', fun
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -516,9 +516,9 @@ tape( 'the constructor supports specifying the iteration direction (array)', fun
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), values[ values.length-i-1 ], 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), values[ values.length-i-1 ], 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -550,7 +550,7 @@ tape( 'the constructor supports specifying the iteration direction (object mode;
 
 	function inspect( v ) {
 		i += 1;
-		t.equal( v, values[ values.length-i-1 ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v, values[ values.length-i-1 ], 'returns expected value. i: '+i+'.' );
 	}
 
 	function onEnd() {
@@ -584,10 +584,10 @@ tape( 'by default, the constructor returns a stream which streams newline-delimi
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( v, values[ i ], 'returns expected value' );
+			t.strictEqual( v, values[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -622,10 +622,10 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( v, values[ i ], 'returns expected value' );
+			t.strictEqual( v, values[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -681,7 +681,7 @@ tape( 'by default, the constructor returns a stream which serializes streamed va
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseJSON( result[ i ] );
 			t.deepEqual( v, values[ i ], 'returns expected value' );
@@ -733,9 +733,9 @@ tape( 'the constructor supports providing a custom serialization function (strin
 	function onEnd() {
 		var i;
 		result = result.split( '\n' );
-		t.equal( result.length, expected.length, 'has expected length' );
+		t.strictEqual( result.length, expected.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( result[ i ], expected[ i ], 'returns expected value' );
+			t.strictEqual( result[ i ], expected[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -784,9 +784,9 @@ tape( 'the constructor supports providing a custom serialization function (buffe
 	function onEnd() {
 		var i;
 		result = result.split( '\n' );
-		t.equal( result.length, expected.length, 'has expected length' );
+		t.strictEqual( result.length, expected.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( result[ i ], expected[ i ], 'returns expected value' );
+			t.strictEqual( result[ i ], expected[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -817,7 +817,7 @@ tape( 'in object mode, `null` values are reserved', function test( t ) {
 
 	function inspect( v, i ) {
 		count += 1;
-		t.equal( v, values[ i ], 'returns expected value' );
+		t.strictEqual( v, values[ i ], 'returns expected value' );
 	}
 
 	function onError( err ) {
@@ -827,8 +827,8 @@ tape( 'in object mode, `null` values are reserved', function test( t ) {
 
 	function onEnd() {
 		t.pass( 'stream ended' );
-		t.equal( FLG, false, 'stream does not emit an error' );
-		t.equal( count, 3, 'streamed expected number of values' );
+		t.strictEqual( FLG, false, 'stream does not emit an error' );
+		t.strictEqual( count, 3, 'streamed expected number of values' );
 		t.end();
 	}
 });
@@ -869,11 +869,11 @@ tape( 'by default, when not in object mode, a stream emits an `error` upon encou
 		var i;
 
 		t.pass( 'stream ended' );
-		t.equal( FLG, true, 'stream does emit an error' );
-		t.equal( count, 7, 'streamed expected number of values' );
+		t.strictEqual( FLG, true, 'stream does emit an error' );
+		t.strictEqual( count, 7, 'streamed expected number of values' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 7, 'has expected length' );
+		t.strictEqual( result.length, 7, 'has expected length' );
 
 		j = -1;
 		for ( i = 0; i < values.length; i++ ) {
@@ -881,7 +881,7 @@ tape( 'by default, when not in object mode, a stream emits an `error` upon encou
 				continue;
 			}
 			j += 1;
-			t.equal( parseFloat( result[ j ] ), values[ i ], 'returns expected value. i: '+i+'.' );
+			t.strictEqual( parseFloat( result[ j ] ), values[ i ], 'returns expected value. i: '+i+'.' );
 		}
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/streams/node/from-array/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/from-array/test/test.object_mode.js
index c18f85e5969d..11ecfe553a71 100644
--- a/lib/node_modules/@stdlib/streams/node/from-array/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/from-array/test/test.object_mode.js
@@ -122,13 +122,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( [ 1, 2, 3 ] );
-	t.equal( s instanceof ArrayStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof ArrayStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( [ 1, 2, 3 ], {} );
-	t.equal( s instanceof ArrayStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof ArrayStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -151,7 +151,7 @@ tape( 'the function returns a stream which streams elements of an array-like obj
 	s.pipe( iStream );
 
 	function inspect( v, i ) {
-		t.equal( v, values[ i ], 'returns expected value' );
+		t.strictEqual( v, values[ i ], 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -181,7 +181,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v, i ) {
-		t.equal( v, values[ i ], 'returns expected value' );
+		t.strictEqual( v, values[ i ], 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/streams/node/from-array/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/from-array/test/test.validate.js
index e4e3ace5f8f2..a448b29a63f6 100644
--- a/lib/node_modules/@stdlib/streams/node/from-array/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/from-array/test/test.validate.js
@@ -76,7 +76,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -154,7 +154,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -180,7 +180,7 @@ tape( 'the function returns an error if provided a `serialize` option which is n
 		err = validate( {}, {
 			'serialize': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -209,7 +209,7 @@ tape( 'the function returns an error if provided a `dir` option which is neither
 		err = validate( {}, {
 			'dir': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -230,7 +230,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -244,7 +244,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -266,7 +266,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.factory.js
index f0c592bdaa0e..8a1aeec03e83 100644
--- a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.factory.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -172,7 +172,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	arr = [ 1, 2, 3 ];
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( arr ) instanceof CircularArrayStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( arr ) instanceof CircularArrayStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -186,7 +186,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	arr = [ 1, 2, 3 ];
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( arr ) instanceof CircularArrayStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( arr ) instanceof CircularArrayStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.js b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.js
index 9a22765c27ac..2375396babda 100644
--- a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof circularArrayStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof circularArrayStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof circularArrayStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof circularArrayStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.main.js b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.main.js
index c65740daeeb4..bbc6090fbbec 100644
--- a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.main.js
@@ -155,7 +155,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new CircularArrayStream( [ 1, 2, 3 ] );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -164,13 +164,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = circularArrayStream( [ 1, 2, 3 ] );
-	t.equal( s instanceof CircularArrayStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof CircularArrayStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = circularArrayStream( [ 1, 2, 3 ] );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -180,7 +180,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = circularArrayStream( [ 1, 2, 3, 4, 5, 6, 7, 8 ] );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -215,7 +215,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = circularArrayStream( [ 1, 2, 3, 4, 5, 6, 7, 8 ] );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -285,7 +285,7 @@ tape( 'the constructor returns a stream which streams elements of a "circular" a
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -295,9 +295,9 @@ tape( 'the constructor returns a stream which streams elements of a "circular" a
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), values[ i%values.length ], 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), values[ i%values.length ], 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -329,7 +329,7 @@ tape( 'the constructor returns a stream which streams elements of a "circular" a
 
 	function inspect( v ) {
 		i += 1;
-		t.equal( v, values[ i%values.length ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v, values[ i%values.length ], 'returns expected value. i: '+i+'.' );
 	}
 
 	function onEnd() {
@@ -366,7 +366,7 @@ tape( 'the constructor returns a stream which streams elements of a "circular" a
 
 	function inspect( chunk ) {
 		count += 1;
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 		if ( count === 10 ) {
 			s.destroy();
@@ -379,9 +379,9 @@ tape( 'the constructor returns a stream which streams elements of a "circular" a
 		t.pass( 'stream closed' );
 
 		result = result.split( '\n' );
-		t.equal( result.length >= 10, true, 'has expected length' );
+		t.strictEqual( result.length >= 10, true, 'has expected length' );
 		for ( i = 0; i < 10; i++ ) {
-			t.equal( typeof parseFloat( result[ i ] ), 'number', 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( typeof parseFloat( result[ i ] ), 'number', 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -415,7 +415,7 @@ tape( 'the constructor returns a stream which streams elements of a "circular" a
 
 	function inspect( v ) {
 		i += 1;
-		t.equal( typeof v, 'number', 'returns expected value. i: '+i+'.' );
+		t.strictEqual( typeof v, 'number', 'returns expected value. i: '+i+'.' );
 		if ( i === 10 ) {
 			return s.destroy();
 		}
@@ -452,7 +452,7 @@ tape( 'the constructor supports specifying the iteration direction (array)', fun
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -462,9 +462,9 @@ tape( 'the constructor supports specifying the iteration direction (array)', fun
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), expected[ i ], 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), expected[ i ], 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -496,7 +496,7 @@ tape( 'the constructor supports specifying the iteration direction (object mode;
 	s.pipe( iStream );
 
 	function inspect( v, i ) {
-		t.equal( v, expected[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v, expected[ i ], 'returns expected value. i: '+i+'.' );
 	}
 
 	function onEnd() {
@@ -534,10 +534,10 @@ tape( 'by default, the constructor returns a stream which streams newline-delimi
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( v, values[ i ], 'returns expected value' );
+			t.strictEqual( v, values[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -573,10 +573,10 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( v, values[ i%values.length ], 'returns expected value' );
+			t.strictEqual( v, values[ i%values.length ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -636,7 +636,7 @@ tape( 'by default, the constructor returns a stream which serializes streamed va
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseJSON( result[ i ] );
 			t.deepEqual( v, values[ i%values.length ], 'returns expected value' );
@@ -689,9 +689,9 @@ tape( 'the constructor supports providing a custom serialization function (strin
 	function onEnd() {
 		var i;
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( result[ i ], expected[ i%expected.length ], 'returns expected value' );
+			t.strictEqual( result[ i ], expected[ i%expected.length ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -741,9 +741,9 @@ tape( 'the constructor supports providing a custom serialization function (buffe
 	function onEnd() {
 		var i;
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( result[ i ], expected[ i%expected.length ], 'returns expected value' );
+			t.strictEqual( result[ i ], expected[ i%expected.length ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -775,7 +775,7 @@ tape( 'in object mode, `null` values are reserved', function test( t ) {
 
 	function inspect( v, i ) {
 		count += 1;
-		t.equal( v, values[ i ], 'returns expected value' );
+		t.strictEqual( v, values[ i ], 'returns expected value' );
 	}
 
 	function onError( err ) {
@@ -785,8 +785,8 @@ tape( 'in object mode, `null` values are reserved', function test( t ) {
 
 	function onEnd() {
 		t.pass( 'stream ended' );
-		t.equal( FLG, false, 'stream does not emit an error' );
-		t.equal( count, 3, 'streamed expected number of values' );
+		t.strictEqual( FLG, false, 'stream does not emit an error' );
+		t.strictEqual( count, 3, 'streamed expected number of values' );
 		t.end();
 	}
 });
@@ -831,11 +831,11 @@ tape( 'by default, when not in object mode, a stream emits an `error` upon encou
 		var i;
 
 		t.pass( 'stream ended' );
-		t.equal( FLG, true, 'stream does emit an error' );
-		t.equal( count, 7, 'streamed expected number of values' );
+		t.strictEqual( FLG, true, 'stream does emit an error' );
+		t.strictEqual( count, 7, 'streamed expected number of values' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 7, 'has expected length' );
+		t.strictEqual( result.length, 7, 'has expected length' );
 
 		j = -1;
 		for ( i = 0; i < values.length; i++ ) {
@@ -843,7 +843,7 @@ tape( 'by default, when not in object mode, a stream emits an `error` upon encou
 				continue;
 			}
 			j += 1;
-			t.equal( parseFloat( result[ j ] ), values[ i ], 'returns expected value. i: '+i+'.' );
+			t.strictEqual( parseFloat( result[ j ] ), values[ i ], 'returns expected value. i: '+i+'.' );
 		}
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.object_mode.js
index cfb43cb61742..2f46b1a4a8b3 100644
--- a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.object_mode.js
@@ -122,13 +122,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( [ 1, 2, 3 ] );
-	t.equal( s instanceof CircularArrayStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof CircularArrayStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( [ 1, 2, 3 ], {} );
-	t.equal( s instanceof CircularArrayStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof CircularArrayStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -154,7 +154,7 @@ tape( 'the function returns a stream which streams elements of an array-like obj
 	s.pipe( iStream );
 
 	function inspect( v, i ) {
-		t.equal( v, values[ i%values.length ], 'returns expected value' );
+		t.strictEqual( v, values[ i%values.length ], 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -185,7 +185,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v, i ) {
-		t.equal( v, values[ i%values.length ], 'returns expected value' );
+		t.strictEqual( v, values[ i%values.length ], 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.validate.js
index 654df6379853..ed624e9b33f7 100644
--- a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.validate.js
@@ -76,7 +76,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -154,7 +154,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -180,7 +180,7 @@ tape( 'the function returns an error if provided a `serialize` option which is n
 		err = validate( {}, {
 			'serialize': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -208,7 +208,7 @@ tape( 'the function returns an error if provided an `iter` option which is not a
 		err = validate( {}, {
 			'iter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -237,7 +237,7 @@ tape( 'the function returns an error if provided a `dir` option which is neither
 		err = validate( {}, {
 			'dir': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -259,7 +259,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -274,7 +274,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -296,7 +296,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.factory.js
index 6a78fd8ebfc4..a0d6bcd71e82 100644
--- a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.factory.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -44,19 +44,19 @@ tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory({
 		'iter': 10
 	});
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 'beep' );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 'beep', {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -283,7 +283,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 'beep' ) instanceof ConstantStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 'beep' ) instanceof ConstantStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -297,7 +297,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	});
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 'beep' ) instanceof ConstantStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 'beep' ) instanceof ConstantStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -309,7 +309,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 'beep' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof ConstantStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof ConstantStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -321,7 +321,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 'beep', {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof ConstantStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof ConstantStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -352,7 +352,7 @@ tape( 'the function returns a function which creates streams which always stream
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, value, 'returns expected value' );
+		t.strictEqual( v, value, 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.js b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.js
index 58672dbcde63..e2fd493c995d 100644
--- a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof constantStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof constantStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof constantStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof constantStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.main.js b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.main.js
index a934bfcc065a..cfb0e65135ef 100644
--- a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.main.js
@@ -188,7 +188,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new ConstantStream( 'beep' );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -197,13 +197,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = constantStream( 'beep' );
-	t.equal( s instanceof ConstantStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof ConstantStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = constantStream( 'beep' );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -213,7 +213,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = constantStream( 'boop' );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -248,7 +248,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = constantStream( 'beep' );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -315,7 +315,7 @@ tape( 'the constructor returns a stream which always streams the same value (str
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -325,9 +325,9 @@ tape( 'the constructor returns a stream which always streams the same value (str
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), 3.14, 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), 3.14, 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -352,7 +352,7 @@ tape( 'the constructor returns a stream which always streams the same value (Buf
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -362,9 +362,9 @@ tape( 'the constructor returns a stream which always streams the same value (Buf
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), 3.14, 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), 3.14, 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -393,7 +393,7 @@ tape( 'the constructor returns a stream which always streams the same value (Uin
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -403,9 +403,9 @@ tape( 'the constructor returns a stream which always streams the same value (Uin
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 10, 'has expected length' );
+		t.strictEqual( result.length, 10, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), 3.14, 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), 3.14, 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -435,7 +435,7 @@ tape( 'the constructor returns a stream which always streams the same value (obj
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( v, value, 'returns expected value. i: '+count+'.' );
+		t.strictEqual( v, value, 'returns expected value. i: '+count+'.' );
 		if ( count >= 10 ) {
 			s.destroy();
 		}
@@ -473,11 +473,11 @@ tape( 'the constructor supports limiting the number of iterations', function tes
 
 	function inspect( v ) {
 		count += 1;
-		t.equal( v, 3.14, 'returns expected value' );
+		t.strictEqual( v, 3.14, 'returns expected value' );
 	}
 
 	function onEnd() {
-		t.equal( count === niter, true, 'performs expected number of iterations' );
+		t.strictEqual( count === niter, true, 'performs expected number of iterations' );
 		t.end();
 	}
 });
@@ -509,9 +509,9 @@ tape( 'by default, the constructor generates newline-delimited values', function
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( result[ i ], value, 'returns expected value' );
+			t.strictEqual( result[ i ], value, 'returns expected value' );
 		}
 		t.end();
 	}
@@ -543,9 +543,9 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, opts.iter, 'has expected length' );
+		t.strictEqual( result.length, opts.iter, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( result[ i ], '3.14', 'returns expected value' );
+			t.strictEqual( result[ i ], '3.14', 'returns expected value' );
 		}
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.object_mode.js
index dffc9726723f..7eac5a4d6835 100644
--- a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.object_mode.js
@@ -126,13 +126,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 'beep' );
-	t.equal( s instanceof ConstantStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof ConstantStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 'beep', {} );
-	t.equal( s instanceof ConstantStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof ConstantStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -158,7 +158,7 @@ tape( 'the function returns a stream which always streams the same value', funct
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, value, 'returns expected value' );
+		t.strictEqual( v, value, 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -186,7 +186,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.equal( v, 'beep', 'returns expected value' );
+		t.strictEqual( v, 'beep', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.validate.js
index 2e6a5c59ee72..533bab09f107 100644
--- a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.validate.js
@@ -76,7 +76,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -154,7 +154,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -182,7 +182,7 @@ tape( 'the function returns an error if provided an `iter` option which is not a
 		err = validate( {}, {
 			'iter': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -202,7 +202,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -215,7 +215,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -233,7 +233,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.factory.js
index 1c7757375415..0f76a77d7663 100644
--- a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.factory.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -173,7 +173,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	it = array2iterator( [ 1, 2, 3 ] );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( it ) instanceof IteratorStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( it ) instanceof IteratorStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -187,7 +187,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	it = array2iterator( [ 1, 2, 3 ] );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( it ) instanceof IteratorStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( it ) instanceof IteratorStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.js b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.js
index f1479e9d4a73..d17521034b4a 100644
--- a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof iteratorStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof iteratorStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof iteratorStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof iteratorStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.main.js b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.main.js
index 4ba4a7cb9060..cbe3711c60a8 100644
--- a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.main.js
@@ -157,7 +157,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new IteratorStream( array2iterator( [ 1, 2, 3 ] ) );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -166,13 +166,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = iteratorStream( array2iterator( [ 1, 2, 3 ] ) );
-	t.equal( s instanceof IteratorStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof IteratorStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = iteratorStream( array2iterator( [ 1, 2, 3 ] ) );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -182,7 +182,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = iteratorStream( randu() );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -217,7 +217,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = iteratorStream( randu() );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -288,7 +288,7 @@ tape( 'the constructor returns a stream which streams iterated values', function
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -298,9 +298,9 @@ tape( 'the constructor returns a stream which streams iterated values', function
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), values[ i ], 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), values[ i ], 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -333,7 +333,7 @@ tape( 'the constructor returns a stream which streams iterated values (object mo
 
 	function inspect( v ) {
 		i += 1;
-		t.equal( v, values[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v, values[ i ], 'returns expected value. i: '+i+'.' );
 	}
 
 	function onEnd() {
@@ -363,7 +363,7 @@ tape( 'the constructor returns a stream which streams iterated values (infinite
 
 	function inspect( chunk ) {
 		count += 1;
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 		if ( count === 10 ) {
 			s.destroy();
@@ -376,9 +376,9 @@ tape( 'the constructor returns a stream which streams iterated values (infinite
 		t.pass( 'stream closed' );
 
 		result = result.split( '\n' );
-		t.equal( result.length >= 10, true, 'has expected length' );
+		t.strictEqual( result.length >= 10, true, 'has expected length' );
 		for ( i = 0; i < 10; i++ ) {
-			t.equal( typeof parseFloat( result[ i ] ), 'number', 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( typeof parseFloat( result[ i ] ), 'number', 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -406,7 +406,7 @@ tape( 'the constructor returns a stream which streams iterated values (object mo
 
 	function inspect( v ) {
 		i += 1;
-		t.equal( typeof v, 'number', 'returns expected value. i: '+i+'.' );
+		t.strictEqual( typeof v, 'number', 'returns expected value. i: '+i+'.' );
 		if ( i === 10 ) {
 			return s.destroy();
 		}
@@ -441,7 +441,7 @@ tape( 'the constructor returns a stream which streams iterated values (value+don
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -451,9 +451,9 @@ tape( 'the constructor returns a stream which streams iterated values (value+don
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), values[ i ], 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), values[ i ], 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -519,7 +519,7 @@ tape( 'the constructor returns a stream which streams iterated values (object mo
 
 	function inspect( v ) {
 		i += 1;
-		t.equal( v, values[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v, values[ i ], 'returns expected value. i: '+i+'.' );
 	}
 
 	function onEnd() {
@@ -584,7 +584,7 @@ tape( 'the constructor returns a stream which streams iterated values (len=1; va
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -594,9 +594,9 @@ tape( 'the constructor returns a stream which streams iterated values (len=1; va
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), values[ i ], 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), values[ i ], 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -662,7 +662,7 @@ tape( 'the constructor returns a stream which streams iterated values (object mo
 
 	function inspect( v ) {
 		i += 1;
-		t.equal( v, values[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v, values[ i ], 'returns expected value. i: '+i+'.' );
 	}
 
 	function onEnd() {
@@ -731,10 +731,10 @@ tape( 'by default, the constructor returns a stream which streams newline-delimi
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( v, values[ i ], 'returns expected value' );
+			t.strictEqual( v, values[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -771,10 +771,10 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( v, values[ i ], 'returns expected value' );
+			t.strictEqual( v, values[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -832,7 +832,7 @@ tape( 'by default, the constructor returns a stream which serializes streamed va
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseJSON( result[ i ] );
 			t.deepEqual( v, values[ i ], 'returns expected value' );
@@ -886,9 +886,9 @@ tape( 'the constructor supports providing a custom serialization function (strin
 	function onEnd() {
 		var i;
 		result = result.split( '\n' );
-		t.equal( result.length, expected.length, 'has expected length' );
+		t.strictEqual( result.length, expected.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( result[ i ], expected[ i ], 'returns expected value' );
+			t.strictEqual( result[ i ], expected[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -939,9 +939,9 @@ tape( 'the constructor supports providing a custom serialization function (buffe
 	function onEnd() {
 		var i;
 		result = result.split( '\n' );
-		t.equal( result.length, expected.length, 'has expected length' );
+		t.strictEqual( result.length, expected.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( result[ i ], expected[ i ], 'returns expected value' );
+			t.strictEqual( result[ i ], expected[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -999,7 +999,7 @@ tape( 'by default, the constructor returns a stream which serializes streamed va
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseJSON( result[ i ] );
 			t.deepEqual( v, values[ i ], 'returns expected value' );
@@ -1086,9 +1086,9 @@ tape( 'the constructor supports providing a custom serialization function (value
 	function onEnd() {
 		var i;
 		result = result.split( '\n' );
-		t.equal( result.length, expected.length, 'has expected length' );
+		t.strictEqual( result.length, expected.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( result[ i ], expected[ i ], 'returns expected value' );
+			t.strictEqual( result[ i ], expected[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -1172,9 +1172,9 @@ tape( 'the constructor supports providing a custom serialization function (value
 	function onEnd() {
 		var i;
 		result = result.split( '\n' );
-		t.equal( result.length, expected.length, 'has expected length' );
+		t.strictEqual( result.length, expected.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( result[ i ], expected[ i ], 'returns expected value' );
+			t.strictEqual( result[ i ], expected[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -1251,9 +1251,9 @@ tape( 'the constructor supports providing a custom serialization function (value
 	function onEnd() {
 		var i;
 		result = result.split( '\n' );
-		t.equal( result.length, expected.length, 'has expected length' );
+		t.strictEqual( result.length, expected.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( result[ i ], expected[ i ], 'returns expected value' );
+			t.strictEqual( result[ i ], expected[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -1319,7 +1319,7 @@ tape( 'in object mode, `null` values are reserved', function test( t ) {
 
 	function inspect( v, i ) {
 		count += 1;
-		t.equal( v, values[ i ], 'returns expected value' );
+		t.strictEqual( v, values[ i ], 'returns expected value' );
 	}
 
 	function onError( err ) {
@@ -1329,8 +1329,8 @@ tape( 'in object mode, `null` values are reserved', function test( t ) {
 
 	function onEnd() {
 		t.pass( 'stream ended' );
-		t.equal( FLG, false, 'stream does not emit an error' );
-		t.equal( count, 3, 'streamed expected number of values' );
+		t.strictEqual( FLG, false, 'stream does not emit an error' );
+		t.strictEqual( count, 3, 'streamed expected number of values' );
 		t.end();
 	}
 });
@@ -1373,11 +1373,11 @@ tape( 'by default, when not in object mode, a stream emits an `error` upon encou
 		var i;
 
 		t.pass( 'stream ended' );
-		t.equal( FLG, true, 'stream does emit an error' );
-		t.equal( count, 7, 'streamed expected number of values' );
+		t.strictEqual( FLG, true, 'stream does emit an error' );
+		t.strictEqual( count, 7, 'streamed expected number of values' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 7, 'has expected length' );
+		t.strictEqual( result.length, 7, 'has expected length' );
 
 		j = -1;
 		for ( i = 0; i < values.length; i++ ) {
@@ -1385,7 +1385,7 @@ tape( 'by default, when not in object mode, a stream emits an `error` upon encou
 				continue;
 			}
 			j += 1;
-			t.equal( parseFloat( result[ j ] ), values[ i ], 'returns expected value. i: '+i+'.' );
+			t.strictEqual( parseFloat( result[ j ] ), values[ i ], 'returns expected value. i: '+i+'.' );
 		}
 		t.end();
 	}
@@ -1429,11 +1429,11 @@ tape( 'by default, when not in object mode, a stream emits an `error` upon encou
 		var i;
 
 		t.pass( 'stream ended' );
-		t.equal( FLG, true, 'stream does emit an error' );
-		t.equal( count, 7, 'streamed expected number of values' );
+		t.strictEqual( FLG, true, 'stream does emit an error' );
+		t.strictEqual( count, 7, 'streamed expected number of values' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 7, 'has expected length' );
+		t.strictEqual( result.length, 7, 'has expected length' );
 
 		j = -1;
 		for ( i = 0; i < values.length; i++ ) {
@@ -1441,7 +1441,7 @@ tape( 'by default, when not in object mode, a stream emits an `error` upon encou
 				continue;
 			}
 			j += 1;
-			t.equal( parseFloat( result[ j ] ), values[ i ], 'returns expected value. i: '+i+'.' );
+			t.strictEqual( parseFloat( result[ j ] ), values[ i ], 'returns expected value. i: '+i+'.' );
 		}
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.object_mode.js
index 57ded1c9d88f..22e1cdb68b8c 100644
--- a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.object_mode.js
@@ -124,13 +124,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( array2iterator( [ 1, 2, 3 ] ) );
-	t.equal( s instanceof IteratorStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof IteratorStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( array2iterator( [ 1, 2, 3 ] ), {} );
-	t.equal( s instanceof IteratorStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof IteratorStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -155,7 +155,7 @@ tape( 'the function returns a stream which streams iterated values', function te
 	s.pipe( iStream );
 
 	function inspect( v, i ) {
-		t.equal( v, values[ i ], 'returns expected value' );
+		t.strictEqual( v, values[ i ], 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -187,7 +187,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v, i ) {
-		t.equal( v, values[ i ], 'returns expected value' );
+		t.strictEqual( v, values[ i ], 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.validate.js
index 0c1b0506450b..13848f2456aa 100644
--- a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.validate.js
@@ -76,7 +76,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -154,7 +154,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -180,7 +180,7 @@ tape( 'the function returns an error if provided a `serialize` option which is n
 		err = validate( {}, {
 			'serialize': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -200,7 +200,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -213,7 +213,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -235,7 +235,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.factory.js
index 0d8d9955be30..a0732cabd3fa 100644
--- a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.factory.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -356,7 +356,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	arr = [ 1, 2, 3 ];
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( arr.length, arr, 1, 0 ) instanceof StridedArrayStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( arr.length, arr, 1, 0 ) instanceof StridedArrayStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
@@ -370,7 +370,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	arr = [ 1, 2, 3 ];
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( arr.length, arr, 1, 0 ) instanceof StridedArrayStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( arr.length, arr, 1, 0 ) instanceof StridedArrayStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.js b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.js
index 3cb29b9d7310..82e1bbc95762 100644
--- a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof stridedArrayStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof stridedArrayStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof stridedArrayStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof stridedArrayStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.main.js b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.main.js
index d6966a770c14..7f0435d922eb 100644
--- a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.main.js
@@ -473,7 +473,7 @@ tape( 'the function is a constructor which returns a readable stream', function
 	var s;
 
 	s = new StridedArrayStream( 3, [ 1, 2, 3 ], 1, 0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -482,13 +482,13 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = stridedArrayStream( 3, [ 1, 2, 3 ], 1, 0 );
-	t.equal( s instanceof StridedArrayStream, true, 'returns expected value' );
+	t.strictEqual( s instanceof StridedArrayStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the constructor returns a readable stream (no new)', function test( t ) {
 	var s = stridedArrayStream( 3, [ 1, 2, 3 ], 1, 0 );
-	t.equal( s instanceof Readable, true, 'returns expected value' );
+	t.strictEqual( s instanceof Readable, true, 'returns expected value' );
 	t.end();
 });
 
@@ -498,7 +498,7 @@ tape( 'the returned stream provides a method to destroy a stream (object)', func
 
 	s = stridedArrayStream( 8, [ 1, 2, 3, 4, 5, 6, 7, 8 ], 1, 0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -533,7 +533,7 @@ tape( 'the returned stream provides a method to destroy a stream (error object)'
 
 	s = stridedArrayStream( 8, [ 1, 2, 3, 4, 5, 6, 7, 8 ], 1, 0 );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream which streams elements of a strided arra
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 	}
 
@@ -614,9 +614,9 @@ tape( 'the constructor returns a stream which streams elements of a strided arra
 		t.pass( 'stream ended' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, expected.length, 'has expected length' );
+		t.strictEqual( result.length, expected.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( parseFloat( result[ i ] ), expected[ i ], 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( parseFloat( result[ i ] ), expected[ i ], 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -649,7 +649,7 @@ tape( 'the constructor returns a stream which streams elements of a strided arra
 
 	function inspect( v ) {
 		i += 1;
-		t.equal( v, expected[ i ], 'returns expected value. i: '+i+'.' );
+		t.strictEqual( v, expected[ i ], 'returns expected value. i: '+i+'.' );
 	}
 
 	function onEnd() {
@@ -686,7 +686,7 @@ tape( 'the constructor returns a stream which streams elements of a strided arra
 
 	function inspect( chunk ) {
 		count += 1;
-		t.equal( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
 		result += chunk.toString();
 		if ( count === 10 ) {
 			s.destroy();
@@ -699,9 +699,9 @@ tape( 'the constructor returns a stream which streams elements of a strided arra
 		t.pass( 'stream closed' );
 
 		result = result.split( '\n' );
-		t.equal( result.length >= 10, true, 'has expected length' );
+		t.strictEqual( result.length >= 10, true, 'has expected length' );
 		for ( i = 0; i < 10; i++ ) {
-			t.equal( typeof parseFloat( result[ i ] ), 'number', 'returns expected value. i: ' + i + '.' );
+			t.strictEqual( typeof parseFloat( result[ i ] ), 'number', 'returns expected value. i: ' + i + '.' );
 		}
 		t.end();
 	}
@@ -735,7 +735,7 @@ tape( 'the constructor returns a stream which streams elements of a strided arra
 
 	function inspect( v ) {
 		i += 1;
-		t.equal( typeof v, 'number', 'returns expected value. i: '+i+'.' );
+		t.strictEqual( typeof v, 'number', 'returns expected value. i: '+i+'.' );
 		if ( i === 10 ) {
 			return s.destroy();
 		}
@@ -833,10 +833,10 @@ tape( 'by default, the constructor returns a stream which streams newline-delimi
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, expected.length, 'has expected length' );
+		t.strictEqual( result.length, expected.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( v, expected[ i ], 'returns expected value' );
+			t.strictEqual( v, expected[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -873,10 +873,10 @@ tape( 'the constructor supports providing a custom separator for streamed values
 		var i;
 
 		result = result.split( opts.sep );
-		t.equal( result.length, expected.length, 'has expected length' );
+		t.strictEqual( result.length, expected.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseFloat( result[ i ] );
-			t.equal( v, expected[ i ], 'returns expected value' );
+			t.strictEqual( v, expected[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -932,7 +932,7 @@ tape( 'by default, the constructor returns a stream which serializes streamed va
 		var i;
 
 		result = result.split( '\n' );
-		t.equal( result.length, values.length, 'has expected length' );
+		t.strictEqual( result.length, values.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
 			v = parseJSON( result[ i ] );
 			t.deepEqual( v, values[ i ], 'returns expected value' );
@@ -984,9 +984,9 @@ tape( 'the constructor supports providing a custom serialization function (strin
 	function onEnd() {
 		var i;
 		result = result.split( '\n' );
-		t.equal( result.length, expected.length, 'has expected length' );
+		t.strictEqual( result.length, expected.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( result[ i ], expected[ i ], 'returns expected value' );
+			t.strictEqual( result[ i ], expected[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -1035,9 +1035,9 @@ tape( 'the constructor supports providing a custom serialization function (buffe
 	function onEnd() {
 		var i;
 		result = result.split( '\n' );
-		t.equal( result.length, expected.length, 'has expected length' );
+		t.strictEqual( result.length, expected.length, 'has expected length' );
 		for ( i = 0; i < result.length; i++ ) {
-			t.equal( result[ i ], expected[ i ], 'returns expected value' );
+			t.strictEqual( result[ i ], expected[ i ], 'returns expected value' );
 		}
 		t.end();
 	}
@@ -1068,7 +1068,7 @@ tape( 'in object mode, `null` values are reserved', function test( t ) {
 
 	function inspect( v, i ) {
 		count += 1;
-		t.equal( v, values[ i ], 'returns expected value' );
+		t.strictEqual( v, values[ i ], 'returns expected value' );
 	}
 
 	function onError( err ) {
@@ -1078,8 +1078,8 @@ tape( 'in object mode, `null` values are reserved', function test( t ) {
 
 	function onEnd() {
 		t.pass( 'stream ended' );
-		t.equal( FLG, false, 'stream does not emit an error' );
-		t.equal( count, 3, 'streamed expected number of values' );
+		t.strictEqual( FLG, false, 'stream does not emit an error' );
+		t.strictEqual( count, 3, 'streamed expected number of values' );
 		t.end();
 	}
 });
@@ -1120,11 +1120,11 @@ tape( 'by default, when not in object mode, a stream emits an `error` upon encou
 		var i;
 
 		t.pass( 'stream ended' );
-		t.equal( FLG, true, 'stream does emit an error' );
-		t.equal( count, 7, 'streamed expected number of values' );
+		t.strictEqual( FLG, true, 'stream does emit an error' );
+		t.strictEqual( count, 7, 'streamed expected number of values' );
 
 		result = result.split( '\n' );
-		t.equal( result.length, 7, 'has expected length' );
+		t.strictEqual( result.length, 7, 'has expected length' );
 
 		j = -1;
 		for ( i = 0; i < values.length; i++ ) {
@@ -1132,7 +1132,7 @@ tape( 'by default, when not in object mode, a stream emits an `error` upon encou
 				continue;
 			}
 			j += 1;
-			t.equal( parseFloat( result[ j ] ), values[ i ], 'returns expected value. i: '+i+'.' );
+			t.strictEqual( parseFloat( result[ j ] ), values[ i ], 'returns expected value. i: '+i+'.' );
 		}
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.object_mode.js
index b30934afeb38..1a04a0adaf77 100644
--- a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.object_mode.js
@@ -211,13 +211,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 3, [ 1, 2, 3 ], 1, 0 );
-	t.equal( s instanceof StridedArrayStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof StridedArrayStream, true, 'returns a stream instance' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 3, [ 1, 2, 3 ], 1, 0, {} );
-	t.equal( s instanceof StridedArrayStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof StridedArrayStream, true, 'returns a stream instance' );
 	t.end();
 });
 
@@ -240,7 +240,7 @@ tape( 'the function returns a stream which streams elements of an array-like obj
 	s.pipe( iStream );
 
 	function inspect( v, i ) {
-		t.equal( v, values[ i ], 'returns expected value' );
+		t.strictEqual( v, values[ i ], 'returns expected value' );
 	}
 
 	function onEnd() {
@@ -270,7 +270,7 @@ tape( 'the function does not support overriding the `objectMode` option', functi
 	s.pipe( iStream );
 
 	function inspect( v, i ) {
-		t.equal( v, values[ i ], 'returns expected value' );
+		t.strictEqual( v, values[ i ], 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.validate.js
index 0c1b0506450b..13848f2456aa 100644
--- a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.validate.js
@@ -76,7 +76,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -103,7 +103,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -154,7 +154,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -180,7 +180,7 @@ tape( 'the function returns an error if provided a `serialize` option which is n
 		err = validate( {}, {
 			'serialize': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -200,7 +200,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -213,7 +213,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -235,7 +235,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.factory.js
index 5c0568fef649..4ad70b8bf699 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.factory.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -112,7 +112,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( noop ) instanceof InspectSinkStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( noop ) instanceof InspectSinkStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.js b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.js
index 5a487fa893b2..476f6f08bcd0 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof inspectSinkStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof inspectSinkStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof inspectSinkStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof inspectSinkStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.main.js b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.main.js
index f47fec4fba07..4dd06ad04f92 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.main.js
@@ -109,7 +109,7 @@ tape( 'the constructor throws an error if provided an invalid option', function
 
 tape( 'the constructor returns a Writable stream', function test( t ) {
 	var s = new InspectSinkStream( noop );
-	t.equal( s instanceof Writable, true, 'returns a Writable stream' );
+	t.strictEqual( s instanceof Writable, true, 'returns a Writable stream' );
 	t.end();
 });
 
@@ -118,10 +118,10 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = stream( noop );
-	t.equal( s instanceof Writable, true, 'returns a Writable stream' );
+	t.strictEqual( s instanceof Writable, true, 'returns a Writable stream' );
 
 	s = stream( {}, noop );
-	t.equal( s instanceof Writable, true, 'returns a Writable stream' );
+	t.strictEqual( s instanceof Writable, true, 'returns a Writable stream' );
 
 	t.end();
 });
@@ -142,8 +142,8 @@ tape( 'the returned stream invokes a provided callback with streamed data', func
 	s.end();
 
 	function onData( chunk, idx ) {
-		t.equal( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
-		t.equal( idx, cnt, 'streams expected index' );
+		t.strictEqual( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( idx, cnt, 'streams expected index' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -171,8 +171,8 @@ tape( 'the returned stream invokes a provided callback with streamed data when i
 	s.end();
 
 	function onData( chunk, idx ) {
-		t.equal( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
-		t.equal( idx, cnt, 'streams expected index' );
+		t.strictEqual( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( idx, cnt, 'streams expected index' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -186,7 +186,7 @@ tape( 'the returned stream provides a method to destroy a stream', function test
 
 	s = new InspectSinkStream( noop );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
@@ -219,7 +219,7 @@ tape( 'the returned stream provides a method to destroy a stream (subsequent wri
 
 	s = new InspectSinkStream( noop );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
diff --git a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.object_mode.js
index 2dbaf096c43e..427f85065cc4 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.object_mode.js
@@ -119,7 +119,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode( noop );
-	t.equal( stream instanceof InspectSinkStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof InspectSinkStream, true, 'returns a stream instance' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.validate.js
index 9932e7142bac..5e46deb4baa0 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.validate.js
@@ -76,7 +76,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -101,7 +101,7 @@ tape( 'the function returns an error if provided a `decodeStrings` option which
 		err = validate( {}, {
 			'decodeStrings': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function returns an error if provided an `defaultEncoding` option whi
 		err = validate( {}, {
 			'defaultEncoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -154,7 +154,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -173,7 +173,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -191,7 +191,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/inspect/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/inspect/test/test.factory.js
index 8640f8a6ae49..a8a0e37ff4be 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect/test/test.factory.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -112,7 +112,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( noop ) instanceof InspectStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( noop ) instanceof InspectStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/inspect/test/test.js b/lib/node_modules/@stdlib/streams/node/inspect/test/test.js
index e233eb7de56f..c07499e3f200 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof inspectStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof inspectStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof inspectStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof inspectStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/inspect/test/test.main.js b/lib/node_modules/@stdlib/streams/node/inspect/test/test.main.js
index 0c7d618a559e..51ed03709097 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect/test/test.main.js
@@ -109,7 +109,7 @@ tape( 'the constructor throws an error if provided an invalid option', function
 
 tape( 'the constructor returns a Transform stream', function test( t ) {
 	var s = new InspectStream( noop );
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 	t.end();
 });
 
@@ -118,10 +118,10 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = stream( noop );
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	s = stream( {}, noop );
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	t.end();
 });
@@ -142,8 +142,8 @@ tape( 'the returned stream forwards streamed data to a provided callback', funct
 	s.end();
 
 	function onData( chunk, idx ) {
-		t.equal( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
-		t.equal( idx, cnt, 'streams expected index' );
+		t.strictEqual( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( idx, cnt, 'streams expected index' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -171,8 +171,8 @@ tape( 'the returned stream forwards streamed data to a provided callback when in
 	s.end();
 
 	function onData( chunk, idx ) {
-		t.equal( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
-		t.equal( idx, cnt, 'streams expected index' );
+		t.strictEqual( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( idx, cnt, 'streams expected index' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -186,7 +186,7 @@ tape( 'the returned stream provides a method to destroy a stream', function test
 
 	s = new InspectStream( noop );
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
diff --git a/lib/node_modules/@stdlib/streams/node/inspect/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/inspect/test/test.object_mode.js
index 3708d5a039c8..e6085e038868 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect/test/test.object_mode.js
@@ -119,7 +119,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode( noop );
-	t.equal( stream instanceof InspectStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof InspectStream, true, 'returns a stream instance' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/inspect/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/inspect/test/test.validate.js
index 81b9189eb084..9d30a1ec614f 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect/test/test.validate.js
@@ -75,7 +75,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns an error if provided a `readableObjectMode` option w
 		err = validate( {}, {
 			'readableObjectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns an error if provided an `allowHalfOpen` option which
 		err = validate( {}, {
 			'allowHalfOpen': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -150,7 +150,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -169,7 +169,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -187,7 +187,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/join/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/join/test/test.factory.js
index 60ae2b86bf92..27ad416c780a 100644
--- a/lib/node_modules/@stdlib/streams/node/join/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/join/test/test.factory.js
@@ -64,13 +64,13 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -81,7 +81,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof JoinStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof JoinStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/join/test/test.js b/lib/node_modules/@stdlib/streams/node/join/test/test.js
index 20041893b56e..881dd9881c12 100644
--- a/lib/node_modules/@stdlib/streams/node/join/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/join/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof joinStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof joinStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof joinStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof joinStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/join/test/test.main.js b/lib/node_modules/@stdlib/streams/node/join/test/test.main.js
index 3427e6c7d80c..c802abb5bb0f 100644
--- a/lib/node_modules/@stdlib/streams/node/join/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/join/test/test.main.js
@@ -81,7 +81,7 @@ tape( 'the constructor throws an error if provided an invalid option', function
 
 tape( 'the constructor returns a Transform stream', function test( t ) {
 	var s = new JoinStream();
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 	t.end();
 });
 
@@ -90,10 +90,10 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = stream();
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	s = stream({});
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	t.end();
 });
@@ -117,7 +117,7 @@ tape( 'the returned stream joins streamed data', function test( t ) {
 	s.end();
 
 	function onData( chunk ) {
-		t.equal( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -147,7 +147,7 @@ tape( 'the returned stream joins streamed data when in object mode', function te
 	s.end();
 
 	function onData( chunk ) {
-		t.equal( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -192,7 +192,7 @@ tape( 'the returned stream joins streamed data not encoded as UTF-8', function t
 		chunk = new Buffer( chunk, 'base64' );
 		chunk = chunk.toString();
 
-		t.equal( chunk, expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( chunk, expected[ cnt ], 'streams expected chunk' );
 
 		cnt += 1;
 		if ( cnt === expected.length ) {
@@ -207,7 +207,7 @@ tape( 'the returned stream provides a method to destroy a stream', function test
 
 	s = new JoinStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
diff --git a/lib/node_modules/@stdlib/streams/node/join/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/join/test/test.object_mode.js
index 4c656aebdbfd..960fb7901daf 100644
--- a/lib/node_modules/@stdlib/streams/node/join/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/join/test/test.object_mode.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode();
-	t.equal( stream instanceof JoinStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof JoinStream, true, 'returns a stream instance' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/join/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/join/test/test.validate.js
index 4e7d879679cb..b6a389170d0e 100644
--- a/lib/node_modules/@stdlib/streams/node/join/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/join/test/test.validate.js
@@ -74,7 +74,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns an error if provided a `readableObjectMode` option w
 		err = validate( {}, {
 			'readableObjectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -174,7 +174,7 @@ tape( 'the function returns an error if provided an `allowHalfOpen` option which
 		err = validate( {}, {
 			'allowHalfOpen': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -220,7 +220,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -238,7 +238,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/split/test/test.decode.js b/lib/node_modules/@stdlib/streams/node/split/test/test.decode.js
index d8a1418c9f83..69427a30945a 100644
--- a/lib/node_modules/@stdlib/streams/node/split/test/test.decode.js
+++ b/lib/node_modules/@stdlib/streams/node/split/test/test.decode.js
@@ -37,10 +37,10 @@ tape( 'the function converts a UTF-8 string to a specified encoding', function t
 	var str;
 
 	str = decode( 'beep', 'base64' );
-	t.equal( str, string2buffer( 'beep' ).toString( 'base64' ), 'returns base64 encoded string' );
+	t.strictEqual( str, string2buffer( 'beep' ).toString( 'base64' ), 'returns base64 encoded string' );
 
 	str = decode( 'beep', 'ascii' );
-	t.equal( str, string2buffer( 'beep' ).toString( 'ascii' ), 'returns ascii encoded string' );
+	t.strictEqual( str, string2buffer( 'beep' ).toString( 'ascii' ), 'returns ascii encoded string' );
 
 	t.end();
 });
@@ -49,10 +49,10 @@ tape( 'the function returns the input string if the specified encoding is either
 	var str;
 
 	str = decode( 'beep', 'utf8' );
-	t.equal( str, 'beep', 'returns utf8 encoding string' );
+	t.strictEqual( str, 'beep', 'returns utf8 encoding string' );
 
 	str = decode( 'beep', 'buffer' );
-	t.equal( str, 'beep', 'returns string having buffer encoding' );
+	t.strictEqual( str, 'beep', 'returns string having buffer encoding' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/split/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/split/test/test.factory.js
index e581112cd510..a175162b357b 100644
--- a/lib/node_modules/@stdlib/streams/node/split/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/split/test/test.factory.js
@@ -64,13 +64,13 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -81,7 +81,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream() instanceof SplitStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof SplitStream, true, 'returns a stream instance' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/split/test/test.js b/lib/node_modules/@stdlib/streams/node/split/test/test.js
index 7f66291858fa..26231dd7fc1e 100644
--- a/lib/node_modules/@stdlib/streams/node/split/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/split/test/test.js
@@ -33,11 +33,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof splitStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof splitStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof splitStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof splitStream.factory, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/split/test/test.main.js b/lib/node_modules/@stdlib/streams/node/split/test/test.main.js
index 69d262560037..a36f488abe64 100644
--- a/lib/node_modules/@stdlib/streams/node/split/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/split/test/test.main.js
@@ -48,7 +48,7 @@ tape( 'the constructor throws an error if provided an invalid option', function
 
 tape( 'the constructor returns a Transform stream', function test( t ) {
 	var s = new SplitStream();
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 	t.end();
 });
 
@@ -57,10 +57,10 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = stream();
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	s = stream({});
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'the returned stream provides a method to destroy a stream', function test
 
 	s = new SplitStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
diff --git a/lib/node_modules/@stdlib/streams/node/split/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/split/test/test.object_mode.js
index adc64d102529..2564cbad7867 100644
--- a/lib/node_modules/@stdlib/streams/node/split/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/split/test/test.object_mode.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode();
-	t.equal( stream instanceof SplitStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof SplitStream, true, 'returns a stream instance' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/split/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/split/test/test.validate.js
index 2781574bdbcd..ef2cea33da58 100644
--- a/lib/node_modules/@stdlib/streams/node/split/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/split/test/test.validate.js
@@ -74,7 +74,7 @@ tape( 'the function returns an error if provided a `sep` option which is not a s
 		err = validate( {}, {
 			'sep': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns an error if provided a `writableObjectMode` option w
 		err = validate( {}, {
 			'writableObjectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -174,7 +174,7 @@ tape( 'the function returns an error if provided an `allowHalfOpen` option which
 		err = validate( {}, {
 			'allowHalfOpen': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -199,7 +199,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -220,7 +220,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -238,7 +238,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/stderr/test/test.js b/lib/node_modules/@stdlib/streams/node/stderr/test/test.js
index cfc9929711ec..e2550539aa51 100644
--- a/lib/node_modules/@stdlib/streams/node/stderr/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/stderr/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is an object', function test( t ) {
 });
 
 tape( 'the export is an alias for `process.stderr`', function test( t ) {
-	t.equal( stderr, proc.stderr, 'is an alias' );
+	t.strictEqual( stderr, proc.stderr, 'is an alias' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/stdin/test/test.js b/lib/node_modules/@stdlib/streams/node/stdin/test/test.js
index 42b947984dce..82097e2eb97a 100644
--- a/lib/node_modules/@stdlib/streams/node/stdin/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/stdin/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is an object', function test( t ) {
 });
 
 tape( 'the export is an alias for `process.stdin`', function test( t ) {
-	t.equal( stdin, proc.stdin, 'is an alias' );
+	t.strictEqual( stdin, proc.stdin, 'is an alias' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/stdout/test/test.js b/lib/node_modules/@stdlib/streams/node/stdout/test/test.js
index 0f13bf2ed3ed..d3dba81d0993 100644
--- a/lib/node_modules/@stdlib/streams/node/stdout/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/stdout/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is an object', function test( t ) {
 });
 
 tape( 'the export is an alias for `process.stdout`', function test( t ) {
-	t.equal( stdout, proc.stdout, 'is an alias' );
+	t.strictEqual( stdout, proc.stdout, 'is an alias' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/test/test.js b/lib/node_modules/@stdlib/streams/node/test/test.js
index b99d23e44548..b126c0c8b3a0 100644
--- a/lib/node_modules/@stdlib/streams/node/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains streams', function test( t ) {
 	var keys = objectKeys( streams );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/transform/test/test.ctor.js b/lib/node_modules/@stdlib/streams/node/transform/test/test.ctor.js
index 72d597cc2be2..da5ea2699da9 100644
--- a/lib/node_modules/@stdlib/streams/node/transform/test/test.ctor.js
+++ b/lib/node_modules/@stdlib/streams/node/transform/test/test.ctor.js
@@ -51,7 +51,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 tape( 'the function returns a transform stream constructor', function test( t ) {
 	var Stream = ctor();
 	var s = new Stream();
-	t.equal( s instanceof Transform, true, 'returns a transform stream constructor' );
+	t.strictEqual( s instanceof Transform, true, 'returns a transform stream constructor' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'the returned constructor does not require the `new` operator', function t
 	var s;
 
 	s = stream();
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	s = stream({});
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	t.end();
 });
@@ -111,7 +111,7 @@ tape( 'the returned constructor creates a stream which applies a transform funct
 	}
 
 	function onData( chunk ) {
-		t.equal( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -148,7 +148,7 @@ tape( 'the returned constructor creates a stream which applies a transform funct
 	}
 
 	function onData( chunk ) {
-		t.equal( chunk, expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( chunk, expected[ cnt ], 'streams expected chunk' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -215,7 +215,7 @@ tape( 'if not provided a transform function, the returned constructor creates a
 	s.end();
 
 	function onData( chunk ) {
-		t.equal( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -281,7 +281,7 @@ tape( 'options provided to the returned constructor override options provided wh
 	}
 
 	function onData( chunk ) {
-		t.equal( chunk.value, expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( chunk.value, expected[ cnt ], 'streams expected chunk' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -299,7 +299,7 @@ tape( 'the returned constructor creates a stream which provides a method to dest
 	TransformStream = ctor();
 	s = new TransformStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
diff --git a/lib/node_modules/@stdlib/streams/node/transform/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/transform/test/test.factory.js
index 2fb12710d0bb..0dcb954ef023 100644
--- a/lib/node_modules/@stdlib/streams/node/transform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/transform/test/test.factory.js
@@ -22,7 +22,7 @@
 
 var tape = require( 'tape' );
 var noop = require( '@stdlib/utils/noop' );
-var TransformStream = require( './../lib/main.js' );
+var TransformStream = require( './../lib/main.js' ); // eslint-disable-line stdlib/no-redeclare
 var factory = require( './../lib/factory.js' );
 
 
@@ -64,13 +64,13 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.equal( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns a function' );
 	t.end();
 });
 
@@ -140,11 +140,11 @@ tape( 'the function returns a factory function which creates stream instances',
 
 	// Provide just a transform function...
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( noop ) instanceof TransformStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( noop ) instanceof TransformStream, true, 'returns a stream instance' );
 	}
 	// Provide both transform and flush functions...
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( noop, noop ) instanceof TransformStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( noop, noop ) instanceof TransformStream, true, 'returns a stream instance' );
 	}
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/streams/node/transform/test/test.js b/lib/node_modules/@stdlib/streams/node/transform/test/test.js
index 7c33393768fb..f6e9edd59453 100644
--- a/lib/node_modules/@stdlib/streams/node/transform/test/test.js
+++ b/lib/node_modules/@stdlib/streams/node/transform/test/test.js
@@ -33,16 +33,16 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to main export is a method to create a stream in object mode', function test( t ) {
-	t.equal( typeof transformStream.objectMode, 'function', 'has method' );
+	t.strictEqual( typeof transformStream.objectMode, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream factory', function test( t ) {
-	t.equal( typeof transformStream.factory, 'function', 'has method' );
+	t.strictEqual( typeof transformStream.factory, 'function', 'has method' );
 	t.end();
 });
 
 tape( 'attached to main export is a method to create a stream constructor', function test( t ) {
-	t.equal( typeof transformStream.ctor, 'function', 'has method' );
+	t.strictEqual( typeof transformStream.ctor, 'function', 'has method' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/transform/test/test.main.js b/lib/node_modules/@stdlib/streams/node/transform/test/test.main.js
index 951e7c5b1451..8d64a232fbee 100644
--- a/lib/node_modules/@stdlib/streams/node/transform/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/transform/test/test.main.js
@@ -24,7 +24,7 @@ var tape = require( 'tape' );
 var Transform = require( 'readable-stream' ).Transform;
 var noop = require( '@stdlib/utils/noop' );
 var inspectStream = require( '@stdlib/streams/node/inspect-sink' );
-var TransformStream = require( './../lib/main.js' );
+var TransformStream = require( './../lib/main.js' ); // eslint-disable-line stdlib/no-redeclare
 
 
 // TESTS //
@@ -50,7 +50,7 @@ tape( 'the constructor throws an error if provided an invalid option', function
 
 tape( 'the constructor returns a Transform stream', function test( t ) {
 	var s = new TransformStream();
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 	t.end();
 });
 
@@ -59,10 +59,10 @@ tape( 'the constructor does not require the `new` operator', function test( t )
 	var s;
 
 	s = stream();
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	s = stream({});
-	t.equal( s instanceof Transform, true, 'returns a Transform stream' );
+	t.strictEqual( s instanceof Transform, true, 'returns a Transform stream' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'the returned stream applies a transform function to streamed data', funct
 	}
 
 	function onData( chunk ) {
-		t.equal( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -126,7 +126,7 @@ tape( 'the returned stream applies a transform function to streamed data when in
 	}
 
 	function onData( chunk ) {
-		t.equal( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -153,7 +153,7 @@ tape( 'if not provided a transform function, the returned stream allows streamed
 	s.end();
 
 	function onData( chunk ) {
-		t.equal( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
+		t.strictEqual( chunk.toString(), expected[ cnt ], 'streams expected chunk' );
 		cnt += 1;
 		if ( cnt === expected.length ) {
 			t.end();
@@ -188,7 +188,7 @@ tape( 'the returned stream provides a method to destroy a stream', function test
 
 	s = new TransformStream();
 
-	t.equal( typeof s.destroy, 'function', 'has destroy method' );
+	t.strictEqual( typeof s.destroy, 'function', 'has destroy method' );
 
 	s.on( 'error', onError );
 	s.on( 'close', onClose );
diff --git a/lib/node_modules/@stdlib/streams/node/transform/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/transform/test/test.object_mode.js
index bb128262fcfc..2955bddfbaa0 100644
--- a/lib/node_modules/@stdlib/streams/node/transform/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/transform/test/test.object_mode.js
@@ -23,7 +23,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
-var TransformStream = require( './../lib/main.js' );
+var TransformStream = require( './../lib/main.js' ); // eslint-disable-line stdlib/no-redeclare
 var objectMode = require( './../lib/object_mode.js' );
 
 
@@ -63,7 +63,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode();
-	t.equal( stream instanceof TransformStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof TransformStream, true, 'returns a stream instance' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/transform/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/transform/test/test.validate.js
index f9668907afce..1dbffa97469c 100644
--- a/lib/node_modules/@stdlib/streams/node/transform/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/transform/test/test.validate.js
@@ -76,7 +76,7 @@ tape( 'the function returns an error if provided a `transform` option which is n
 		err = validate( {}, {
 			'transform': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -101,7 +101,7 @@ tape( 'the function returns an error if provided a `flush` option which is not a
 		err = validate( {}, {
 			'flush': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -126,7 +126,7 @@ tape( 'the function returns an error if provided an `objectMode` option which is
 		err = validate( {}, {
 			'objectMode': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -151,7 +151,7 @@ tape( 'the function returns an error if provided an `encoding` option which is n
 		err = validate( {}, {
 			'encoding': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -176,7 +176,7 @@ tape( 'the function returns an error if provided an `allowHalfOpen` option which
 		err = validate( {}, {
 			'allowHalfOpen': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -201,7 +201,7 @@ tape( 'the function returns an error if provided a `highWaterMark` option which
 		err = validate( {}, {
 			'highWaterMark': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -226,7 +226,7 @@ tape( 'the function returns an error if provided a `decodeStrings` option which
 		err = validate( {}, {
 			'decodeStrings': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a type error when provided '+values[i] );
 	}
 	t.end();
 });
@@ -248,7 +248,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -266,7 +266,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/test/test.js b/lib/node_modules/@stdlib/streams/test/test.js
index 3b68da488318..a8ea5cd34800 100644
--- a/lib/node_modules/@stdlib/streams/test/test.js
+++ b/lib/node_modules/@stdlib/streams/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains stream namespaces', function test( t ) {
 	var keys = objectKeys( streams );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });

From f344466c6dcfb8f52d7f3148acaadd52772938da Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Thu, 14 Aug 2025 14:04:38 -0500
Subject: [PATCH 13/32] test: use .strictEqual() instead of .equal() and fix
 lint errors

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 lib/node_modules/@stdlib/bigint/test/test.js  |  2 +-
 .../@stdlib/blas/base/assert/test/test.js     |  2 +-
 .../@stdlib/blas/base/dcabs1/test/test.js     |  2 +-
 .../blas/base/dcabs1/test/test.native.js      |  2 +-
 .../@stdlib/blas/base/scabs1/test/test.js     |  2 +-
 .../blas/base/scabs1/test/test.native.js      |  2 +-
 .../@stdlib/blas/base/test/test.js            |  2 +-
 .../@stdlib/blas/base/wasm/test/test.js       |  2 +-
 .../blas/ext/base/ndarray/test/test.js        |  2 +-
 .../@stdlib/blas/ext/base/test/test.js        |  2 +-
 .../@stdlib/blas/ext/base/wasm/test/test.js   |  2 +-
 .../@stdlib/blas/ext/test/test.js             |  2 +-
 lib/node_modules/@stdlib/blas/test/test.js    |  2 +-
 .../@stdlib/blas/tools/test/test.js           |  2 +-
 lib/node_modules/@stdlib/boolean/test/test.js |  2 +-
 lib/node_modules/@stdlib/buffer/test/test.js  |  2 +-
 lib/node_modules/@stdlib/cli/test/test.js     |  2 +-
 .../@stdlib/dstructs/test/test.js             |  2 +-
 .../@stdlib/error/reviver/test/test.ctors.js  |  4 +-
 .../@stdlib/error/reviver/test/test.js        | 16 ++--
 lib/node_modules/@stdlib/error/test/test.js   |  2 +-
 .../@stdlib/error/tools/database/test/test.js |  4 +-
 .../tools/fmtprodmsg-factory/test/test.js     |  4 +-
 .../fmtprodmsg-factory/test/test.validate.js  |  8 +-
 .../error/tools/fmtprodmsg/test/test.js       |  2 +-
 .../@stdlib/error/tools/test/test.js          |  2 +-
 .../@stdlib/function/test/test.js             |  2 +-
 .../@stdlib/lapack/base/test/test.js          |  2 +-
 lib/node_modules/@stdlib/lapack/test/test.js  |  2 +-
 .../@stdlib/ndarray/base/assert/test/test.js  |  2 +-
 .../@stdlib/ndarray/base/test/test.js         |  2 +-
 lib/node_modules/@stdlib/ndarray/test/test.js |  2 +-
 .../@stdlib/ndarray/vector/test/test.js       |  2 +-
 .../disposable-http-server/test/test.main.js  | 26 ++---
 .../test/test.validate.js                     | 12 +--
 .../@stdlib/net/http-server/test/test.js      | 10 +-
 .../net/http-server/test/test.validate.js     | 14 +--
 .../net/simple-http-server/test/test.main.js  |  4 +-
 .../simple-http-server/test/test.validate.js  | 10 +-
 lib/node_modules/@stdlib/net/test/test.js     |  2 +-
 .../@stdlib/nlp/expand-acronyms/test/test.js  |  2 +-
 .../nlp/expand-contractions/test/test.js      |  2 +-
 .../@stdlib/nlp/lda/test/test.validate.js     | 10 +-
 .../@stdlib/nlp/ordinalize/test/test.js       | 42 ++++----
 .../nlp/ordinalize/test/test.validate.js      | 12 +--
 .../@stdlib/nlp/porter-stemmer/test/test.js   |  4 +-
 .../@stdlib/nlp/sentencize/test/test.js       |  4 +-
 lib/node_modules/@stdlib/nlp/test/test.js     |  2 +-
 .../@stdlib/nlp/tokenize/test/test.js         |  4 +-
 .../@stdlib/object/assign/test/test.js        |  4 +-
 .../@stdlib/object/some-in-by/test/test.js    |  6 +-
 lib/node_modules/@stdlib/object/test/test.js  |  2 +-
 lib/node_modules/@stdlib/os/arch/test/test.js |  2 +-
 .../@stdlib/os/byte-order/test/test.js        |  8 +-
 .../@stdlib/os/float-word-order/test/test.js  |  6 +-
 .../@stdlib/os/num-cpus/test/test.browser.js  |  4 +-
 .../@stdlib/os/num-cpus/test/test.js          |  2 +-
 .../@stdlib/os/platform/test/test.js          |  2 +-
 lib/node_modules/@stdlib/os/test/test.js      |  2 +-
 .../@stdlib/os/tmpdir/test/test.js            |  2 +-
 .../@stdlib/process/chdir/test/test.js        |  8 +-
 .../process/chdir/test/test.polyfill.js       |  2 +-
 .../@stdlib/process/cwd/test/test.js          |  2 +-
 .../@stdlib/process/cwd/test/test.polyfill.js |  2 +-
 .../process/exec-path/test/test.browser.js    |  2 +-
 .../@stdlib/process/exec-path/test/test.js    |  6 +-
 .../process/exec-path/test/test.main.js       |  2 +-
 .../process/node-version/test/test.browser.js |  2 +-
 .../@stdlib/process/node-version/test/test.js |  6 +-
 .../process/node-version/test/test.version.js |  2 +-
 .../@stdlib/process/read-stdin/test/test.js   | 40 ++++----
 lib/node_modules/@stdlib/process/test/test.js |  2 +-
 .../process/umask/test/test.browser.js        | 96 +++++++++----------
 .../@stdlib/process/umask/test/test.js        | 96 +++++++++----------
 .../regexp/basename-posix/test/test.js        |  2 +-
 .../regexp/basename-windows/test/test.js      |  2 +-
 .../regexp/decimal-number/test/test.js        |  4 +-
 .../@stdlib/regexp/dirname-posix/test/test.js |  2 +-
 .../regexp/dirname-posix/test/test.main.js    |  2 +-
 .../regexp/dirname-posix/test/test.regexp.js  |  4 +-
 .../regexp/dirname-windows/test/test.js       |  2 +-
 .../regexp/dirname-windows/test/test.main.js  |  2 +-
 .../dirname-windows/test/test.regexp.js       |  4 +-
 .../@stdlib/regexp/dirname/test/test.js       |  8 +-
 .../regexp/duration-string/test/test.js       |  2 +-
 .../regexp/duration-string/test/test.main.js  |  6 +-
 .../duration-string/test/test.regexp.js       |  8 +-
 .../@stdlib/regexp/eol/test/test.js           |  4 +-
 .../@stdlib/regexp/eol/test/test.regexp.js    |  6 +-
 .../regexp/extended-length-path/test/test.js  |  2 +-
 .../@stdlib/regexp/extname-posix/test/test.js |  2 +-
 .../regexp/extname-posix/test/test.main.js    |  4 +-
 .../regexp/extname-posix/test/test.regexp.js  |  6 +-
 .../regexp/extname-windows/test/test.js       |  2 +-
 .../regexp/extname-windows/test/test.main.js  |  4 +-
 .../extname-windows/test/test.regexp.js       |  6 +-
 .../@stdlib/regexp/extname/test/test.js       |  8 +-
 .../regexp/filename-posix/test/test.js        |  2 +-
 .../regexp/filename-windows/test/test.js      |  2 +-
 .../@stdlib/regexp/function-name/test/test.js |  2 +-
 .../regexp/function-name/test/test.main.js    |  4 +-
 .../regexp/function-name/test/test.regexp.js  |  6 +-
 .../regexp/native-function/test/test.js       |  2 +-
 .../@stdlib/regexp/regexp/test/test.js        |  2 +-
 .../@stdlib/regexp/regexp/test/test.main.js   |  4 +-
 .../@stdlib/regexp/regexp/test/test.regexp.js |  6 +-
 .../@stdlib/regexp/reviver/test/test.js       |  4 +-
 .../@stdlib/regexp/semver/test/test.js        |  2 +-
 .../@stdlib/regexp/semver/test/test.main.js   |  4 +-
 .../@stdlib/regexp/semver/test/test.regexp.js |  6 +-
 lib/node_modules/@stdlib/regexp/test/test.js  |  2 +-
 .../@stdlib/regexp/unc-path/test/test.js      |  2 +-
 .../@stdlib/regexp/unc-path/test/test.main.js | 20 ++--
 .../regexp/unc-path/test/test.regexp.js       | 22 ++---
 .../regexp/utf16-surrogate-pair/test/test.js  |  2 +-
 .../utf16-unpaired-surrogate/test/test.js     |  2 +-
 .../@stdlib/regexp/whitespace/test/test.js    |  4 +-
 .../@stdlib/simulate/test/test.js             |  2 +-
 .../@stdlib/slice/base/test/test.js           |  2 +-
 lib/node_modules/@stdlib/slice/test/test.js   |  2 +-
 .../@stdlib/strided/base/test/test.js         |  2 +-
 lib/node_modules/@stdlib/strided/test/test.js |  2 +-
 lib/node_modules/@stdlib/symbol/test/test.js  |  2 +-
 .../@stdlib/time/base/test/test.js            |  2 +-
 .../@stdlib/time/duration2ms/test/test.js     |  2 +-
 .../@stdlib/time/ms2duration/test/test.js     | 80 ++++++++--------
 lib/node_modules/@stdlib/time/test/test.js    |  2 +-
 .../@stdlib/wasm/base/test/test.js            |  2 +-
 lib/node_modules/@stdlib/wasm/test/test.js    |  2 +-
 129 files changed, 427 insertions(+), 427 deletions(-)

diff --git a/lib/node_modules/@stdlib/bigint/test/test.js b/lib/node_modules/@stdlib/bigint/test/test.js
index 4703875b1edd..e682e93dba4d 100644
--- a/lib/node_modules/@stdlib/bigint/test/test.js
+++ b/lib/node_modules/@stdlib/bigint/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/assert/test/test.js b/lib/node_modules/@stdlib/blas/base/assert/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/blas/base/assert/test/test.js
+++ b/lib/node_modules/@stdlib/blas/base/assert/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/dcabs1/test/test.js b/lib/node_modules/@stdlib/blas/base/dcabs1/test/test.js
index ee3eac83fb0c..acf9281728a3 100644
--- a/lib/node_modules/@stdlib/blas/base/dcabs1/test/test.js
+++ b/lib/node_modules/@stdlib/blas/base/dcabs1/test/test.js
@@ -48,7 +48,7 @@ tape( 'the function computes the sum of the absolute values of the real and imag
 
 	for ( i = 0; i < re.length; i++ ) {
 		y = dcabs1( new Complex128( re[ i ], im[ i ] ) );
-		t.equal( y, expected[ i ], 'returns expected value. re: '+re[ i ]+'. im: '+im[ i ]+'. expected: '+expected[ i ]+'.' );
+		t.strictEqual( y, expected[ i ], 'returns expected value. re: '+re[ i ]+'. im: '+im[ i ]+'. expected: '+expected[ i ]+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/dcabs1/test/test.native.js b/lib/node_modules/@stdlib/blas/base/dcabs1/test/test.native.js
index 8587708bbf84..683b7ade69b4 100644
--- a/lib/node_modules/@stdlib/blas/base/dcabs1/test/test.native.js
+++ b/lib/node_modules/@stdlib/blas/base/dcabs1/test/test.native.js
@@ -57,7 +57,7 @@ tape( 'the function computes the sum of the absolute values of the real and imag
 
 	for ( i = 0; i < re.length; i++ ) {
 		y = dcabs1( new Complex128( re[ i ], im[ i ] ) );
-		t.equal( y, expected[ i ], 'returns expected value. re: '+re[ i ]+'. im: '+im[ i ]+'. expected: '+expected[ i ]+'.' );
+		t.strictEqual( y, expected[ i ], 'returns expected value. re: '+re[ i ]+'. im: '+im[ i ]+'. expected: '+expected[ i ]+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/scabs1/test/test.js b/lib/node_modules/@stdlib/blas/base/scabs1/test/test.js
index d85f6f99c63f..5643a118a000 100644
--- a/lib/node_modules/@stdlib/blas/base/scabs1/test/test.js
+++ b/lib/node_modules/@stdlib/blas/base/scabs1/test/test.js
@@ -48,7 +48,7 @@ tape( 'the function computes the sum of the absolute values of the real and imag
 
 	for ( i = 0; i < re.length; i++ ) {
 		y = scabs1( new Complex64( re[ i ], im[ i ] ) );
-		t.equal( y, expected[ i ], 'returns expected value. re: '+re[i]+'. im: '+im[i]+'. expected: '+expected[i]+'.' );
+		t.strictEqual( y, expected[ i ], 'returns expected value. re: '+re[i]+'. im: '+im[i]+'. expected: '+expected[i]+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/scabs1/test/test.native.js b/lib/node_modules/@stdlib/blas/base/scabs1/test/test.native.js
index 34a186c68740..c182700e6c79 100644
--- a/lib/node_modules/@stdlib/blas/base/scabs1/test/test.native.js
+++ b/lib/node_modules/@stdlib/blas/base/scabs1/test/test.native.js
@@ -57,7 +57,7 @@ tape( 'the function computes the sum of the absolute values of the real and imag
 
 	for ( i = 0; i < re.length; i++ ) {
 		y = scabs1( new Complex64( re[ i ], im[ i ] ) );
-		t.equal( y, expected[ i ], 'returns expected value. re: '+re[i]+'. im: '+im[i]+'. expected: '+expected[i]+'.' );
+		t.strictEqual( y, expected[ i ], 'returns expected value. re: '+re[i]+'. im: '+im[i]+'. expected: '+expected[i]+'.' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/test/test.js b/lib/node_modules/@stdlib/blas/base/test/test.js
index 6dafbe5a642e..f3076a184cb0 100644
--- a/lib/node_modules/@stdlib/blas/base/test/test.js
+++ b/lib/node_modules/@stdlib/blas/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains BLAS routines', function test( t ) {
 	var keys = objectKeys( blas );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/wasm/test/test.js b/lib/node_modules/@stdlib/blas/base/wasm/test/test.js
index cad2b376067c..5beac8e7ed4a 100644
--- a/lib/node_modules/@stdlib/blas/base/wasm/test/test.js
+++ b/lib/node_modules/@stdlib/blas/base/wasm/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains BLAS routines', function test( t ) {
 	var keys = objectKeys( blas );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/ndarray/test/test.js
index d1e6eeb4039e..30bee535777f 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/test/test.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'returns expected value' );
+	t.strictEqual( keys.length > 0, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/ext/base/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/test/test.js
index 630b5b5a6ff7..76eceb93c544 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/test/test.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/test/test.js
index 32b98cc80a9a..4ee3c72f6fae 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/wasm/test/test.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains extended BLAS routines', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/ext/test/test.js b/lib/node_modules/@stdlib/blas/ext/test/test.js
index 630b5b5a6ff7..76eceb93c544 100644
--- a/lib/node_modules/@stdlib/blas/ext/test/test.js
+++ b/lib/node_modules/@stdlib/blas/ext/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/test/test.js b/lib/node_modules/@stdlib/blas/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/blas/test/test.js
+++ b/lib/node_modules/@stdlib/blas/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/tools/test/test.js b/lib/node_modules/@stdlib/blas/tools/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/blas/tools/test/test.js
+++ b/lib/node_modules/@stdlib/blas/tools/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/boolean/test/test.js b/lib/node_modules/@stdlib/boolean/test/test.js
index 9931b3a8638f..da72de67868b 100644
--- a/lib/node_modules/@stdlib/boolean/test/test.js
+++ b/lib/node_modules/@stdlib/boolean/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/buffer/test/test.js b/lib/node_modules/@stdlib/buffer/test/test.js
index 4703875b1edd..e682e93dba4d 100644
--- a/lib/node_modules/@stdlib/buffer/test/test.js
+++ b/lib/node_modules/@stdlib/buffer/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/cli/test/test.js b/lib/node_modules/@stdlib/cli/test/test.js
index 4703875b1edd..e682e93dba4d 100644
--- a/lib/node_modules/@stdlib/cli/test/test.js
+++ b/lib/node_modules/@stdlib/cli/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/dstructs/test/test.js b/lib/node_modules/@stdlib/dstructs/test/test.js
index 4888b60cd38c..85de573de8c2 100644
--- a/lib/node_modules/@stdlib/dstructs/test/test.js
+++ b/lib/node_modules/@stdlib/dstructs/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/error/reviver/test/test.ctors.js b/lib/node_modules/@stdlib/error/reviver/test/test.ctors.js
index fca21a4c7fa1..06052b6db792 100644
--- a/lib/node_modules/@stdlib/error/reviver/test/test.ctors.js
+++ b/lib/node_modules/@stdlib/error/reviver/test/test.ctors.js
@@ -34,13 +34,13 @@ tape( 'main export is a function hash', function test( t ) {
 	var i;
 
 	t.ok( true, __filename );
-	t.equal( isPlainObject( ctors ), true, 'main export is an object' );
+	t.strictEqual( isPlainObject( ctors ), true, 'main export is an object' );
 
 	keys = objectKeys( ctors );
 	t.ok( keys.length > 0, 'has keys' );
 
 	for ( i = 0; i < keys.length; i++ ) {
-		t.equal( isFunction( ctors[ keys[i] ] ), true, keys[i] + ' value is a function' );
+		t.strictEqual( isFunction( ctors[ keys[i] ] ), true, keys[i] + ' value is a function' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/error/reviver/test/test.js b/lib/node_modules/@stdlib/error/reviver/test/test.js
index 92323ac324a6..3620cc2187be 100644
--- a/lib/node_modules/@stdlib/error/reviver/test/test.js
+++ b/lib/node_modules/@stdlib/error/reviver/test/test.js
@@ -58,7 +58,7 @@ tape( 'values which are not recognized as serialized error objects are unaffecte
 
 	// Null edge case:
 	actual = JSON.parse( 'null', reviveError );
-	t.equal( actual, null, 'returns expected value' );
+	t.strictEqual( actual, null, 'returns expected value' );
 
 	t.end();
 });
@@ -141,8 +141,8 @@ tape( 'the function will revive a JSON-serialized error object', function test(
 		actual = JSON.parse( JSON.stringify( json ), reviveError );
 
 		t.ok( actual instanceof ctors[ i ], 'instance of type ' + types[i] );
-		t.equal( actual.message, expected.message, 'returns expected value' );
-		t.equal( actual.stack, expected.stack, 'returns expected value' );
+		t.strictEqual( actual.message, expected.message, 'returns expected value' );
+		t.strictEqual( actual.stack, expected.stack, 'returns expected value' );
 	}
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'non-standard error properties are bound to the revived error instance', f
 
 	err = JSON.parse( JSON.stringify( json ), reviveError );
 
-	t.equal( err.beep, json.beep, 'shallow properties' );
+	t.strictEqual( err.beep, json.beep, 'shallow properties' );
 
 	t.notEqual( err.arr, json.arr, 'separate instances' );
 	t.deepEqual( err.arr, json.arr, 'returns expected value' );
@@ -219,8 +219,8 @@ tape( 'the function will revive deeply nested serialized error objects', functio
 		expected.stack = 'boop';
 
 		t.ok( actual[i] instanceof ctors[i], 'instance of ' + ctors[ i ] );
-		t.equal( actual[i].message, expected.message, 'returns expected value' );
-		t.equal( actual[i].stack, expected.stack, 'returns expected value' );
+		t.strictEqual( actual[i].message, expected.message, 'returns expected value' );
+		t.strictEqual( actual[i].stack, expected.stack, 'returns expected value' );
 	}
 
 	json = {
@@ -240,9 +240,9 @@ tape( 'the function will revive deeply nested serialized error objects', functio
 
 	t.ok( actual.beep.boop instanceof RangeError, 'instance of RangeError' );
 
-	t.equal( actual.beep.boop.message, expected.beep.boop.message, 'returns expected value' );
+	t.strictEqual( actual.beep.boop.message, expected.beep.boop.message, 'returns expected value' );
 
-	t.equal( actual.beep.boop.stack, expected.beep.boop.stack, 'returns expected value' );
+	t.strictEqual( actual.beep.boop.stack, expected.beep.boop.stack, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/error/test/test.js b/lib/node_modules/@stdlib/error/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/error/test/test.js
+++ b/lib/node_modules/@stdlib/error/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/error/tools/database/test/test.js b/lib/node_modules/@stdlib/error/tools/database/test/test.js
index d0b56ca514ef..4ce9c298b05d 100644
--- a/lib/node_modules/@stdlib/error/tools/database/test/test.js
+++ b/lib/node_modules/@stdlib/error/tools/database/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns an object mappping error codes to error messages', function test( t ) {
 	var data = database();
 	var keys = objectKeys( data );
-	t.equal( isPlainObject( data ), true, 'returns a plain object' );
-	t.equal( keys.length > 0, true, 'the returned object has keys' );
+	t.strictEqual( isPlainObject( data ), true, 'returns a plain object' );
+	t.strictEqual( keys.length > 0, true, 'the returned object has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.js b/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.js
index 38de851d8f91..77ad8865a8be 100644
--- a/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.js
+++ b/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.js
@@ -94,7 +94,7 @@ tape( 'the function returns an error message function', function test( t ) {
 	formatProdErrorMessage = fmtprodmsgFactory( opts );
 	str = formatProdErrorMessage( '6', 'boop' );
 
-	t.equal( typeof formatProdErrorMessage, 'function', 'returns a function' );
-	t.equal( typeof str, 'string', 'returned function returns a string' );
+	t.strictEqual( typeof formatProdErrorMessage, 'function', 'returns a function' );
+	t.strictEqual( typeof str, 'string', 'returned function returns a string' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.validate.js b/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.validate.js
index 6edd8caa503a..b1536ce0be2a 100644
--- a/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.validate.js
+++ b/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.validate.js
@@ -118,9 +118,9 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
-	t.equal( obj.url, opts.url, 'sets url option' );
-	t.equal( obj.message, opts.message, 'sets message option' );
+	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( obj.url, opts.url, 'sets url option' );
+	t.strictEqual( obj.message, opts.message, 'sets message option' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/error/tools/fmtprodmsg/test/test.js b/lib/node_modules/@stdlib/error/tools/fmtprodmsg/test/test.js
index 8378761a055a..77612b5edf4d 100644
--- a/lib/node_modules/@stdlib/error/tools/fmtprodmsg/test/test.js
+++ b/lib/node_modules/@stdlib/error/tools/fmtprodmsg/test/test.js
@@ -37,6 +37,6 @@ tape( 'the function returns a formatted error message', function test( t ) {
 
 	actual = fmtprodmsg( 'foo' );
 
-	t.equal( typeof actual, 'string', 'returns a string' );
+	t.strictEqual( typeof actual, 'string', 'returns a string' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/error/tools/test/test.js b/lib/node_modules/@stdlib/error/tools/test/test.js
index d982199b4a5d..9e59fbadc2f8 100644
--- a/lib/node_modules/@stdlib/error/tools/test/test.js
+++ b/lib/node_modules/@stdlib/error/tools/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains error utility tools', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/function/test/test.js b/lib/node_modules/@stdlib/function/test/test.js
index 9931b3a8638f..da72de67868b 100644
--- a/lib/node_modules/@stdlib/function/test/test.js
+++ b/lib/node_modules/@stdlib/function/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/lapack/base/test/test.js b/lib/node_modules/@stdlib/lapack/base/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/lapack/base/test/test.js
+++ b/lib/node_modules/@stdlib/lapack/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/lapack/test/test.js b/lib/node_modules/@stdlib/lapack/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/lapack/test/test.js
+++ b/lib/node_modules/@stdlib/lapack/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/base/assert/test/test.js b/lib/node_modules/@stdlib/ndarray/base/assert/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assert/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assert/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/base/test/test.js b/lib/node_modules/@stdlib/ndarray/base/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/ndarray/base/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/test/test.js b/lib/node_modules/@stdlib/ndarray/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/ndarray/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/vector/test/test.js b/lib/node_modules/@stdlib/ndarray/vector/test/test.js
index d1e6eeb4039e..30bee535777f 100644
--- a/lib/node_modules/@stdlib/ndarray/vector/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/vector/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'returns expected value' );
+	t.strictEqual( keys.length > 0, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/net/disposable-http-server/test/test.main.js b/lib/node_modules/@stdlib/net/disposable-http-server/test/test.main.js
index 9d24da297e81..08ab59291149 100644
--- a/lib/node_modules/@stdlib/net/disposable-http-server/test/test.main.js
+++ b/lib/node_modules/@stdlib/net/disposable-http-server/test/test.main.js
@@ -145,7 +145,7 @@ tape( 'if only provided HTML, the server serves the HTML content once and then c
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( body, opts.html, 'returns content' );
+		t.strictEqual( body, opts.html, 'returns content' );
 		if ( flg ) {
 			t.end();
 		} else {
@@ -207,7 +207,7 @@ tape( 'if only provided JavaScript, the server serves an HTML boilerplate and th
 			t.ok( false, error.message );
 			return t.end();
 		}
-		t.equal( data, html, 'returns HTML boilerplate' );
+		t.strictEqual( data, html, 'returns HTML boilerplate' );
 		getJavaScript();
 	}
 
@@ -227,7 +227,7 @@ tape( 'if only provided JavaScript, the server serves an HTML boilerplate and th
 			t.ok( false, error.message );
 			return t.end();
 		}
-		t.equal( data, opts.javascript, 'returns JavaScript' );
+		t.strictEqual( data, opts.javascript, 'returns JavaScript' );
 		if ( flg ) {
 			t.end();
 		} else {
@@ -285,7 +285,7 @@ tape( 'if provided HTML and JavaScript, the server serves the HTML and then the
 			t.ok( false, error.message );
 			return t.end();
 		}
-		t.equal( data, opts.html, 'returns HTML' );
+		t.strictEqual( data, opts.html, 'returns HTML' );
 		getJavaScript();
 	}
 
@@ -305,7 +305,7 @@ tape( 'if provided HTML and JavaScript, the server serves the HTML and then the
 			t.ok( false, error.message );
 			return t.end();
 		}
-		t.equal( data, opts.javascript, 'returns JavaScript' );
+		t.strictEqual( data, opts.javascript, 'returns JavaScript' );
 		if ( flg ) {
 			t.end();
 		} else {
@@ -362,7 +362,7 @@ tape( 'if a client only requests JavaScript, the server serves the JavaScript an
 			t.ok( false, error.message );
 			return t.end();
 		}
-		t.equal( data, opts.javascript, 'returns JavaScript' );
+		t.strictEqual( data, opts.javascript, 'returns JavaScript' );
 		if ( flg ) {
 			t.end();
 		} else {
@@ -415,7 +415,7 @@ tape( 'if the server receives a request for something other than the JavaScript
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( res.statusCode, 404, 'returns 404' );
+		t.strictEqual( res.statusCode, 404, 'returns 404' );
 		server.close();
 	}
 
@@ -470,7 +470,7 @@ tape( 'if the server receives a request while closing, the server returns a `503
 			t.ok( false, error.message );
 			return t.end();
 		}
-		t.equal( data, opts.html, 'returns HTML' );
+		t.strictEqual( data, opts.html, 'returns HTML' );
 		next();
 	}
 
@@ -490,7 +490,7 @@ tape( 'if the server receives a request while closing, the server returns a `503
 			t.ok( false, error.message );
 			return t.end();
 		}
-		t.equal( res.statusCode, 503, 'returns 503 response' );
+		t.strictEqual( res.statusCode, 503, 'returns 503 response' );
 
 		// Restore the close method:
 		server.close = close;
@@ -540,7 +540,7 @@ tape( 'the function accepts `Buffer` objects for both HTML and JavaScript', func
 			t.ok( false, error.message );
 			return t.end();
 		}
-		t.equal( data, opts.html.toString(), 'returns HTML' );
+		t.strictEqual( data, opts.html.toString(), 'returns HTML' );
 		getJavaScript();
 	}
 
@@ -560,7 +560,7 @@ tape( 'the function accepts `Buffer` objects for both HTML and JavaScript', func
 			t.ok( false, error.message );
 			return t.end();
 		}
-		t.equal( data, opts.javascript.toString(), 'returns JavaScript' );
+		t.strictEqual( data, opts.javascript.toString(), 'returns JavaScript' );
 		if ( flg ) {
 			t.end();
 		} else {
@@ -663,7 +663,7 @@ tape( 'if the `open` option is `true`, the function will attempt to open the con
 	function openURL( url ) {
 		var options;
 
-		t.equal( url, 'http://'+opts.address+':'+opts.port, 'attempts to open URL' );
+		t.strictEqual( url, 'http://'+opts.address+':'+opts.port, 'attempts to open URL' );
 
 		options = {
 			'protocol': 'http:',
@@ -692,7 +692,7 @@ tape( 'if the `open` option is `true`, the function will attempt to open the con
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( body, opts.html, 'returns content' );
+		t.strictEqual( body, opts.html, 'returns content' );
 		if ( flg ) {
 			t.end();
 		} else {
diff --git a/lib/node_modules/@stdlib/net/disposable-http-server/test/test.validate.js b/lib/node_modules/@stdlib/net/disposable-http-server/test/test.validate.js
index 73f3ebc93ec6..7722353c73bb 100644
--- a/lib/node_modules/@stdlib/net/disposable-http-server/test/test.validate.js
+++ b/lib/node_modules/@stdlib/net/disposable-http-server/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided an `html` option which is n
 		err = validate( {}, {
 			'html': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns a type error if provided a `javascript` option which
 		err = validate( {}, {
 			'javascript': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns a type error if provided an `open` option which is n
 		err = validate( {}, {
 			'open': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -151,7 +151,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -172,7 +172,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/net/http-server/test/test.js b/lib/node_modules/@stdlib/net/http-server/test/test.js
index cb9fcf58a41f..c4579bc480c1 100644
--- a/lib/node_modules/@stdlib/net/http-server/test/test.js
+++ b/lib/node_modules/@stdlib/net/http-server/test/test.js
@@ -79,7 +79,7 @@ tape( 'the function will throw an error if provided a request listener which is
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.equal( typeof httpServer(), 'function', 'returns a function' );
+	t.strictEqual( typeof httpServer(), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -126,7 +126,7 @@ tape( 'the created server listens on a specified port', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		} else {
-			t.equal( server.address().port, opts.port, 'listens on port '+opts.port );
+			t.strictEqual( server.address().port, opts.port, 'listens on port '+opts.port );
 		}
 		server.close();
 		t.end();
@@ -204,7 +204,7 @@ tape( 'the returned function will port hunt', function test( t ) {
 
 	function next() {
 		var addr = eServer.address();
-		t.equal( addr.port, opts.port, 'fixture server bound to port '+opts.port+' and with address '+addr.address );
+		t.strictEqual( addr.port, opts.port, 'fixture server bound to port '+opts.port+' and with address '+addr.address );
 		create( onServer );
 	}
 
@@ -215,7 +215,7 @@ tape( 'the returned function will port hunt', function test( t ) {
 			t.ok( false, error.message );
 		} else {
 			port = server.address().port;
-			t.equal( port > opts.port, true, 'returns a server with a port ('+port+') higher than '+opts.port );
+			t.strictEqual( port > opts.port, true, 'returns a server with a port ('+port+') higher than '+opts.port );
 		}
 		setTimeout( onTimeout, 0 );
 	}
@@ -265,7 +265,7 @@ tape( 'the server will listen on a specified address', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		} else {
-			t.equal( server.address().address, opts.address, 'listens at address '+opts.address );
+			t.strictEqual( server.address().address, opts.address, 'listens at address '+opts.address );
 		}
 		server.close();
 		t.end();
diff --git a/lib/node_modules/@stdlib/net/http-server/test/test.validate.js b/lib/node_modules/@stdlib/net/http-server/test/test.validate.js
index 5b65b0997f22..772d7bdcce87 100644
--- a/lib/node_modules/@stdlib/net/http-server/test/test.validate.js
+++ b/lib/node_modules/@stdlib/net/http-server/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns an error if provided an `options` argument which is
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[ i ] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns an error if provided a `port` option which is not a
 		err = validate( {}, {
 			'port': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an error if provided a `maxport` option which is not
 		err = validate( {}, {
 			'maxport': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'the function returns an error if provided a `hostname` option which is no
 		err = validate( {}, {
 			'hostname': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -154,7 +154,7 @@ tape( 'the function returns an error if provided an `address` option which is no
 		err = validate( {}, {
 			'address': values[ i ]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -173,7 +173,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -191,7 +191,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/net/simple-http-server/test/test.main.js b/lib/node_modules/@stdlib/net/simple-http-server/test/test.main.js
index 6dc61d8acc7d..b48ed8870bcd 100644
--- a/lib/node_modules/@stdlib/net/simple-http-server/test/test.main.js
+++ b/lib/node_modules/@stdlib/net/simple-http-server/test/test.main.js
@@ -256,7 +256,7 @@ tape( 'if provided a `dir` option from which to serve files, the function resolv
 	}
 
 	function requestListener( options ) {
-		t.equal( options.dir, dir, 'resolves relative path to current working directory' );
+		t.strictEqual( options.dir, dir, 'resolves relative path to current working directory' );
 		flg = true;
 	}
 });
@@ -280,7 +280,7 @@ tape( 'if the `open` option is `true`, the function will attempt to open a user\
 	httpServer( opts, onReady );
 
 	function openURL( url ) {
-		t.equal( url, 'http://'+opts.address+':'+opts.port, 'attempts to open URL' );
+		t.strictEqual( url, 'http://'+opts.address+':'+opts.port, 'attempts to open URL' );
 		flg = true;
 	}
 
diff --git a/lib/node_modules/@stdlib/net/simple-http-server/test/test.validate.js b/lib/node_modules/@stdlib/net/simple-http-server/test/test.validate.js
index b81202f2cdda..96002fb34a00 100644
--- a/lib/node_modules/@stdlib/net/simple-http-server/test/test.validate.js
+++ b/lib/node_modules/@stdlib/net/simple-http-server/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function returns a type error if provided a `dir` option which is not
 		err = validate( {}, {
 			'dir': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns a type error if provided an `open` option which is n
 		err = validate( {}, {
 			'open': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -145,7 +145,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/net/test/test.js b/lib/node_modules/@stdlib/net/test/test.js
index 8345209ed3c6..1e268fa5474a 100644
--- a/lib/node_modules/@stdlib/net/test/test.js
+++ b/lib/node_modules/@stdlib/net/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains networking functionality', function test( t ) {
 	var keys = objectKeys( net );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/nlp/expand-acronyms/test/test.js b/lib/node_modules/@stdlib/nlp/expand-acronyms/test/test.js
index d28757191d1e..1d2595c3546a 100644
--- a/lib/node_modules/@stdlib/nlp/expand-acronyms/test/test.js
+++ b/lib/node_modules/@stdlib/nlp/expand-acronyms/test/test.js
@@ -82,7 +82,7 @@ tape( 'the function expands acronyms', function test( t ) {
 	];
 	for ( i = 0; i < values.length; i++ ) {
 		actual = expandAcronyms( values[i] );
-		t.equal( actual, expected[i], 'converts string to '+expected[i] );
+		t.strictEqual( actual, expected[i], 'converts string to '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/nlp/expand-contractions/test/test.js b/lib/node_modules/@stdlib/nlp/expand-contractions/test/test.js
index da2b623eceaa..6aabcc699dfe 100644
--- a/lib/node_modules/@stdlib/nlp/expand-contractions/test/test.js
+++ b/lib/node_modules/@stdlib/nlp/expand-contractions/test/test.js
@@ -80,7 +80,7 @@ tape( 'the function expands contractions to their formal equivalents', function
 	];
 	for ( i = 0; i < values.length; i++ ) {
 		actual = expandContractions( values[i] );
-		t.equal( actual, expected[i], 'converts string to '+expected[i] );
+		t.strictEqual( actual, expected[i], 'converts string to '+expected[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/nlp/lda/test/test.validate.js b/lib/node_modules/@stdlib/nlp/lda/test/test.validate.js
index e5584f6ae384..147cfa005fa4 100644
--- a/lib/node_modules/@stdlib/nlp/lda/test/test.validate.js
+++ b/lib/node_modules/@stdlib/nlp/lda/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns a type error if provided a `alpha` option which is n
 		err = validate( {}, {
 			'alpha': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns a type error if provided a `beta` option which is no
 		err = validate( {}, {
 			'beta': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -149,7 +149,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/nlp/ordinalize/test/test.js b/lib/node_modules/@stdlib/nlp/ordinalize/test/test.js
index 5a9d8bfcad78..41b70e22a8d8 100644
--- a/lib/node_modules/@stdlib/nlp/ordinalize/test/test.js
+++ b/lib/node_modules/@stdlib/nlp/ordinalize/test/test.js
@@ -191,7 +191,7 @@ tape( 'the function returns an ordinal string for a provided integer string (def
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i] ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i] ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -243,7 +243,7 @@ tape( 'the function returns an ordinal string for a provided integer (default la
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i] ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i] ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -300,7 +300,7 @@ tape( 'the function supports returning an ordinal string suffix for a provided i
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -357,7 +357,7 @@ tape( 'the function supports returning an ordinal string suffix for a provided i
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -414,7 +414,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -471,7 +471,7 @@ tape( 'the function returns an ordinal string for a provided integer (lang=en)',
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -528,7 +528,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -586,7 +586,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -644,7 +644,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -701,7 +701,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -758,7 +758,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -815,7 +815,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -873,7 +873,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -931,7 +931,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -988,7 +988,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -1046,7 +1046,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -1104,7 +1104,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -1161,7 +1161,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -1219,7 +1219,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -1277,7 +1277,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
@@ -1334,7 +1334,7 @@ tape( 'the function returns an ordinal string for a provided integer string (lan
 	};
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
+		t.strictEqual( ordinalize( values[i], opts ), expected[i], 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/nlp/ordinalize/test/test.validate.js b/lib/node_modules/@stdlib/nlp/ordinalize/test/test.validate.js
index acb3f359101d..cf4aa6af95ed 100644
--- a/lib/node_modules/@stdlib/nlp/ordinalize/test/test.validate.js
+++ b/lib/node_modules/@stdlib/nlp/ordinalize/test/test.validate.js
@@ -50,7 +50,7 @@ tape( 'the function returns a type error if not provided an options object', fun
 
 	for ( i = 0; i < values.length; i++ ) {
 		err = validate( {}, values[i] );
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns a type error if provided a `lang` option which is no
 		err = validate( {}, {
 			'lang': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'the function returns a type error if provided n `gender` option which is
 		err = validate( {}, {
 			'gender': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function returns a type error if provided a `suffixOnly` option which
 		err = validate( {}, {
 			'suffixOnly': values[i]
 		});
-		t.equal( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
+		t.strictEqual( err instanceof TypeError, true, 'returns a TypeError when provided '+values[i] );
 	}
 	t.end();
 });
@@ -153,7 +153,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.equal( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns null' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/nlp/porter-stemmer/test/test.js b/lib/node_modules/@stdlib/nlp/porter-stemmer/test/test.js
index aee8400711f6..8cef5df10ea0 100644
--- a/lib/node_modules/@stdlib/nlp/porter-stemmer/test/test.js
+++ b/lib/node_modules/@stdlib/nlp/porter-stemmer/test/test.js
@@ -76,13 +76,13 @@ tape( 'the function stems an input string using the Porter stemming algorithm',
 	for ( i = 0; i < words.original.length; i++ ) {
 		expected = words.stemmed[ i ];
 		actual = porterStemmer( words.original[ i ] );
-		t.equal( actual, expected, 'returns the expected string' );
+		t.strictEqual( actual, expected, 'returns the expected string' );
 	}
 	t.end();
 });
 
 tape( 'the function returns an empty string if provided an empty string', function test( t ) {
 	var out = porterStemmer( '' );
-	t.equal( isEmptyString( out ), true, 'returns an empty string' );
+	t.strictEqual( isEmptyString( out ), true, 'returns an empty string' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/nlp/sentencize/test/test.js b/lib/node_modules/@stdlib/nlp/sentencize/test/test.js
index 95e641e770c0..20d689d5431d 100644
--- a/lib/node_modules/@stdlib/nlp/sentencize/test/test.js
+++ b/lib/node_modules/@stdlib/nlp/sentencize/test/test.js
@@ -313,8 +313,8 @@ tape( 'the function splits a string into an array of sentences (multiple punctua
 
 tape( 'the function returns an empty array if provided an empty string', function test( t ) {
 	var out = sentencize( '' );
-	t.equal( isArray( out ), true, 'returns an array' );
-	t.equal( out.length, 0, 'array length is zero' );
+	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( out.length, 0, 'array length is zero' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/nlp/test/test.js b/lib/node_modules/@stdlib/nlp/test/test.js
index af4f8f42851a..281b9585eecd 100644
--- a/lib/node_modules/@stdlib/nlp/test/test.js
+++ b/lib/node_modules/@stdlib/nlp/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains functions for natural language processing', function test( t ) {
 	var keys = objectKeys( nlp );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/nlp/tokenize/test/test.js b/lib/node_modules/@stdlib/nlp/tokenize/test/test.js
index 2b6b0cb0c2a6..9bf578e83079 100644
--- a/lib/node_modules/@stdlib/nlp/tokenize/test/test.js
+++ b/lib/node_modules/@stdlib/nlp/tokenize/test/test.js
@@ -281,7 +281,7 @@ tape( 'the function tokenizes a string (preserving whitespace)', function test(
 
 tape( 'the function returns an emptry array if provided an empty string', function test( t ) {
 	var out = tokenize( '' );
-	t.equal( isArray( out ), true, 'returns an array' );
-	t.equal( out.length, 0, 'array length is zero' );
+	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( out.length, 0, 'array length is zero' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/object/assign/test/test.js b/lib/node_modules/@stdlib/object/assign/test/test.js
index e246827d8e1a..82e8e1b2e218 100644
--- a/lib/node_modules/@stdlib/object/assign/test/test.js
+++ b/lib/node_modules/@stdlib/object/assign/test/test.js
@@ -40,7 +40,7 @@ tape( 'if an environment has a built-in implementation, the export is the built-
 		'./has_object_assign.js': true
 	});
 
-	t.equal( assign, native, 'exports native function' );
+	t.strictEqual( assign, native, 'exports native function' );
 	t.end();
 });
 
@@ -49,6 +49,6 @@ tape( 'if an environment does not have a built-in implementation, the export is
 		'./has_object_assign.js': false
 	});
 
-	t.equal( assign, polyfill, 'exports polyfill function' );
+	t.strictEqual( assign, polyfill, 'exports polyfill function' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/object/some-in-by/test/test.js b/lib/node_modules/@stdlib/object/some-in-by/test/test.js
index 3459fa8c17d8..f3a36a552731 100644
--- a/lib/node_modules/@stdlib/object/some-in-by/test/test.js
+++ b/lib/node_modules/@stdlib/object/some-in-by/test/test.js
@@ -98,7 +98,7 @@ tape( 'the function throws an error if not provided a second argument which is a
 
 	function badValue( value ) {
 		return function badValue() {
-			someInBy( {
+			someInBy({
 				'a': 1,
 				'b': 2,
 				'c': 3
@@ -132,7 +132,7 @@ tape( 'the function throws an error if not provided a predicate function', funct
 
 	function badValue( value ) {
 		return function badValue() {
-			someInBy( {
+			someInBy({
 				'a': 1,
 				'b': 2,
 				'c': 3
@@ -306,7 +306,7 @@ tape( 'the function returns `false` if provided a regular expression or a date o
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( someInBy( values[ i ], 1, threshold ), false, 'returns false when provided ' + values[ i ] );
+		t.strictEqual( someInBy( values[ i ], 1, threshold ), false, 'returns false when provided ' + values[ i ] );
 	}
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/object/test/test.js b/lib/node_modules/@stdlib/object/test/test.js
index 9931b3a8638f..da72de67868b 100644
--- a/lib/node_modules/@stdlib/object/test/test.js
+++ b/lib/node_modules/@stdlib/object/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/os/arch/test/test.js b/lib/node_modules/@stdlib/os/arch/test/test.js
index d685bc0030cf..4895ba3e3ead 100644
--- a/lib/node_modules/@stdlib/os/arch/test/test.js
+++ b/lib/node_modules/@stdlib/os/arch/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a string', function test( t ) {
 });
 
 tape( 'should alias `process.arch`', function test( t ) {
-	t.equal( ARCH, proc.arch, 'is alias' );
+	t.strictEqual( ARCH, proc.arch, 'is alias' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/os/byte-order/test/test.js b/lib/node_modules/@stdlib/os/byte-order/test/test.js
index 0731011fab44..65383bc0e2de 100644
--- a/lib/node_modules/@stdlib/os/byte-order/test/test.js
+++ b/lib/node_modules/@stdlib/os/byte-order/test/test.js
@@ -40,7 +40,7 @@ tape( 'if the platform is little-endian, the value should be `little-endian`', f
 		'@stdlib/assert/is-little-endian': true,
 		'@stdlib/assert/is-big-endian': false
 	});
-	t.equal( BYTE_ORDER, 'little-endian', 'returns expected value' );
+	t.strictEqual( BYTE_ORDER, 'little-endian', 'returns expected value' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'if the platform is big-endian, the value should be `big-endian`', functio
 		'@stdlib/assert/is-little-endian': false,
 		'@stdlib/assert/is-big-endian': true
 	});
-	t.equal( BYTE_ORDER, 'big-endian', 'returns expected value' );
+	t.strictEqual( BYTE_ORDER, 'big-endian', 'returns expected value' );
 	t.end();
 });
 
@@ -62,7 +62,7 @@ tape( 'if the platform is both little-endian and big-endian, the value should be
 		'@stdlib/assert/is-little-endian': true,
 		'@stdlib/assert/is-big-endian': true
 	});
-	t.equal( BYTE_ORDER, 'mixed-endian', 'returns expected value' );
+	t.strictEqual( BYTE_ORDER, 'mixed-endian', 'returns expected value' );
 	t.end();
 });
 
@@ -73,6 +73,6 @@ tape( 'if the platform is neither little-endian nor big-endian, the value should
 		'@stdlib/assert/is-little-endian': false,
 		'@stdlib/assert/is-big-endian': false
 	});
-	t.equal( BYTE_ORDER, 'unknown', 'returns expected value' );
+	t.strictEqual( BYTE_ORDER, 'unknown', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/os/float-word-order/test/test.js b/lib/node_modules/@stdlib/os/float-word-order/test/test.js
index 354e84c3262c..8f5ac9fc4a91 100644
--- a/lib/node_modules/@stdlib/os/float-word-order/test/test.js
+++ b/lib/node_modules/@stdlib/os/float-word-order/test/test.js
@@ -39,7 +39,7 @@ tape( 'if the platform is little-endian, the value should be `little-endian`', f
 	FLOAT_WORD_ORDER = proxyquire( './../lib/main.js', {
 		'@stdlib/os/byte-order': 'little-endian'
 	});
-	t.equal( FLOAT_WORD_ORDER, 'little-endian', 'returns expected value' );
+	t.strictEqual( FLOAT_WORD_ORDER, 'little-endian', 'returns expected value' );
 	t.end();
 });
 
@@ -49,7 +49,7 @@ tape( 'if the platform is big-endian, the value should be `big-endian`', functio
 	FLOAT_WORD_ORDER = proxyquire( './../lib/main.js', {
 		'@stdlib/os/byte-order': 'big-endian'
 	});
-	t.equal( FLOAT_WORD_ORDER, 'big-endian', 'returns expected value' );
+	t.strictEqual( FLOAT_WORD_ORDER, 'big-endian', 'returns expected value' );
 	t.end();
 });
 
@@ -59,6 +59,6 @@ tape( 'if the platform is neither little-endian nor big-endian, the value should
 	FLOAT_WORD_ORDER = proxyquire( './../lib/main.js', {
 		'@stdlib/os/byte-order': 'beep-boop'
 	});
-	t.equal( FLOAT_WORD_ORDER, 'unknown', 'returns expected value' );
+	t.strictEqual( FLOAT_WORD_ORDER, 'unknown', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/os/num-cpus/test/test.browser.js b/lib/node_modules/@stdlib/os/num-cpus/test/test.browser.js
index f61845d4eafb..7a0ff87f6d1f 100644
--- a/lib/node_modules/@stdlib/os/num-cpus/test/test.browser.js
+++ b/lib/node_modules/@stdlib/os/num-cpus/test/test.browser.js
@@ -35,7 +35,7 @@ tape( 'main export is a number', function test( t ) {
 });
 
 tape( 'the exported value is always a positive integer', function test( t ) {
-	t.equal( isPositiveInteger( NUM_CPUS ), true, 'returns a positive integer' );
+	t.strictEqual( isPositiveInteger( NUM_CPUS ), true, 'returns a positive integer' );
 	t.end();
 });
 
@@ -44,6 +44,6 @@ tape( 'if a web browser does not support hardware concurrency, the exported valu
 		'./navigator.js': {}
 	});
 
-	t.equal( NUM_CPUS, 1, 'returns 1' );
+	t.strictEqual( NUM_CPUS, 1, 'returns 1' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/os/num-cpus/test/test.js b/lib/node_modules/@stdlib/os/num-cpus/test/test.js
index d6494dee8dd0..4c750309efdc 100644
--- a/lib/node_modules/@stdlib/os/num-cpus/test/test.js
+++ b/lib/node_modules/@stdlib/os/num-cpus/test/test.js
@@ -42,6 +42,6 @@ tape( 'main export is a number', opts, function test( t ) {
 });
 
 tape( 'the exported value is always a positive integer', opts, function test( t ) {
-	t.equal( isPositiveInteger( NUM_CPUS ), true, 'returns a positive integer' );
+	t.strictEqual( isPositiveInteger( NUM_CPUS ), true, 'returns a positive integer' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/os/platform/test/test.js b/lib/node_modules/@stdlib/os/platform/test/test.js
index 3714f12f3959..378234e6e3de 100644
--- a/lib/node_modules/@stdlib/os/platform/test/test.js
+++ b/lib/node_modules/@stdlib/os/platform/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a string', function test( t ) {
 });
 
 tape( 'should alias `process.platform`', function test( t ) {
-	t.equal( PLATFORM, proc.platform, 'is alias' );
+	t.strictEqual( PLATFORM, proc.platform, 'is alias' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/os/test/test.js b/lib/node_modules/@stdlib/os/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/os/test/test.js
+++ b/lib/node_modules/@stdlib/os/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/os/tmpdir/test/test.js b/lib/node_modules/@stdlib/os/tmpdir/test/test.js
index 0d32344de178..834f83671355 100644
--- a/lib/node_modules/@stdlib/os/tmpdir/test/test.js
+++ b/lib/node_modules/@stdlib/os/tmpdir/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.equal( typeof tmpdir(), 'string', 'returns a string' );
+	t.strictEqual( typeof tmpdir(), 'string', 'returns a string' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/process/chdir/test/test.js b/lib/node_modules/@stdlib/process/chdir/test/test.js
index 93db1096e8a8..f146ffe38874 100644
--- a/lib/node_modules/@stdlib/process/chdir/test/test.js
+++ b/lib/node_modules/@stdlib/process/chdir/test/test.js
@@ -57,8 +57,8 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function changes the working directory', opts, function test( t ) {
 	var err = chdir( __dirname );
 
-	t.equal( err, null, 'returns expected value' );
-	t.equal( cwd(), __dirname, 'sets working directory' );
+	t.strictEqual( err, null, 'returns expected value' );
+	t.strictEqual( cwd(), __dirname, 'sets working directory' );
 
 	// Restore current working directory:
 	restore();
@@ -69,8 +69,8 @@ tape( 'the function changes the working directory', opts, function test( t ) {
 tape( 'if the function encounters an error when attempting to change the working directory, the function returns the error', opts, function test( t ) {
 	var err = chdir( 'kjflajflsda/bkadlfjadlfksabldjkfklajsf/dkfaljsf' ); // non-existent directory
 
-	t.equal( err instanceof Error, true, 'returns an error' );
-	t.equal( cwd(), DIR, 'does not change working directory' );
+	t.strictEqual( err instanceof Error, true, 'returns an error' );
+	t.strictEqual( cwd(), DIR, 'does not change working directory' );
 
 	// Restore current working directory:
 	restore();
diff --git a/lib/node_modules/@stdlib/process/chdir/test/test.polyfill.js b/lib/node_modules/@stdlib/process/chdir/test/test.polyfill.js
index 3330ddf1e49e..bdc6b11fe77d 100644
--- a/lib/node_modules/@stdlib/process/chdir/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/process/chdir/test/test.polyfill.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an error', function test( t ) {
 	var err = chdir();
-	t.equal( err instanceof Error, true, 'returns an error' );
+	t.strictEqual( err instanceof Error, true, 'returns an error' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/cwd/test/test.js b/lib/node_modules/@stdlib/process/cwd/test/test.js
index 75927632a795..8036ab1db46d 100644
--- a/lib/node_modules/@stdlib/process/cwd/test/test.js
+++ b/lib/node_modules/@stdlib/process/cwd/test/test.js
@@ -42,6 +42,6 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns the current working directory', opts, function test( t ) {
-	t.equal( cwd(), proc.cwd(), 'returns current working directory' );
+	t.strictEqual( cwd(), proc.cwd(), 'returns current working directory' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/cwd/test/test.polyfill.js b/lib/node_modules/@stdlib/process/cwd/test/test.polyfill.js
index 324b1e392de1..142e1207e7a8 100644
--- a/lib/node_modules/@stdlib/process/cwd/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/process/cwd/test/test.polyfill.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns the current working directory', function test( t ) {
-	t.equal( cwd(), '/', 'returns current working directory' );
+	t.strictEqual( cwd(), '/', 'returns current working directory' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/exec-path/test/test.browser.js b/lib/node_modules/@stdlib/process/exec-path/test/test.browser.js
index 427c0f64d249..01949c372129 100644
--- a/lib/node_modules/@stdlib/process/exec-path/test/test.browser.js
+++ b/lib/node_modules/@stdlib/process/exec-path/test/test.browser.js
@@ -28,6 +28,6 @@ var EXEC_PATH = require( './../lib/browser.js' );
 
 tape( 'main export is `null`', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( EXEC_PATH, null, 'main export is `null`' );
+	t.strictEqual( EXEC_PATH, null, 'main export is `null`' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/exec-path/test/test.js b/lib/node_modules/@stdlib/process/exec-path/test/test.js
index d97b4c151b49..986b7ec30f21 100644
--- a/lib/node_modules/@stdlib/process/exec-path/test/test.js
+++ b/lib/node_modules/@stdlib/process/exec-path/test/test.js
@@ -36,9 +36,9 @@ tape( 'main export is either a string or `null`', function test( t ) {
 
 tape( 'if running in a Node.js process, the main export is a string; otherwise, the export is equal to `null`.', function test( t ) {
 	if ( IS_NODE ) {
-		t.equal( typeof EXEC_PATH, 'string', 'exports a string' );
+		t.strictEqual( typeof EXEC_PATH, 'string', 'exports a string' );
 	} else {
-		t.equal( EXEC_PATH, null, 'exports null' );
+		t.strictEqual( EXEC_PATH, null, 'exports null' );
 	}
 	t.end();
 });
@@ -47,6 +47,6 @@ tape( 'if not running in a Node.js process, the main export is `null`', function
 	var EXEC_PATH = proxyquire( './../lib', {
 		'@stdlib/assert/is-node': false
 	});
-	t.equal( EXEC_PATH, null, 'exports null' );
+	t.strictEqual( EXEC_PATH, null, 'exports null' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/exec-path/test/test.main.js b/lib/node_modules/@stdlib/process/exec-path/test/test.main.js
index aac2ea72b00b..52dc9f3faf25 100644
--- a/lib/node_modules/@stdlib/process/exec-path/test/test.main.js
+++ b/lib/node_modules/@stdlib/process/exec-path/test/test.main.js
@@ -39,6 +39,6 @@ tape( 'main export equals `process.execPath`', function test( t ) {
 			'execPath': '/foo/bar/node'
 		}
 	});
-	t.equal( EXEC_PATH, '/foo/bar/node', 'returns expected value' );
+	t.strictEqual( EXEC_PATH, '/foo/bar/node', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/node-version/test/test.browser.js b/lib/node_modules/@stdlib/process/node-version/test/test.browser.js
index 5223acb12890..6b59630b0f8f 100644
--- a/lib/node_modules/@stdlib/process/node-version/test/test.browser.js
+++ b/lib/node_modules/@stdlib/process/node-version/test/test.browser.js
@@ -28,6 +28,6 @@ var VERSION = require( './../lib/browser.js' );
 
 tape( 'main export is `null`', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( VERSION, null, 'main export is `null`' );
+	t.strictEqual( VERSION, null, 'main export is `null`' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/node-version/test/test.js b/lib/node_modules/@stdlib/process/node-version/test/test.js
index 2664433b4f66..68437cd98386 100644
--- a/lib/node_modules/@stdlib/process/node-version/test/test.js
+++ b/lib/node_modules/@stdlib/process/node-version/test/test.js
@@ -36,9 +36,9 @@ tape( 'main export is either a string or `null`', function test( t ) {
 
 tape( 'if running in a Node.js process, the main export is a string; otherwise, the export is equal to `null`.', function test( t ) {
 	if ( IS_NODE ) {
-		t.equal( typeof VERSION, 'string', 'exports a string' );
+		t.strictEqual( typeof VERSION, 'string', 'exports a string' );
 	} else {
-		t.equal( VERSION, null, 'exports null' );
+		t.strictEqual( VERSION, null, 'exports null' );
 	}
 	t.end();
 });
@@ -47,6 +47,6 @@ tape( 'if not running in a Node.js process, the main export is `null`', function
 	var VERSION = proxyquire( './../lib', {
 		'@stdlib/assert/is-node': false
 	});
-	t.equal( VERSION, null, 'exports null' );
+	t.strictEqual( VERSION, null, 'exports null' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/node-version/test/test.version.js b/lib/node_modules/@stdlib/process/node-version/test/test.version.js
index 7ff7ac86ca9b..c4ea8a77050e 100644
--- a/lib/node_modules/@stdlib/process/node-version/test/test.version.js
+++ b/lib/node_modules/@stdlib/process/node-version/test/test.version.js
@@ -41,6 +41,6 @@ tape( 'main export equals `process.versions.node`', function test( t ) {
 			}
 		}
 	});
-	t.equal( VERSION, '3.1.4', 'returns expected value' );
+	t.strictEqual( VERSION, '3.1.4', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/read-stdin/test/test.js b/lib/node_modules/@stdlib/process/read-stdin/test/test.js
index 2d6684449018..4a77f79aaf96 100644
--- a/lib/node_modules/@stdlib/process/read-stdin/test/test.js
+++ b/lib/node_modules/@stdlib/process/read-stdin/test/test.js
@@ -121,8 +121,8 @@ tape( 'if `stdin` is run in TTY mode and the encoding is not set, the function r
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isBuffer( data ), true, 'returns a buffer' );
-		t.equal( data.length, 0, 'buffer is empty' );
+		t.strictEqual( isBuffer( data ), true, 'returns a buffer' );
+		t.strictEqual( data.length, 0, 'buffer is empty' );
 		t.end();
 	}
 });
@@ -145,9 +145,9 @@ tape( 'if `stdin` is run in TTY mode and the encoding is set, the function retur
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isBuffer( data ), false, 'does not return a buffer' );
-		t.equal( typeof data, 'string', 'returns a string' );
-		t.equal( data.length, 0, 'string is empty' );
+		t.strictEqual( isBuffer( data ), false, 'does not return a buffer' );
+		t.strictEqual( typeof data, 'string', 'returns a string' );
+		t.strictEqual( data.length, 0, 'string is empty' );
 		t.end();
 	}
 });
@@ -170,7 +170,7 @@ tape( 'if an error is encountered while reading from `stdin`, the error is retur
 
 	function onRead( error ) {
 		if ( error ) {
-			t.equal( error.message, 'beep', 'returns an error' );
+			t.strictEqual( error.message, 'beep', 'returns an error' );
 		}
 		t.end();
 	}
@@ -194,7 +194,7 @@ tape( 'if an error is encountered while reading from `stdin`, the error is retur
 
 	function onRead( error ) {
 		if ( error ) {
-			t.equal( error.message, 'beep', 'returns an error' );
+			t.strictEqual( error.message, 'beep', 'returns an error' );
 		}
 		t.end();
 	}
@@ -223,8 +223,8 @@ tape( 'if the `encoding` argument is not set, the function returns `stdin` data
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isBuffer( data ), true, 'returns a buffer' );
-		t.equal( data.toString(), 'beep boop', 'returns `stdin` data' );
+		t.strictEqual( isBuffer( data ), true, 'returns a buffer' );
+		t.strictEqual( data.toString(), 'beep boop', 'returns `stdin` data' );
 		t.end();
 	}
 });
@@ -252,8 +252,8 @@ tape( 'if the `encoding` argument is not set, the function returns `stdin` data
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isBuffer( data ), true, 'returns a buffer' );
-		t.equal( data.toString(), 'beep boop', 'returns `stdin` data' );
+		t.strictEqual( isBuffer( data ), true, 'returns a buffer' );
+		t.strictEqual( data.toString(), 'beep boop', 'returns `stdin` data' );
 		t.end();
 	}
 });
@@ -281,9 +281,9 @@ tape( 'if the `encoding` argument is set, the function returns `stdin` data as a
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isBuffer( data ), false, 'does not return a buffer' );
-		t.equal( typeof data, 'string', 'returns a string' );
-		t.equal( data, 'beep boop', 'returns `stdin` data' );
+		t.strictEqual( isBuffer( data ), false, 'does not return a buffer' );
+		t.strictEqual( typeof data, 'string', 'returns a string' );
+		t.strictEqual( data, 'beep boop', 'returns `stdin` data' );
 		t.end();
 	}
 });
@@ -308,9 +308,9 @@ tape( 'if the `encoding` argument is not set and no `stdin` data, the function r
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isBuffer( data ), true, 'returns a buffer' );
-		t.equal( data.length, 0, 'returns an empty buffer' );
-		t.equal( data.toString(), '', 'buffer is empty' );
+		t.strictEqual( isBuffer( data ), true, 'returns a buffer' );
+		t.strictEqual( data.length, 0, 'returns an empty buffer' );
+		t.strictEqual( data.toString(), '', 'buffer is empty' );
 		t.end();
 	}
 });
@@ -335,9 +335,9 @@ tape( 'if the `encoding` argument is set and no `stdin` data, the function retur
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.equal( isBuffer( data ), false, 'does not return a buffer' );
-		t.equal( typeof data, 'string', 'returns a string' );
-		t.equal( data, '', 'returns empty string' );
+		t.strictEqual( isBuffer( data ), false, 'does not return a buffer' );
+		t.strictEqual( typeof data, 'string', 'returns a string' );
+		t.strictEqual( data, '', 'returns empty string' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/process/test/test.js b/lib/node_modules/@stdlib/process/test/test.js
index 57cb56495788..6dd0e95cb7a9 100644
--- a/lib/node_modules/@stdlib/process/test/test.js
+++ b/lib/node_modules/@stdlib/process/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/umask/test/test.browser.js b/lib/node_modules/@stdlib/process/umask/test/test.browser.js
index b7aea55aa129..6a3320f883ab 100644
--- a/lib/node_modules/@stdlib/process/umask/test/test.browser.js
+++ b/lib/node_modules/@stdlib/process/umask/test/test.browser.js
@@ -270,15 +270,15 @@ tape( 'if provided an expression mask, the function throws an error if unable to
 
 tape( 'if not provided any arguments, the function returns the process mask', function test( t ) {
 	var expected = 0;
-	t.equal( typeof expected, 'number', 'returns a number' );
-	t.equal( umask(), expected, 'returns expected value' );
+	t.strictEqual( typeof expected, 'number', 'returns a number' );
+	t.strictEqual( umask(), expected, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function ignores unrecognized/unsupported options and returns the process mask', function test( t ) {
 	var expected = 0;
-	t.equal( typeof expected, 'number', 'returns a number' );
-	t.equal( umask( {} ), expected, 'returns expected value' );
+	t.strictEqual( typeof expected, 'number', 'returns a number' );
+	t.strictEqual( umask( {} ), expected, 'returns expected value' );
 	restore();
 	t.end();
 });
@@ -294,7 +294,7 @@ tape( 'the function supports returning the process mask in symbolic notation', f
 	actual = umask( opts );
 	expected = 'u=rwx,g=rwx,o=rwx';
 
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	restore();
 	t.end();
@@ -309,8 +309,8 @@ tape( 'if the `symbolic` option is `false`, the function returns the process mas
 	};
 	mask = umask( opts );
 
-	t.equal( typeof mask, 'number', 'returns a number' );
-	t.equal( mask, 0, 'returns expected value' );
+	t.strictEqual( typeof mask, 'number', 'returns a number' );
+	t.strictEqual( mask, 0, 'returns expected value' );
 
 	restore();
 	t.end();
@@ -322,8 +322,8 @@ tape( 'if provided a nonnegative integer, the function sets the process mask and
 
 	for ( i = 0; i < 100; i++ ) {
 		old = umask();
-		t.equal( umask( i ), old, 'returns previous mask' );
-		t.equal( umask(), 0, 'returns expected value' );
+		t.strictEqual( umask( i ), old, 'returns previous mask' );
+		t.strictEqual( umask(), 0, 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -339,9 +339,9 @@ tape( 'if provided a nonnegative integer and the `symbolic` option is `false`, t
 	};
 	for ( i = 100; i < 200; i++ ) {
 		old = umask( opts );
-		t.equal( typeof old, 'number', 'returns a number' );
-		t.equal( umask( i, opts ), old, 'returns previous mask' );
-		t.equal( umask( opts ), 0, 'returns expected value' );
+		t.strictEqual( typeof old, 'number', 'returns a number' );
+		t.strictEqual( umask( i, opts ), old, 'returns previous mask' );
+		t.strictEqual( umask( opts ), 0, 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -358,12 +358,12 @@ tape( 'if provided a nonnegative integer and the `symbolic` option is `true`, th
 	};
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask( opts );
-		t.equal( typeof old, 'string', 'returns a string' );
+		t.strictEqual( typeof old, 'string', 'returns a string' );
 
 		mask = umask( i, opts );
-		t.equal( mask, old, 'returns previous mask' );
+		t.strictEqual( mask, old, 'returns previous mask' );
 
-		t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+		t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -376,12 +376,12 @@ tape( 'if provided an expression mask, the function sets the process mask and re
 
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask();
-		t.equal( typeof old, 'number', 'returns a number' );
+		t.strictEqual( typeof old, 'number', 'returns a number' );
 
 		mask = INT_TO_SYMBOLIC[ i ];
-		t.equal( umask( mask ), old, 'returns previous mask' );
+		t.strictEqual( umask( mask ), old, 'returns previous mask' );
 
-		t.equal( umask(), 0, 'returns expected value' );
+		t.strictEqual( umask(), 0, 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -398,12 +398,12 @@ tape( 'if provided an expression mask and the `symbolic` option is `false`, the
 	};
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask( opts );
-		t.equal( typeof old, 'number', 'returns a number' );
+		t.strictEqual( typeof old, 'number', 'returns a number' );
 
 		mask = INT_TO_SYMBOLIC[ i ];
-		t.equal( umask( mask, opts ), old, 'returns previous mask' );
+		t.strictEqual( umask( mask, opts ), old, 'returns previous mask' );
 
-		t.equal( umask(), 0, 'returns expected value' );
+		t.strictEqual( umask(), 0, 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -421,12 +421,12 @@ tape( 'if provided an expression mask, the function supports setting the process
 
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask( opts );
-		t.equal( typeof old, 'string', 'returns a string' );
+		t.strictEqual( typeof old, 'string', 'returns a string' );
 
 		mask = INT_TO_SYMBOLIC[ i ];
-		t.equal( umask( mask, opts ), old, 'returns previous mask' );
+		t.strictEqual( umask( mask, opts ), old, 'returns previous mask' );
 
-		t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+		t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -455,11 +455,11 @@ tape( 'the function supports mask expressions containing an "all" user class', f
 	for ( i = 0; i < values.length; i++ ) {
 		// Clear all bits:
 		umask( 'u=,g=,o=' );
-		t.equal( umask(), 0, 'returns expected value' );
+		t.strictEqual( umask(), 0, 'returns expected value' );
 
 		// Enable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+		t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -488,11 +488,11 @@ tape( 'the function supports mask expressions containing an "all" user class', f
 	for ( i = 0; i < values.length; i++ ) {
 		// Set all bits:
 		umask( 'u=rwx,g=rwx,o=rwx' );
-		t.equal( umask(), 0, 'returns expected value' ); // 0 == 0o0000
+		t.strictEqual( umask(), 0, 'returns expected value' ); // 0 == 0o0000
 
 		// Disable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+		t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -521,11 +521,11 @@ tape( 'the function supports mask expressions without a user class', function te
 	for ( i = 0; i < values.length; i++ ) {
 		// Clear all bits:
 		umask( 'u=,g=,o=' );
-		t.equal( umask(), 0, 'returns expected value' );
+		t.strictEqual( umask(), 0, 'returns expected value' );
 
 		// Enable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+		t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -554,11 +554,11 @@ tape( 'the function supports mask expressions specifying a user class', function
 	for ( i = 0; i < values.length; i++ ) {
 		// Set all bits:
 		umask( 'u=rwx,g=rwx,o=rwx' );
-		t.equal( umask(), 0, 'returns expected value' ); // 0 == 0o0000
+		t.strictEqual( umask(), 0, 'returns expected value' ); // 0 == 0o0000
 
 		// Disable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+		t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -587,11 +587,11 @@ tape( 'the function supports providing a mask expression enabling permissions fo
 	for ( i = 0; i < values.length; i++ ) {
 		// Clear all bits:
 		umask( 'u=,g=,o=' );
-		t.equal( umask(), 0, 'returns expected value' );
+		t.strictEqual( umask(), 0, 'returns expected value' );
 
 		// Enable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+		t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -620,11 +620,11 @@ tape( 'the function supports providing a mask expression enabling permissions fo
 	for ( i = 0; i < values.length; i++ ) {
 		// Clear all bits:
 		umask( 'u=,g=,o=' );
-		t.equal( umask(), 0, 'returns expected value' );
+		t.strictEqual( umask(), 0, 'returns expected value' );
 
 		// Enable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+		t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -653,11 +653,11 @@ tape( 'the function supports providing a mask expression enabling permissions fo
 	for ( i = 0; i < values.length; i++ ) {
 		// Clear all bits:
 		umask( 'u=,g=,o=' );
-		t.equal( umask(), 0, 'returns expected value' );
+		t.strictEqual( umask(), 0, 'returns expected value' );
 
 		// Enable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+		t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -686,11 +686,11 @@ tape( 'the function supports providing a mask expression disabling permissions f
 	for ( i = 0; i < values.length; i++ ) {
 		// Set all bits:
 		umask( 'u=rwx,g=rwx,o=rwx' );
-		t.equal( umask(), 0, 'returns expected value' ); // 0 == 0o0000
+		t.strictEqual( umask(), 0, 'returns expected value' ); // 0 == 0o0000
 
 		// Disable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+		t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -719,11 +719,11 @@ tape( 'the function supports providing a mask expression disabling permissions f
 	for ( i = 0; i < values.length; i++ ) {
 		// Set all bits:
 		umask( 'u=rwx,g=rwx,o=rwx' );
-		t.equal( umask(), 0, 'returns expected value' ); // 0 == 0o0000
+		t.strictEqual( umask(), 0, 'returns expected value' ); // 0 == 0o0000
 
 		// Disable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+		t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -752,11 +752,11 @@ tape( 'the function supports providing a mask expression disabling permissions f
 	for ( i = 0; i < values.length; i++ ) {
 		// Set all bits:
 		umask( 'u=rwx,g=rwx,o=rwx' );
-		t.equal( umask(), 0, 'returns expected value' ); // 0 == 0o0000
+		t.strictEqual( umask(), 0, 'returns expected value' ); // 0 == 0o0000
 
 		// Disable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+		t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -768,16 +768,16 @@ tape( 'while not encouraged, the function allows for providing mask expressions
 	};
 
 	umask( 'a-rwx,u+r,g+w,o+x' );
-	t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+	t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 
 	umask( 'a+rwx,u-r,g-w,o-x' );
-	t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+	t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 
 	umask( 'ugo=rwx,a=w' );
-	t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+	t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 
 	umask( 'a=rwx,u=r,g=rw,o=x' );
-	t.equal( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
+	t.strictEqual( umask( opts ), 'u=rwx,g=rwx,o=rwx', 'returns expected value' );
 
 	restore();
 	t.end();
diff --git a/lib/node_modules/@stdlib/process/umask/test/test.js b/lib/node_modules/@stdlib/process/umask/test/test.js
index 0625dffac57e..79594aed5f6c 100644
--- a/lib/node_modules/@stdlib/process/umask/test/test.js
+++ b/lib/node_modules/@stdlib/process/umask/test/test.js
@@ -297,15 +297,15 @@ tape( 'if provided an expression mask, the function throws an error if unable to
 
 tape( 'if not provided any arguments, the function returns the process mask', opts, function test( t ) {
 	var expected = proc.umask();
-	t.equal( typeof expected, 'number', 'returns a number' );
-	t.equal( umask(), expected, 'returns expected value' );
+	t.strictEqual( typeof expected, 'number', 'returns a number' );
+	t.strictEqual( umask(), expected, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function ignores unrecognized/unsupported options and returns the process mask', opts, function test( t ) {
 	var expected = proc.umask();
-	t.equal( typeof expected, 'number', 'returns a number' );
-	t.equal( umask( {} ), expected, 'returns expected value' );
+	t.strictEqual( typeof expected, 'number', 'returns a number' );
+	t.strictEqual( umask( {} ), expected, 'returns expected value' );
 	restore();
 	t.end();
 });
@@ -324,7 +324,7 @@ tape( 'the function supports returning the process mask in symbolic notation', o
 	actual = umask( opts );
 	expected = INT_TO_SYMBOLIC[ mask ];
 
-	t.equal( actual, expected, 'returns expected value' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	restore();
 	t.end();
@@ -339,8 +339,8 @@ tape( 'if the `symbolic` option is `false`, the function returns the process mas
 	};
 	mask = umask( opts );
 
-	t.equal( typeof mask, 'number', 'returns a number' );
-	t.equal( mask, proc.umask(), 'returns expected value' );
+	t.strictEqual( typeof mask, 'number', 'returns a number' );
+	t.strictEqual( mask, proc.umask(), 'returns expected value' );
 
 	restore();
 	t.end();
@@ -352,8 +352,8 @@ tape( 'if provided a nonnegative integer, the function sets the process mask and
 
 	for ( i = 0; i < 100; i++ ) {
 		old = umask();
-		t.equal( umask( i ), old, 'returns previous mask' );
-		t.equal( umask(), i, 'returns expected value' );
+		t.strictEqual( umask( i ), old, 'returns previous mask' );
+		t.strictEqual( umask(), i, 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -369,9 +369,9 @@ tape( 'if provided a nonnegative integer and the `symbolic` option is `false`, t
 	};
 	for ( i = 100; i < 200; i++ ) {
 		old = umask( opts );
-		t.equal( typeof old, 'number', 'returns a number' );
-		t.equal( umask( i, opts ), old, 'returns previous mask' );
-		t.equal( umask( opts ), i, 'returns expected value' );
+		t.strictEqual( typeof old, 'number', 'returns a number' );
+		t.strictEqual( umask( i, opts ), old, 'returns previous mask' );
+		t.strictEqual( umask( opts ), i, 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -388,12 +388,12 @@ tape( 'if provided a nonnegative integer and the `symbolic` option is `true`, th
 	};
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask( opts );
-		t.equal( typeof old, 'string', 'returns a string' );
+		t.strictEqual( typeof old, 'string', 'returns a string' );
 
 		mask = umask( i, opts );
-		t.equal( mask, old, 'returns previous mask' );
+		t.strictEqual( mask, old, 'returns previous mask' );
 
-		t.equal( umask( opts ), INT_TO_SYMBOLIC[ i ], 'returns expected value' );
+		t.strictEqual( umask( opts ), INT_TO_SYMBOLIC[ i ], 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -406,12 +406,12 @@ tape( 'if provided an expression mask, the function sets the process mask and re
 
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask();
-		t.equal( typeof old, 'number', 'returns a number' );
+		t.strictEqual( typeof old, 'number', 'returns a number' );
 
 		mask = INT_TO_SYMBOLIC[ i ];
-		t.equal( umask( mask ), old, 'returns previous mask' );
+		t.strictEqual( umask( mask ), old, 'returns previous mask' );
 
-		t.equal( umask(), SYMBOLIC_TO_INT[ mask ], 'returns expected value' );
+		t.strictEqual( umask(), SYMBOLIC_TO_INT[ mask ], 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -428,12 +428,12 @@ tape( 'if provided an expression mask and the `symbolic` option is `false`, the
 	};
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask( opts );
-		t.equal( typeof old, 'number', 'returns a number' );
+		t.strictEqual( typeof old, 'number', 'returns a number' );
 
 		mask = INT_TO_SYMBOLIC[ i ];
-		t.equal( umask( mask, opts ), old, 'returns previous mask' );
+		t.strictEqual( umask( mask, opts ), old, 'returns previous mask' );
 
-		t.equal( umask(), SYMBOLIC_TO_INT[ mask ], 'returns expected value' );
+		t.strictEqual( umask(), SYMBOLIC_TO_INT[ mask ], 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -451,12 +451,12 @@ tape( 'if provided an expression mask, the function supports setting the process
 
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask( opts );
-		t.equal( typeof old, 'string', 'returns a string' );
+		t.strictEqual( typeof old, 'string', 'returns a string' );
 
 		mask = INT_TO_SYMBOLIC[ i ];
-		t.equal( umask( mask, opts ), old, 'returns previous mask' );
+		t.strictEqual( umask( mask, opts ), old, 'returns previous mask' );
 
-		t.equal( umask( opts ), mask, 'returns expected value' );
+		t.strictEqual( umask( opts ), mask, 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -496,11 +496,11 @@ tape( 'the function supports enabling permissions using the "all" user class', o
 	for ( i = 0; i < values.length; i++ ) {
 		// Clear all bits:
 		umask( 'u=,g=,o=' );
-		t.equal( umask(), 511, 'returns expected value' ); // 511 == 0o0777
+		t.strictEqual( umask(), 511, 'returns expected value' ); // 511 == 0o0777
 
 		// Enable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), expected[ i ], 'returns expected value' );
+		t.strictEqual( umask( opts ), expected[ i ], 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -540,11 +540,11 @@ tape( 'the function supports disabling permissions using the "all" user class',
 	for ( i = 0; i < values.length; i++ ) {
 		// Set all bits:
 		umask( 'u=rwx,g=rwx,o=rwx' );
-		t.equal( umask(), 0, 'returns expected value' ); // 0 == 0o0000
+		t.strictEqual( umask(), 0, 'returns expected value' ); // 0 == 0o0000
 
 		// Disable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), expected[ i ], 'returns expected value' );
+		t.strictEqual( umask( opts ), expected[ i ], 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -584,11 +584,11 @@ tape( 'the function supports enabling permissions without specifying a user clas
 	for ( i = 0; i < values.length; i++ ) {
 		// Clear all bits:
 		umask( 'u=,g=,o=' );
-		t.equal( umask(), 511, 'returns expected value' ); // 511 == 0o0777
+		t.strictEqual( umask(), 511, 'returns expected value' ); // 511 == 0o0777
 
 		// Enable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), expected[ i ], 'returns expected value' );
+		t.strictEqual( umask( opts ), expected[ i ], 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -628,11 +628,11 @@ tape( 'the function supports disabling permissions without specifying a user cla
 	for ( i = 0; i < values.length; i++ ) {
 		// Set all bits:
 		umask( 'u=rwx,g=rwx,o=rwx' );
-		t.equal( umask(), 0, 'returns expected value' ); // 0 == 0o0000
+		t.strictEqual( umask(), 0, 'returns expected value' ); // 0 == 0o0000
 
 		// Disable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), expected[ i ], 'returns expected value' );
+		t.strictEqual( umask( opts ), expected[ i ], 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -672,11 +672,11 @@ tape( 'the function supports enabling permissions for the "user" user class', op
 	for ( i = 0; i < values.length; i++ ) {
 		// Clear all bits:
 		umask( 'u=,g=,o=' );
-		t.equal( umask(), 511, 'returns expected value' ); // 511 == 0o0777
+		t.strictEqual( umask(), 511, 'returns expected value' ); // 511 == 0o0777
 
 		// Enable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), expected[ i ], 'returns expected value' );
+		t.strictEqual( umask( opts ), expected[ i ], 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -716,11 +716,11 @@ tape( 'the function supports enabling permissions for the "group" user class', o
 	for ( i = 0; i < values.length; i++ ) {
 		// Clear all bits:
 		umask( 'u=,g=,o=' );
-		t.equal( umask(), 511, 'returns expected value' ); // 511 == 0o0777
+		t.strictEqual( umask(), 511, 'returns expected value' ); // 511 == 0o0777
 
 		// Enable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), expected[ i ], 'returns expected value' );
+		t.strictEqual( umask( opts ), expected[ i ], 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -760,11 +760,11 @@ tape( 'the function supports enabling permissions for the "non-group" user class
 	for ( i = 0; i < values.length; i++ ) {
 		// Clear all bits:
 		umask( 'u=,g=,o=' );
-		t.equal( umask(), 511, 'returns expected value' ); // 511 == 0o0777
+		t.strictEqual( umask(), 511, 'returns expected value' ); // 511 == 0o0777
 
 		// Enable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), expected[ i ], 'returns expected value' );
+		t.strictEqual( umask( opts ), expected[ i ], 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -804,11 +804,11 @@ tape( 'the function supports disabling permissions for the "user" user class', o
 	for ( i = 0; i < values.length; i++ ) {
 		// Set all bits:
 		umask( 'u=rwx,g=rwx,o=rwx' );
-		t.equal( umask(), 0, 'returns expected value' ); // 0 == 0o0000
+		t.strictEqual( umask(), 0, 'returns expected value' ); // 0 == 0o0000
 
 		// Disable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), expected[ i ], 'returns expected value' );
+		t.strictEqual( umask( opts ), expected[ i ], 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -848,11 +848,11 @@ tape( 'the function supports disabling permissions for the "group" user class',
 	for ( i = 0; i < values.length; i++ ) {
 		// Set all bits:
 		umask( 'u=rwx,g=rwx,o=rwx' );
-		t.equal( umask(), 0, 'returns expected value' ); // 0 == 0o0000
+		t.strictEqual( umask(), 0, 'returns expected value' ); // 0 == 0o0000
 
 		// Disable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), expected[ i ], 'returns expected value' );
+		t.strictEqual( umask( opts ), expected[ i ], 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -892,11 +892,11 @@ tape( 'the function supports disabling permissions for the "non-group" user clas
 	for ( i = 0; i < values.length; i++ ) {
 		// Set all bits:
 		umask( 'u=rwx,g=rwx,o=rwx' );
-		t.equal( umask(), 0, 'returns expected value' ); // 0 == 0o0000
+		t.strictEqual( umask(), 0, 'returns expected value' ); // 0 == 0o0000
 
 		// Disable permissions:
 		umask( values[ i ] );
-		t.equal( umask( opts ), expected[ i ], 'returns expected value' );
+		t.strictEqual( umask( opts ), expected[ i ], 'returns expected value' );
 	}
 	restore();
 	t.end();
@@ -908,16 +908,16 @@ tape( 'while not encouraged, the function allows for overriding permission setti
 	};
 
 	umask( 'a-rwx,u+r,g+w,o+x' );
-	t.equal( umask( opts ), 'u=r,g=w,o=x', 'returns expected value' );
+	t.strictEqual( umask( opts ), 'u=r,g=w,o=x', 'returns expected value' );
 
 	umask( 'a+rwx,u-r,g-w,o-x' );
-	t.equal( umask( opts ), 'u=wx,g=rx,o=rw', 'returns expected value' );
+	t.strictEqual( umask( opts ), 'u=wx,g=rx,o=rw', 'returns expected value' );
 
 	umask( 'ugo=rwx,a=w' );
-	t.equal( umask( opts ), 'u=w,g=w,o=w', 'returns expected value' );
+	t.strictEqual( umask( opts ), 'u=w,g=w,o=w', 'returns expected value' );
 
 	umask( 'a=rwx,u=r,g=rw,o=x' );
-	t.equal( umask( opts ), 'u=r,g=rw,o=x', 'returns expected value' );
+	t.strictEqual( umask( opts ), 'u=r,g=rw,o=x', 'returns expected value' );
 
 	restore();
 	t.end();
diff --git a/lib/node_modules/@stdlib/regexp/basename-posix/test/test.js b/lib/node_modules/@stdlib/regexp/basename-posix/test/test.js
index de7dc0de3b7a..6688be3c75f6 100644
--- a/lib/node_modules/@stdlib/regexp/basename-posix/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/basename-posix/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reBasenamePosix.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reBasenamePosix.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/basename-windows/test/test.js b/lib/node_modules/@stdlib/regexp/basename-windows/test/test.js
index 144074424dfa..fdd4b9bac22b 100644
--- a/lib/node_modules/@stdlib/regexp/basename-windows/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/basename-windows/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reBasenameWindows.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reBasenameWindows.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/decimal-number/test/test.js b/lib/node_modules/@stdlib/regexp/decimal-number/test/test.js
index 11b428c60a2a..cd61ed168aa8 100644
--- a/lib/node_modules/@stdlib/regexp/decimal-number/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/decimal-number/test/test.js
@@ -34,11 +34,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reDecimalNumber.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reDecimalNumber.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
 
 tape( 'attached to the main export is a regular expression (capture group)', function test( t ) {
-	t.equal( isRegExp( reDecimalNumber.REGEXP_CAPTURE ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reDecimalNumber.REGEXP_CAPTURE ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/dirname-posix/test/test.js b/lib/node_modules/@stdlib/regexp/dirname-posix/test/test.js
index 7d5eac294f19..4f00b84b48e8 100644
--- a/lib/node_modules/@stdlib/regexp/dirname-posix/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/dirname-posix/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reDirnamePosix.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reDirnamePosix.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/dirname-posix/test/test.main.js b/lib/node_modules/@stdlib/regexp/dirname-posix/test/test.main.js
index 5fcb478129fd..9d71cb279398 100644
--- a/lib/node_modules/@stdlib/regexp/dirname-posix/test/test.main.js
+++ b/lib/node_modules/@stdlib/regexp/dirname-posix/test/test.main.js
@@ -81,7 +81,7 @@ tape( 'the function returns a regular expression that captures POSIX path dirnam
 
 	for ( i = 0; i < values.length; i++ ) {
 		dir = RE.exec( values[ i ] )[ 1 ];
-		t.equal( dir, expected[ i ], values[ i ] );
+		t.strictEqual( dir, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/dirname-posix/test/test.regexp.js b/lib/node_modules/@stdlib/regexp/dirname-posix/test/test.regexp.js
index 86ba6c8db89a..408fb7bda67c 100644
--- a/lib/node_modules/@stdlib/regexp/dirname-posix/test/test.regexp.js
+++ b/lib/node_modules/@stdlib/regexp/dirname-posix/test/test.regexp.js
@@ -28,7 +28,7 @@ var RE = require( './../lib/regexp.js' );
 
 tape( 'main export is a regular expression', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( RE instanceof RegExp, true, 'main export is a regular expression' );
+	t.strictEqual( RE instanceof RegExp, true, 'main export is a regular expression' );
 	t.end();
 });
 
@@ -78,7 +78,7 @@ tape( 'the regular expression captures POSIX path dirnames', function test( t )
 
 	for ( i = 0; i < values.length; i++ ) {
 		dir = RE.exec( values[ i ] )[ 1 ];
-		t.equal( dir, expected[ i ], values[ i ] );
+		t.strictEqual( dir, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/dirname-windows/test/test.js b/lib/node_modules/@stdlib/regexp/dirname-windows/test/test.js
index 992c2002d419..01a92e604e20 100644
--- a/lib/node_modules/@stdlib/regexp/dirname-windows/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/dirname-windows/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reDirnameWindows.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reDirnameWindows.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/dirname-windows/test/test.main.js b/lib/node_modules/@stdlib/regexp/dirname-windows/test/test.main.js
index b59374b388e3..8c6986e568e3 100644
--- a/lib/node_modules/@stdlib/regexp/dirname-windows/test/test.main.js
+++ b/lib/node_modules/@stdlib/regexp/dirname-windows/test/test.main.js
@@ -73,7 +73,7 @@ tape( 'the function returns a regular expression captures Windows path dirnames'
 
 	for ( i = 0; i < values.length; i++ ) {
 		dir = RE.exec( values[ i ] )[ 1 ];
-		t.equal( dir, expected[ i ], values[ i ] );
+		t.strictEqual( dir, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/dirname-windows/test/test.regexp.js b/lib/node_modules/@stdlib/regexp/dirname-windows/test/test.regexp.js
index b006aad72c6a..515ecbb85476 100644
--- a/lib/node_modules/@stdlib/regexp/dirname-windows/test/test.regexp.js
+++ b/lib/node_modules/@stdlib/regexp/dirname-windows/test/test.regexp.js
@@ -28,7 +28,7 @@ var RE = require( './../lib/regexp.js' );
 
 tape( 'main export is a regular expression', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( RE instanceof RegExp, true, 'main export is a regular expression' );
+	t.strictEqual( RE instanceof RegExp, true, 'main export is a regular expression' );
 	t.end();
 });
 
@@ -70,7 +70,7 @@ tape( 'the regular expression captures Windows path dirnames', function test( t
 
 	for ( i = 0; i < values.length; i++ ) {
 		dir = RE.exec( values[ i ] )[ 1 ];
-		t.equal( dir, expected[ i ], values[ i ] );
+		t.strictEqual( dir, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/dirname/test/test.js b/lib/node_modules/@stdlib/regexp/dirname/test/test.js
index eccb21760ad1..b3efbcc25e56 100644
--- a/lib/node_modules/@stdlib/regexp/dirname/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/dirname/test/test.js
@@ -61,7 +61,7 @@ tape( 'the `REGEXP` property is a POSIX specific regular expression if on a POSI
 		'./main.js': function noop() {}
 	});
 
-	t.equal( main.REGEXP.toString(), main.REGEXP_POSIX.toString(), '`REGEXP` property  is `posix` regexp: '+main.REGEXP.toString() );
+	t.strictEqual( main.REGEXP.toString(), main.REGEXP_POSIX.toString(), '`REGEXP` property  is `posix` regexp: '+main.REGEXP.toString() );
 	t.end();
 });
 
@@ -73,7 +73,7 @@ tape( 'the `REGEXP` property is a Windows specific regular expression if on a Wi
 		'./main.js': function noop() {}
 	});
 
-	t.equal( main.REGEXP.toString(), main.REGEXP_WIN32.toString(), '`REGEXP` property  is `win32` regexp: '+main.REGEXP.toString() );
+	t.strictEqual( main.REGEXP.toString(), main.REGEXP_WIN32.toString(), '`REGEXP` property  is `win32` regexp: '+main.REGEXP.toString() );
 	t.end();
 });
 
@@ -95,7 +95,7 @@ tape( 'the `REGEXP_POSIX` regular expression captures POSIX path dirnames', func
 
 	for ( i = 0; i < values.length; i++ ) {
 		dir = reDirname.REGEXP_POSIX.exec( values[ i ] )[ 1 ];
-		t.equal( dir, expected[ i ], values[ i ] );
+		t.strictEqual( dir, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the `REGEXP_WIN32` regular expression captures Windows path dirnames', fu
 
 	for ( i = 0; i < values.length; i++ ) {
 		dir = reDirname.REGEXP_WIN32.exec( values[ i ] )[ 1 ];
-		t.equal( dir, expected[ i ], values[ i ] );
+		t.strictEqual( dir, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/duration-string/test/test.js b/lib/node_modules/@stdlib/regexp/duration-string/test/test.js
index 2794d502aaa5..de70e49101c0 100644
--- a/lib/node_modules/@stdlib/regexp/duration-string/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/duration-string/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reDurationString.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reDurationString.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/duration-string/test/test.main.js b/lib/node_modules/@stdlib/regexp/duration-string/test/test.main.js
index c4cc8fcb65e0..bd8865632caf 100644
--- a/lib/node_modules/@stdlib/regexp/duration-string/test/test.main.js
+++ b/lib/node_modules/@stdlib/regexp/duration-string/test/test.main.js
@@ -67,14 +67,14 @@ tape( 'the returned regular expression matches a duration string', function test
 		'3D4H5M6S7MS'
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[i] ), true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( RE.test( values[i] ), true, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
 
 tape( 'the returned regular expression matches an empty string', function test( t ) {
 	var RE = reDurationString();
-	t.equal( RE.test( '' ), true, 'returns expected value' );
+	t.strictEqual( RE.test( '' ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -94,7 +94,7 @@ tape( 'the returned regular expression does not match a non-duration string', fu
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[i] ), false, 'returns expected value when provided '+values[i] );
+		t.strictEqual( RE.test( values[i] ), false, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/duration-string/test/test.regexp.js b/lib/node_modules/@stdlib/regexp/duration-string/test/test.regexp.js
index b4513315fd02..1a6f0e8d1294 100644
--- a/lib/node_modules/@stdlib/regexp/duration-string/test/test.regexp.js
+++ b/lib/node_modules/@stdlib/regexp/duration-string/test/test.regexp.js
@@ -28,7 +28,7 @@ var RE = require( './../lib/regexp.js' );
 
 tape( 'main export is a regular expression', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( RE instanceof RegExp, true, 'main export is a regular expression' );
+	t.strictEqual( RE instanceof RegExp, true, 'main export is a regular expression' );
 	t.end();
 });
 
@@ -66,13 +66,13 @@ tape( 'the regular expression matches valid duration strings', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[i] ), true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( RE.test( values[i] ), true, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
 
 tape( 'the regular expression matches an empty string', function test( t ) {
-	t.equal( RE.test( '' ), true, 'returns expected value' );
+	t.strictEqual( RE.test( '' ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -90,7 +90,7 @@ tape( 'the regular expression does not match invalid duration strings', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[i] ), false, 'returns expected value when provided '+values[i] );
+		t.strictEqual( RE.test( values[i] ), false, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/eol/test/test.js b/lib/node_modules/@stdlib/regexp/eol/test/test.js
index 2f43df25a789..f292dfe18f74 100644
--- a/lib/node_modules/@stdlib/regexp/eol/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/eol/test/test.js
@@ -34,11 +34,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reEOL.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reEOL.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
 
 tape( 'attached to the main export is a regular expression (capture group)', function test( t ) {
-	t.equal( isRegExp( reEOL.REGEXP_CAPTURE ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reEOL.REGEXP_CAPTURE ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/eol/test/test.regexp.js b/lib/node_modules/@stdlib/regexp/eol/test/test.regexp.js
index 4d79fe610268..305343dbb226 100644
--- a/lib/node_modules/@stdlib/regexp/eol/test/test.regexp.js
+++ b/lib/node_modules/@stdlib/regexp/eol/test/test.regexp.js
@@ -28,7 +28,7 @@ var RE = require( './../lib/regexp.js' );
 
 tape( 'main export is a regular expression', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( RE instanceof RegExp, true, 'main export is a regular expression' );
+	t.strictEqual( RE instanceof RegExp, true, 'main export is a regular expression' );
 	t.end();
 });
 
@@ -42,7 +42,7 @@ tape( 'the regular expression matches newline character sequences', function tes
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[ i ] ), true, 'matches when provided '+values[i] );
+		t.strictEqual( RE.test( values[ i ] ), true, 'matches when provided '+values[i] );
 	}
 	t.end();
 });
@@ -58,7 +58,7 @@ tape( 'the regular expression does not match escaped sequences or non-matching s
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[ i ] ), false, 'does not match when provided '+values[i] );
+		t.strictEqual( RE.test( values[ i ] ), false, 'does not match when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/extended-length-path/test/test.js b/lib/node_modules/@stdlib/regexp/extended-length-path/test/test.js
index 2e059dc66b09..285a5e28e9fd 100644
--- a/lib/node_modules/@stdlib/regexp/extended-length-path/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/extended-length-path/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reExtendedLengthPath.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reExtendedLengthPath.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/extname-posix/test/test.js b/lib/node_modules/@stdlib/regexp/extname-posix/test/test.js
index 7472dbdf0223..a2728a808282 100644
--- a/lib/node_modules/@stdlib/regexp/extname-posix/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/extname-posix/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reExtnamePosix.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reExtnamePosix.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/extname-posix/test/test.main.js b/lib/node_modules/@stdlib/regexp/extname-posix/test/test.main.js
index 037f2ff9ab97..e80e36372ff8 100644
--- a/lib/node_modules/@stdlib/regexp/extname-posix/test/test.main.js
+++ b/lib/node_modules/@stdlib/regexp/extname-posix/test/test.main.js
@@ -67,7 +67,7 @@ tape( 'the function returns a regular expression that captures POSIX filename ex
 
 	for ( i = 0; i < values.length; i++ ) {
 		ext = RE.exec( values[ i ] )[ 1 ];
-		t.equal( ext, expected[ i ], values[ i ] );
+		t.strictEqual( ext, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -93,7 +93,7 @@ tape( 'the function returns a regular expression that does not capture anything
 
 	for ( i = 0; i < values.length; i++ ) {
 		ext = RE.exec( values[ i ] )[ 1 ];
-		t.equal( ext, '', values[ i ] );
+		t.strictEqual( ext, '', values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/extname-posix/test/test.regexp.js b/lib/node_modules/@stdlib/regexp/extname-posix/test/test.regexp.js
index de4fc3b56ba9..875b3b309d15 100644
--- a/lib/node_modules/@stdlib/regexp/extname-posix/test/test.regexp.js
+++ b/lib/node_modules/@stdlib/regexp/extname-posix/test/test.regexp.js
@@ -28,7 +28,7 @@ var RE = require( './../lib/regexp.js' );
 
 tape( 'main export is a regular expression', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( RE instanceof RegExp, true, 'main export is a regular expression' );
+	t.strictEqual( RE instanceof RegExp, true, 'main export is a regular expression' );
 	t.end();
 });
 
@@ -64,7 +64,7 @@ tape( 'the regular expression captures POSIX filename extensions', function test
 
 	for ( i = 0; i < values.length; i++ ) {
 		ext = RE.exec( values[ i ] )[ 1 ];
-		t.equal( ext, expected[ i ], values[ i ] );
+		t.strictEqual( ext, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'the regular expression does not capture anything if provided a path not h
 
 	for ( i = 0; i < values.length; i++ ) {
 		ext = RE.exec( values[ i ] )[ 1 ];
-		t.equal( ext, '', values[ i ] );
+		t.strictEqual( ext, '', values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/extname-windows/test/test.js b/lib/node_modules/@stdlib/regexp/extname-windows/test/test.js
index d4f3aed0387f..80aaa608cd3b 100644
--- a/lib/node_modules/@stdlib/regexp/extname-windows/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/extname-windows/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reExtnameWindows.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reExtnameWindows.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/extname-windows/test/test.main.js b/lib/node_modules/@stdlib/regexp/extname-windows/test/test.main.js
index 8024852ea0eb..abf66cb1ee0e 100644
--- a/lib/node_modules/@stdlib/regexp/extname-windows/test/test.main.js
+++ b/lib/node_modules/@stdlib/regexp/extname-windows/test/test.main.js
@@ -69,7 +69,7 @@ tape( 'the function returns a regular expression that captures Windows filename
 
 	for ( i = 0; i < values.length; i++ ) {
 		ext = RE.exec( values[ i ] )[ 1 ];
-		t.equal( ext, expected[ i ], values[ i ] );
+		t.strictEqual( ext, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function returns a regular expression that does not capture anything
 
 	for ( i = 0; i < values.length; i++ ) {
 		ext = RE.exec( values[ i ] )[ 1 ];
-		t.equal( ext, '', values[ i ] );
+		t.strictEqual( ext, '', values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/extname-windows/test/test.regexp.js b/lib/node_modules/@stdlib/regexp/extname-windows/test/test.regexp.js
index 4c81bc9e2474..5fd7dcb44d0a 100644
--- a/lib/node_modules/@stdlib/regexp/extname-windows/test/test.regexp.js
+++ b/lib/node_modules/@stdlib/regexp/extname-windows/test/test.regexp.js
@@ -28,7 +28,7 @@ var RE = require( './../lib/regexp.js' );
 
 tape( 'main export is a regular expression', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( RE instanceof RegExp, true, 'main export is a regular expression' );
+	t.strictEqual( RE instanceof RegExp, true, 'main export is a regular expression' );
 	t.end();
 });
 
@@ -66,7 +66,7 @@ tape( 'the regular expression captures Windows filename extensions', function te
 
 	for ( i = 0; i < values.length; i++ ) {
 		ext = RE.exec( values[ i ] )[ 1 ];
-		t.equal( ext, expected[ i ], values[ i ] );
+		t.strictEqual( ext, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the regular expression does not capture anything if provided a path not h
 
 	for ( i = 0; i < values.length; i++ ) {
 		ext = RE.exec( values[ i ] )[ 1 ];
-		t.equal( ext, '', values[ i ] );
+		t.strictEqual( ext, '', values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/extname/test/test.js b/lib/node_modules/@stdlib/regexp/extname/test/test.js
index 8190f975aedf..9ce17d052850 100644
--- a/lib/node_modules/@stdlib/regexp/extname/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/extname/test/test.js
@@ -61,7 +61,7 @@ tape( 'the `REGEXP` property is a POSIX specific regular expression if on a POSI
 		'./main.js': function noop() {}
 	});
 
-	t.equal( main.REGEXP.toString(), main.REGEXP_POSIX.toString(), 'main export is `posix` regexp: '+main.REGEXP.toString() );
+	t.strictEqual( main.REGEXP.toString(), main.REGEXP_POSIX.toString(), 'main export is `posix` regexp: '+main.REGEXP.toString() );
 	t.end();
 });
 
@@ -73,7 +73,7 @@ tape( 'the `REGEXP` property is a Windows specific regular expression if on a Wi
 		'./main.js': function noop() {}
 	});
 
-	t.equal( main.REGEXP.toString(), main.REGEXP_WIN32.toString(), 'main export is `win32` regexp: '+main.REGEXP.toString() );
+	t.strictEqual( main.REGEXP.toString(), main.REGEXP_WIN32.toString(), 'main export is `win32` regexp: '+main.REGEXP.toString() );
 	t.end();
 });
 
@@ -95,7 +95,7 @@ tape( 'the `REGEXP_POSIX` regular expression captures POSIX filename extensions'
 
 	for ( i = 0; i < values.length; i++ ) {
 		ext = reExtname.REGEXP_POSIX.exec( values[ i ] )[ 1 ];
-		t.equal( ext, expected[ i ], values[ i ] );
+		t.strictEqual( ext, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -118,7 +118,7 @@ tape( 'the `REGEXP_WIN32` regular expression captures Windows filename extension
 
 	for ( i = 0; i < values.length; i++ ) {
 		ext = reExtname.REGEXP_WIN32.exec( values[ i ] )[ 1 ];
-		t.equal( ext, expected[ i ], values[ i ] );
+		t.strictEqual( ext, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/filename-posix/test/test.js b/lib/node_modules/@stdlib/regexp/filename-posix/test/test.js
index 711c7125fcc1..f977d0a53e4f 100644
--- a/lib/node_modules/@stdlib/regexp/filename-posix/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/filename-posix/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reFilenamePosix.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reFilenamePosix.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/filename-windows/test/test.js b/lib/node_modules/@stdlib/regexp/filename-windows/test/test.js
index 32136276722c..cd4f64e0577e 100644
--- a/lib/node_modules/@stdlib/regexp/filename-windows/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/filename-windows/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reFilenameWindows.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reFilenameWindows.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/function-name/test/test.js b/lib/node_modules/@stdlib/regexp/function-name/test/test.js
index a0416c4d4f52..66dcf6f2f169 100644
--- a/lib/node_modules/@stdlib/regexp/function-name/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/function-name/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reFunctionName.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reFunctionName.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/function-name/test/test.main.js b/lib/node_modules/@stdlib/regexp/function-name/test/test.main.js
index 692699cdad61..893fb6de99a4 100644
--- a/lib/node_modules/@stdlib/regexp/function-name/test/test.main.js
+++ b/lib/node_modules/@stdlib/regexp/function-name/test/test.main.js
@@ -39,7 +39,7 @@ tape( 'the returned regular expression captures a function name', function test(
 	function beep() {
 		return 'boop';
 	}
-	t.equal( RE.exec( beep.toString() )[ 1 ], 'beep', 'captures function name' );
+	t.strictEqual( RE.exec( beep.toString() )[ 1 ], 'beep', 'captures function name' );
 	t.end();
 });
 
@@ -48,6 +48,6 @@ tape( 'if a function is anonymous, the returned regular expression captures noth
 		return 'boop';
 	};
 	var RE = reFunctionName();
-	t.equal( RE.exec( beep.toString() )[ 1 ], '', 'captures nothing' );
+	t.strictEqual( RE.exec( beep.toString() )[ 1 ], '', 'captures nothing' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/function-name/test/test.regexp.js b/lib/node_modules/@stdlib/regexp/function-name/test/test.regexp.js
index bcc6bea423c7..7868e13ea657 100644
--- a/lib/node_modules/@stdlib/regexp/function-name/test/test.regexp.js
+++ b/lib/node_modules/@stdlib/regexp/function-name/test/test.regexp.js
@@ -30,7 +30,7 @@ var RE = require( './../lib/regexp.js' );
 
 tape( 'main export is a regular expression', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( RE instanceof RegExp, true, 'main export is a regular expression' );
+	t.strictEqual( RE instanceof RegExp, true, 'main export is a regular expression' );
 	t.end();
 });
 
@@ -38,7 +38,7 @@ tape( 'the regular expression captures a function name', function test( t ) {
 	function beep() {
 		return 'boop';
 	}
-	t.equal( RE.exec( beep.toString() )[ 1 ], 'beep', 'captures function name' );
+	t.strictEqual( RE.exec( beep.toString() )[ 1 ], 'beep', 'captures function name' );
 	t.end();
 });
 
@@ -46,6 +46,6 @@ tape( 'if a function is anonymous, the regular expression captures nothing', fun
 	var beep = function () {
 		return 'boop';
 	};
-	t.equal( RE.exec( beep.toString() )[ 1 ], '', 'captures nothing' );
+	t.strictEqual( RE.exec( beep.toString() )[ 1 ], '', 'captures nothing' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/native-function/test/test.js b/lib/node_modules/@stdlib/regexp/native-function/test/test.js
index f3bd745767fc..59ee9029298b 100644
--- a/lib/node_modules/@stdlib/regexp/native-function/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/native-function/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reNativeFunction.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reNativeFunction.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/regexp/test/test.js b/lib/node_modules/@stdlib/regexp/regexp/test/test.js
index 0b1fff646864..5413039661ae 100644
--- a/lib/node_modules/@stdlib/regexp/regexp/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/regexp/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reRegExp.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reRegExp.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/regexp/test/test.main.js b/lib/node_modules/@stdlib/regexp/regexp/test/test.main.js
index ce1f8ee5f4fa..0d14af1cdaa1 100644
--- a/lib/node_modules/@stdlib/regexp/regexp/test/test.main.js
+++ b/lib/node_modules/@stdlib/regexp/regexp/test/test.main.js
@@ -52,7 +52,7 @@ tape( 'the function returns a regular expression that detects a regular expressi
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[i] ), true, values[i] );
+		t.strictEqual( RE.test( values[i] ), true, values[i] );
 	}
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns a regular expression that detects a non-regular expr
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[i] ), false, values[i] );
+		t.strictEqual( RE.test( values[i] ), false, values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/regexp/test/test.regexp.js b/lib/node_modules/@stdlib/regexp/regexp/test/test.regexp.js
index 67659a0c957e..d7bf0d93eacf 100644
--- a/lib/node_modules/@stdlib/regexp/regexp/test/test.regexp.js
+++ b/lib/node_modules/@stdlib/regexp/regexp/test/test.regexp.js
@@ -28,7 +28,7 @@ var RE = require( './../lib/regexp.js' );
 
 tape( 'main export is a regular expression', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( RE instanceof RegExp, true, 'main export is a regular expression' );
+	t.strictEqual( RE instanceof RegExp, true, 'main export is a regular expression' );
 	t.end();
 });
 
@@ -49,7 +49,7 @@ tape( 'the regular expression detects a regular expression string', function tes
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[i] ), true, values[i] );
+		t.strictEqual( RE.test( values[i] ), true, values[i] );
 	}
 	t.end();
 });
@@ -68,7 +68,7 @@ tape( 'the regular expression detects a non-regular expression string', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[i] ), false, values[i] );
+		t.strictEqual( RE.test( values[i] ), false, values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/reviver/test/test.js b/lib/node_modules/@stdlib/regexp/reviver/test/test.js
index ab4bb15bb04d..2c4cc8c92716 100644
--- a/lib/node_modules/@stdlib/regexp/reviver/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/reviver/test/test.js
@@ -57,7 +57,7 @@ tape( 'the function does not transform values which are not serialized RegExp ob
 
 	// Null edge case:
 	actual = parseJSON( 'null', reviveRegExp );
-	t.equal( actual, null, 'returns expected value' );
+	t.strictEqual( actual, null, 'returns expected value' );
 
 	t.end();
 });
@@ -117,7 +117,7 @@ tape( 'the function revives a JSON-serialized regular expression', function test
 		actual = parseJSON( json, reviveRegExp );
 
 		t.ok( actual instanceof RegExp, 'returns expected value' );
-		t.equal( actual.toString(), expected.toString(), 'returns expected value when provided ' + json );
+		t.strictEqual( actual.toString(), expected.toString(), 'returns expected value when provided ' + json );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/semver/test/test.js b/lib/node_modules/@stdlib/regexp/semver/test/test.js
index ff68affa448c..69a045ce2baf 100644
--- a/lib/node_modules/@stdlib/regexp/semver/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/semver/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reSemVer.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reSemVer.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/semver/test/test.main.js b/lib/node_modules/@stdlib/regexp/semver/test/test.main.js
index 00ca2c7dd738..e50fa5ae3ac5 100644
--- a/lib/node_modules/@stdlib/regexp/semver/test/test.main.js
+++ b/lib/node_modules/@stdlib/regexp/semver/test/test.main.js
@@ -53,7 +53,7 @@ tape( 'the returned regular expression matches a semver version string', functio
 		'1.0.0+exp.sha.5114f85'
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[i] ), true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( RE.test( values[i] ), true, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the returned regular expression does not match a non-semver version strin
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[i] ), false, 'returns expected value when provided '+values[i] );
+		t.strictEqual( RE.test( values[i] ), false, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/semver/test/test.regexp.js b/lib/node_modules/@stdlib/regexp/semver/test/test.regexp.js
index 253d03f4ca40..83897408e47e 100644
--- a/lib/node_modules/@stdlib/regexp/semver/test/test.regexp.js
+++ b/lib/node_modules/@stdlib/regexp/semver/test/test.regexp.js
@@ -28,7 +28,7 @@ var RE = require( './../lib/regexp.js' );
 
 tape( 'main export is a regular expression', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( RE instanceof RegExp, true, 'main export is a regular expression' );
+	t.strictEqual( RE instanceof RegExp, true, 'main export is a regular expression' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'the regular expression matches valid semantic version strings', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[i] ), true, 'returns expected value when provided '+values[i] );
+		t.strictEqual( RE.test( values[i] ), true, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the regular expression does not match invalid semantic version strings',
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.equal( RE.test( values[i] ), false, 'returns expected value when provided '+values[i] );
+		t.strictEqual( RE.test( values[i] ), false, 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/test/test.js b/lib/node_modules/@stdlib/regexp/test/test.js
index b2a3b83fb742..7e6e5f386a15 100644
--- a/lib/node_modules/@stdlib/regexp/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( regexp );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/unc-path/test/test.js b/lib/node_modules/@stdlib/regexp/unc-path/test/test.js
index 6f2f1280798a..3927a96bf8d1 100644
--- a/lib/node_modules/@stdlib/regexp/unc-path/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/unc-path/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reUncPath.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reUncPath.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/unc-path/test/test.main.js b/lib/node_modules/@stdlib/regexp/unc-path/test/test.main.js
index ca633d68e599..1b7987d16fd6 100644
--- a/lib/node_modules/@stdlib/regexp/unc-path/test/test.main.js
+++ b/lib/node_modules/@stdlib/regexp/unc-path/test/test.main.js
@@ -54,7 +54,7 @@ tape( 'the returned regular expression captures a UNC path host name', function
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 1 ];
-		t.equal( val, expected, values[ i ] );
+		t.strictEqual( val, expected, values[ i ] );
 	}
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the returned regular expression captures a UNC path share name', function
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 2 ];
-		t.equal( val, expected, values[ i ] );
+		t.strictEqual( val, expected, values[ i ] );
 	}
 	t.end();
 });
@@ -117,7 +117,7 @@ tape( 'the returned regular expression captures a UNC path object name', functio
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 3 ];
-		t.equal( val, expected[ i ], values[ i ] );
+		t.strictEqual( val, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -153,7 +153,7 @@ tape( 'the returned regular expression captures a UNC path path name', function
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 4 ];
-		t.equal( val, expected[ i ], values[ i ] );
+		t.strictEqual( val, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -189,7 +189,7 @@ tape( 'the returned regular expression captures a UNC path file name', function
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 5 ];
-		t.equal( val, expected[ i ], values[ i ] );
+		t.strictEqual( val, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -225,7 +225,7 @@ tape( 'the returned regular expression captures a UNC path stream name', functio
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 6 ];
-		t.equal( val, expected[ i ], values[ i ] );
+		t.strictEqual( val, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -261,7 +261,7 @@ tape( 'the returned regular expression captures a UNC path stream type', functio
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 7 ];
-		t.equal( val, expected[ i ], values[ i ] );
+		t.strictEqual( val, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -295,7 +295,7 @@ tape( 'if unable to match a UNC path, the returned regular expression, when exec
 
 	for ( i = 0; i < values.length; i++ ) {
 		out = RE.exec( values[ i ] );
-		t.equal( out, null, 'returns null when provided '+values[ i ] );
+		t.strictEqual( out, null, 'returns null when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -319,7 +319,7 @@ tape( 'the returned regular expression positively verifies a UNC path', function
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = RE.test( values[ i ] );
-		t.equal( bool, true, 'returns true when provided '+values[ i ] );
+		t.strictEqual( bool, true, 'returns true when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -353,7 +353,7 @@ tape( 'the returned regular expression negatively verifies a non-UNC path', func
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = RE.test( values[ i ] );
-		t.equal( bool, false, 'returns false when provided '+values[ i ] );
+		t.strictEqual( bool, false, 'returns false when provided '+values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/unc-path/test/test.regexp.js b/lib/node_modules/@stdlib/regexp/unc-path/test/test.regexp.js
index 32d115fc2503..f6749de6c8ce 100644
--- a/lib/node_modules/@stdlib/regexp/unc-path/test/test.regexp.js
+++ b/lib/node_modules/@stdlib/regexp/unc-path/test/test.regexp.js
@@ -28,7 +28,7 @@ var RE = require( './../lib/regexp.js' );
 
 tape( 'main export is a regular expression', function test( t ) {
 	t.ok( true, __filename );
-	t.equal( RE instanceof RegExp, true, 'main export is a regular expression' );
+	t.strictEqual( RE instanceof RegExp, true, 'main export is a regular expression' );
 	t.end();
 });
 
@@ -51,7 +51,7 @@ tape( 'the regular expression captures a UNC path host name', function test( t )
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 1 ];
-		t.equal( val, expected, values[ i ] );
+		t.strictEqual( val, expected, values[ i ] );
 	}
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the regular expression captures a UNC path share name', function test( t
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 2 ];
-		t.equal( val, expected, values[ i ] );
+		t.strictEqual( val, expected, values[ i ] );
 	}
 	t.end();
 });
@@ -108,7 +108,7 @@ tape( 'the regular expression captures a UNC path object name', function test( t
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 3 ];
-		t.equal( val, expected[ i ], values[ i ] );
+		t.strictEqual( val, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -141,7 +141,7 @@ tape( 'the regular expression captures a UNC path path name', function test( t )
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 4 ];
-		t.equal( val, expected[ i ], values[ i ] );
+		t.strictEqual( val, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -174,7 +174,7 @@ tape( 'the regular expression captures a UNC path file name', function test( t )
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 5 ];
-		t.equal( val, expected[ i ], values[ i ] );
+		t.strictEqual( val, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -207,7 +207,7 @@ tape( 'the regular expression captures a UNC path stream name', function test( t
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 6 ];
-		t.equal( val, expected[ i ], values[ i ] );
+		t.strictEqual( val, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -240,7 +240,7 @@ tape( 'the regular expression captures a UNC path stream type', function test( t
 
 	for ( i = 0; i < values.length; i++ ) {
 		val = RE.exec( values[ i ] )[ 7 ];
-		t.equal( val, expected[ i ], values[ i ] );
+		t.strictEqual( val, expected[ i ], values[ i ] );
 	}
 	t.end();
 });
@@ -271,7 +271,7 @@ tape( 'if unable to match a UNC path, the regular expression, when executed, ret
 
 	for ( i = 0; i < values.length; i++ ) {
 		out = RE.exec( values[ i ] );
-		t.equal( out, null, 'returns null when provided '+values[ i ] );
+		t.strictEqual( out, null, 'returns null when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -292,7 +292,7 @@ tape( 'the regular expression positively verifies a UNC path', function test( t
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = RE.test( values[ i ] );
-		t.equal( bool, true, 'returns true when provided '+values[ i ] );
+		t.strictEqual( bool, true, 'returns true when provided '+values[ i ] );
 	}
 	t.end();
 });
@@ -323,7 +323,7 @@ tape( 'the regular expression negatively verifies a non-UNC path', function test
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = RE.test( values[ i ] );
-		t.equal( bool, false, 'returns false when provided '+values[ i ] );
+		t.strictEqual( bool, false, 'returns false when provided '+values[ i ] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/utf16-surrogate-pair/test/test.js b/lib/node_modules/@stdlib/regexp/utf16-surrogate-pair/test/test.js
index 9eb265e4eab6..5339b7dc818e 100644
--- a/lib/node_modules/@stdlib/regexp/utf16-surrogate-pair/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/utf16-surrogate-pair/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reUtf16SurrogatePair.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reUtf16SurrogatePair.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/utf16-unpaired-surrogate/test/test.js b/lib/node_modules/@stdlib/regexp/utf16-unpaired-surrogate/test/test.js
index 7a02e6ab7500..b60ff3849082 100644
--- a/lib/node_modules/@stdlib/regexp/utf16-unpaired-surrogate/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/utf16-unpaired-surrogate/test/test.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reUtf16UnpairedSurrogate.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reUtf16UnpairedSurrogate.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/whitespace/test/test.js b/lib/node_modules/@stdlib/regexp/whitespace/test/test.js
index db314cac2056..90ea03f19d34 100644
--- a/lib/node_modules/@stdlib/regexp/whitespace/test/test.js
+++ b/lib/node_modules/@stdlib/regexp/whitespace/test/test.js
@@ -34,11 +34,11 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'attached to the main export is a regular expression', function test( t ) {
-	t.equal( isRegExp( reWhitespace.REGEXP ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reWhitespace.REGEXP ), true, 'exports a regular expression' );
 	t.end();
 });
 
 tape( 'attached to the main export is a regular expression (capture group)', function test( t ) {
-	t.equal( isRegExp( reWhitespace.REGEXP_CAPTURE ), true, 'exports a regular expression' );
+	t.strictEqual( isRegExp( reWhitespace.REGEXP_CAPTURE ), true, 'exports a regular expression' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/simulate/test/test.js b/lib/node_modules/@stdlib/simulate/test/test.js
index cb67e81c846d..6c0235acd703 100644
--- a/lib/node_modules/@stdlib/simulate/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( rand );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/slice/base/test/test.js b/lib/node_modules/@stdlib/slice/base/test/test.js
index 9fdab6e77188..93a939a5f431 100644
--- a/lib/node_modules/@stdlib/slice/base/test/test.js
+++ b/lib/node_modules/@stdlib/slice/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/slice/test/test.js b/lib/node_modules/@stdlib/slice/test/test.js
index 9fdab6e77188..93a939a5f431 100644
--- a/lib/node_modules/@stdlib/slice/test/test.js
+++ b/lib/node_modules/@stdlib/slice/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/strided/base/test/test.js b/lib/node_modules/@stdlib/strided/base/test/test.js
index 6ddfe8e38d7d..2a93e3b916fc 100644
--- a/lib/node_modules/@stdlib/strided/base/test/test.js
+++ b/lib/node_modules/@stdlib/strided/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains base utilities', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/strided/test/test.js b/lib/node_modules/@stdlib/strided/test/test.js
index 9ba0b9295ae3..9a40bad518a8 100644
--- a/lib/node_modules/@stdlib/strided/test/test.js
+++ b/lib/node_modules/@stdlib/strided/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains strided packages', function test( t ) {
 	var keys = objectKeys( strided );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/symbol/test/test.js b/lib/node_modules/@stdlib/symbol/test/test.js
index 4703875b1edd..e682e93dba4d 100644
--- a/lib/node_modules/@stdlib/symbol/test/test.js
+++ b/lib/node_modules/@stdlib/symbol/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/time/base/test/test.js b/lib/node_modules/@stdlib/time/base/test/test.js
index a263f8ed91b6..3a1391ee824b 100644
--- a/lib/node_modules/@stdlib/time/base/test/test.js
+++ b/lib/node_modules/@stdlib/time/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains base (i.e., lower-level) time utilities', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/time/duration2ms/test/test.js b/lib/node_modules/@stdlib/time/duration2ms/test/test.js
index bd55f589ca2c..f2acc5d0f316 100644
--- a/lib/node_modules/@stdlib/time/duration2ms/test/test.js
+++ b/lib/node_modules/@stdlib/time/duration2ms/test/test.js
@@ -82,7 +82,7 @@ tape( 'the function converts a duration string to milliseconds', function test(
 
 	for ( i = 0; i < values.length; i++ ) {
 		ms = duration2ms( values[i] );
-		t.equal( ms, expected[i], 'returns expected value when provided '+values[i] );
+		t.strictEqual( ms, expected[i], 'returns expected value when provided '+values[i] );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/time/ms2duration/test/test.js b/lib/node_modules/@stdlib/time/ms2duration/test/test.js
index 2c87ce464d89..a1b2bcdd6565 100644
--- a/lib/node_modules/@stdlib/time/ms2duration/test/test.js
+++ b/lib/node_modules/@stdlib/time/ms2duration/test/test.js
@@ -64,65 +64,65 @@ tape( 'the function throws an error if provided a value which is not a nonnegati
 
 tape( 'the function returns `0ms` when provided `0`', function test( t ) {
 	var duration = ms2duration( 0 );
-	t.equal( duration, '0ms', 'returns 0ms' );
+	t.strictEqual( duration, '0ms', 'returns 0ms' );
 	t.end();
 });
 
 tape( 'the function converts milliseconds to a string duration (seconds)', function test( t ) {
-	t.equal( ms2duration( 1000 ), '1s', 'converts 1s' );
-	t.equal( ms2duration( 2000 ), '2s', 'converts 2s' );
-	t.equal( ms2duration( 3000 ), '3s', 'converts 3s' );
-	t.equal( ms2duration( 4000 ), '4s', 'converts 4s' );
-	t.equal( ms2duration( 5000 ), '5s', 'converts 5s' );
-	t.equal( ms2duration( 6000 ), '6s', 'converts 6s' );
-	t.equal( ms2duration( 7000 ), '7s', 'converts 7s' );
-	t.equal( ms2duration( 8000 ), '8s', 'converts 8s' );
-	t.equal( ms2duration( 9000 ), '9s', 'converts 9s' );
+	t.strictEqual( ms2duration( 1000 ), '1s', 'converts 1s' );
+	t.strictEqual( ms2duration( 2000 ), '2s', 'converts 2s' );
+	t.strictEqual( ms2duration( 3000 ), '3s', 'converts 3s' );
+	t.strictEqual( ms2duration( 4000 ), '4s', 'converts 4s' );
+	t.strictEqual( ms2duration( 5000 ), '5s', 'converts 5s' );
+	t.strictEqual( ms2duration( 6000 ), '6s', 'converts 6s' );
+	t.strictEqual( ms2duration( 7000 ), '7s', 'converts 7s' );
+	t.strictEqual( ms2duration( 8000 ), '8s', 'converts 8s' );
+	t.strictEqual( ms2duration( 9000 ), '9s', 'converts 9s' );
 	t.end();
 });
 
 tape( 'the function converts milliseconds to a string duration (minutes)', function test( t ) {
-	t.equal( ms2duration( 60000 ), '1m', 'converts 1m' );
-	t.equal( ms2duration( 120000 ), '2m', 'converts 2m' );
-	t.equal( ms2duration( 180000 ), '3m', 'converts 3m' );
-	t.equal( ms2duration( 240000 ), '4m', 'converts 4m' );
-	t.equal( ms2duration( 300000 ), '5m', 'converts 5m' );
-	t.equal( ms2duration( 360000 ), '6m', 'converts 6m' );
-	t.equal( ms2duration( 420000 ), '7m', 'converts 7m' );
-	t.equal( ms2duration( 480000 ), '8m', 'converts 8m' );
-	t.equal( ms2duration( 540000 ), '9m', 'converts 9m' );
+	t.strictEqual( ms2duration( 60000 ), '1m', 'converts 1m' );
+	t.strictEqual( ms2duration( 120000 ), '2m', 'converts 2m' );
+	t.strictEqual( ms2duration( 180000 ), '3m', 'converts 3m' );
+	t.strictEqual( ms2duration( 240000 ), '4m', 'converts 4m' );
+	t.strictEqual( ms2duration( 300000 ), '5m', 'converts 5m' );
+	t.strictEqual( ms2duration( 360000 ), '6m', 'converts 6m' );
+	t.strictEqual( ms2duration( 420000 ), '7m', 'converts 7m' );
+	t.strictEqual( ms2duration( 480000 ), '8m', 'converts 8m' );
+	t.strictEqual( ms2duration( 540000 ), '9m', 'converts 9m' );
 	t.end();
 });
 
 tape( 'the function converts milliseconds to a string duration (hours)', function test( t ) {
-	t.equal( ms2duration( 3600000 ), '1h', 'converts 1h' );
-	t.equal( ms2duration( 7200000 ), '2h', 'converts 2h' );
-	t.equal( ms2duration( 10800000 ), '3h', 'converts 3h' );
-	t.equal( ms2duration( 14400000 ), '4h', 'converts 4h' );
-	t.equal( ms2duration( 18000000 ), '5h', 'converts 5h' );
-	t.equal( ms2duration( 21600000 ), '6h', 'converts 6h' );
-	t.equal( ms2duration( 25200000 ), '7h', 'converts 7h' );
-	t.equal( ms2duration( 28800000 ), '8h', 'converts 8h' );
-	t.equal( ms2duration( 32400000 ), '9h', 'converts 9h' );
+	t.strictEqual( ms2duration( 3600000 ), '1h', 'converts 1h' );
+	t.strictEqual( ms2duration( 7200000 ), '2h', 'converts 2h' );
+	t.strictEqual( ms2duration( 10800000 ), '3h', 'converts 3h' );
+	t.strictEqual( ms2duration( 14400000 ), '4h', 'converts 4h' );
+	t.strictEqual( ms2duration( 18000000 ), '5h', 'converts 5h' );
+	t.strictEqual( ms2duration( 21600000 ), '6h', 'converts 6h' );
+	t.strictEqual( ms2duration( 25200000 ), '7h', 'converts 7h' );
+	t.strictEqual( ms2duration( 28800000 ), '8h', 'converts 8h' );
+	t.strictEqual( ms2duration( 32400000 ), '9h', 'converts 9h' );
 	t.end();
 });
 
 tape( 'the function converts milliseconds to a string duration (days)', function test( t ) {
-	t.equal( ms2duration( 86400000 ), '1d', 'converts 1d' );
-	t.equal( ms2duration( 172800000 ), '2d', 'converts 2d' );
-	t.equal( ms2duration( 259200000 ), '3d', 'converts 3d' );
-	t.equal( ms2duration( 345600000 ), '4d', 'converts 4d' );
-	t.equal( ms2duration( 432000000 ), '5d', 'converts 5d' );
-	t.equal( ms2duration( 518400000 ), '6d', 'converts 6d' );
-	t.equal( ms2duration( 604800000 ), '7d', 'converts 7d' );
+	t.strictEqual( ms2duration( 86400000 ), '1d', 'converts 1d' );
+	t.strictEqual( ms2duration( 172800000 ), '2d', 'converts 2d' );
+	t.strictEqual( ms2duration( 259200000 ), '3d', 'converts 3d' );
+	t.strictEqual( ms2duration( 345600000 ), '4d', 'converts 4d' );
+	t.strictEqual( ms2duration( 432000000 ), '5d', 'converts 5d' );
+	t.strictEqual( ms2duration( 518400000 ), '6d', 'converts 6d' );
+	t.strictEqual( ms2duration( 604800000 ), '7d', 'converts 7d' );
 	t.end();
 });
 
 tape( 'the function converts a value in milliseconds to a string duration', function test( t ) {
-	t.equal( ms2duration( 1234 ), '1s234ms', 'converts 1s234ms' );
-	t.equal( ms2duration( 12345 ), '12s345ms', 'converts 12s345ms' );
-	t.equal( ms2duration( 123456 ), '2m3s456ms', 'converts 2m3s456ms' );
-	t.equal( ms2duration( 1234567 ), '20m34s567ms', 'converts 20m34s567ms' );
-	t.equal( ms2duration( 12345678 ), '3h25m45s678ms', 'converts 3h25m45s678ms' );
+	t.strictEqual( ms2duration( 1234 ), '1s234ms', 'converts 1s234ms' );
+	t.strictEqual( ms2duration( 12345 ), '12s345ms', 'converts 12s345ms' );
+	t.strictEqual( ms2duration( 123456 ), '2m3s456ms', 'converts 2m3s456ms' );
+	t.strictEqual( ms2duration( 1234567 ), '20m34s567ms', 'converts 20m34s567ms' );
+	t.strictEqual( ms2duration( 12345678 ), '3h25m45s678ms', 'converts 3h25m45s678ms' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/time/test/test.js b/lib/node_modules/@stdlib/time/test/test.js
index 98730492dc4e..53fd0bc56e52 100644
--- a/lib/node_modules/@stdlib/time/test/test.js
+++ b/lib/node_modules/@stdlib/time/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains time utilities', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/wasm/base/test/test.js b/lib/node_modules/@stdlib/wasm/base/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/wasm/base/test/test.js
+++ b/lib/node_modules/@stdlib/wasm/base/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/wasm/test/test.js b/lib/node_modules/@stdlib/wasm/test/test.js
index a7d71c83052a..2fbefe9da676 100644
--- a/lib/node_modules/@stdlib/wasm/test/test.js
+++ b/lib/node_modules/@stdlib/wasm/test/test.js
@@ -35,6 +35,6 @@ tape( 'main export is an object', function test( t ) {
 
 tape( 'the exported object contains key-value pairs', function test( t ) {
 	var keys = objectKeys( ns );
-	t.equal( keys.length > 0, true, 'has keys' );
+	t.strictEqual( keys.length > 0, true, 'has keys' );
 	t.end();
 });

From 07f7c0522c73e6ad9505e1d45035ae439344200d Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Thu, 14 Aug 2025 14:49:39 -0500
Subject: [PATCH 14/32] test: use standardized assertion messages and fix lint
 errors

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../browser-build/test/test.validate.js       |   4 +-
 .../benchmarks/bundle/test/test.validate.js   |   4 +-
 .../benchmarks/html/test/test.validate.js     |   4 +-
 .../citation-reference/test/test.validate.js  |   4 +-
 .../bundle/pkg-list/test/test.validate.js     |   4 +-
 .../changelog/generate/test/test.validate.js  |   4 +-
 .../parse-commits/test/test.validate.js       |   4 +-
 .../doctest/compare-values/test/test.js       | 112 ++++++-------
 .../test/test.validate.js                     |   4 +-
 .../github/create-issue/test/test.headers.js  |   2 +-
 .../github/create-issue/test/test.options.js  |   2 +-
 .../create-issue/test/test.ratelimit.js       |   2 +-
 .../github/create-issue/test/test.request.js  |   4 +-
 .../github/create-issue/test/test.validate.js |   4 +-
 .../github/create-repo/test/test.factory.js   |   2 +-
 .../github/create-repo/test/test.headers.js   |   2 +-
 .../github/create-repo/test/test.options.js   |   2 +-
 .../github/create-repo/test/test.ratelimit.js |   2 +-
 .../github/create-repo/test/test.request.js   |   4 +-
 .../github/create-repo/test/test.validate.js  |   4 +-
 .../github/create-token/test/test.headers.js  |   2 +-
 .../github/create-token/test/test.options.js  |   2 +-
 .../create-token/test/test.ratelimit.js       |   2 +-
 .../github/create-token/test/test.request.js  |   4 +-
 .../github/create-token/test/test.validate.js |   4 +-
 .../github/delete-token/test/test.headers.js  |   2 +-
 .../github/delete-token/test/test.options.js  |   2 +-
 .../delete-token/test/test.ratelimit.js       |   2 +-
 .../github/delete-token/test/test.validate.js |   4 +-
 .../dispatch-workflow/test/test.headers.js    |   2 +-
 .../dispatch-workflow/test/test.options.js    |   2 +-
 .../dispatch-workflow/test/test.ratelimit.js  |   2 +-
 .../dispatch-workflow/test/test.validate.js   |   4 +-
 .../github/fetch-file/test/test.factory.js    |   2 +-
 .../github/fetch-file/test/test.options.js    |   2 +-
 .../github/fetch-file/test/test.resolve.js    |   2 +-
 .../github/followers/test/test.factory.js     |   2 +-
 .../github/followers/test/test.validate.js    |   4 +-
 .../github/following/test/test.factory.js     |   2 +-
 .../github/following/test/test.validate.js    |   4 +-
 .../_tools/github/get/test/test.factory.js    |   2 +-
 .../_tools/github/get/test/test.headers.js    |   2 +-
 .../_tools/github/get/test/test.options.js    |   2 +-
 .../_tools/github/get/test/test.ratelimit.js  |   2 +-
 .../_tools/github/get/test/test.request.js    |   4 +-
 .../_tools/github/get/test/test.validate.js   |   4 +-
 .../github/org-repos/test/test.factory.js     |   2 +-
 .../github/org-repos/test/test.validate.js    |   4 +-
 .../rank-followers/test/test.factory.js       |   2 +-
 .../rank-followers/test/test.validate.js      |   4 +-
 .../github/rank-users/test/test.factory.js    |   2 +-
 .../github/rank-users/test/test.validate.js   |   4 +-
 .../github/set-topics/test/test.factory.js    |   2 +-
 .../github/set-topics/test/test.headers.js    |   2 +-
 .../github/set-topics/test/test.options.js    |   2 +-
 .../github/set-topics/test/test.ratelimit.js  |   2 +-
 .../github/set-topics/test/test.validate.js   |   4 +-
 .../github/star-repo/test/test.factory.js     |   2 +-
 .../github/star-repo/test/test.headers.js     |   2 +-
 .../github/star-repo/test/test.options.js     |   2 +-
 .../github/star-repo/test/test.ratelimit.js   |   2 +-
 .../github/star-repo/test/test.validate.js    |   4 +-
 .../github/starred/test/test.factory.js       |   2 +-
 .../github/starred/test/test.validate.js      |   4 +-
 .../github/subscriptions/test/test.factory.js |   2 +-
 .../subscriptions/test/test.validate.js       |   4 +-
 .../github/user-details/test/test.factory.js  |   2 +-
 .../github/user-details/test/test.get.js      |   2 +-
 .../github/user-details/test/test.validate.js |   4 +-
 .../github/user-orgs/test/test.factory.js     |   2 +-
 .../github/user-orgs/test/test.validate.js    |   4 +-
 .../user-rate-limit/test/test.factory.js      |   2 +-
 .../user-rate-limit/test/test.validate.js     |   4 +-
 .../github/user-repos/test/test.factory.js    |   2 +-
 .../github/user-repos/test/test.validate.js   |   4 +-
 .../github/workflow-runs/test/test.factory.js |   2 +-
 .../workflow-runs/test/test.validate.js       |   4 +-
 .../licenses/header-regexp-table/test/test.js |   6 +-
 .../licenses/header/test/test.validate.js     |   4 +-
 .../_tools/links/create/test/test.sync.js     |   6 +-
 .../_tools/links/create/test/test.validate.js |   4 +-
 .../_tools/links/id2uri/test/test.async.js    |   2 +-
 .../_tools/links/id2uri/test/test.sync.js     |   2 +-
 .../_tools/links/id2uri/test/test.validate.js |   4 +-
 .../_tools/links/uri2id/test/test.async.js    |   2 +-
 .../_tools/links/uri2id/test/test.sync.js     |   2 +-
 .../_tools/links/uri2id/test/test.validate.js |   4 +-
 .../links/validate/test/test.validate.js      |   4 +-
 .../lint/filenames/test/test.validate.js      |   4 +-
 .../header-filenames/test/test.validate.js    |   4 +-
 .../license-header-glob/test/test.validate.js |   4 +-
 .../namespace-aliases/test/test.validate.js   |   4 +-
 .../_tools/lint/pkg-json/test/test.sync.js    |   2 +-
 .../lint/pkg-json/test/test.validate.js       |   4 +-
 .../_tools/lint/repl-txt/test/test.sync.js    |   2 +-
 .../lint/repl-txt/test/test.validate.js       |   4 +-
 .../_tools/manifest-json/schema/test/test.js  |  24 +--
 .../img-svg-equation/test/test.validate.js    |   4 +-
 .../inline-svg-equation/test/test.validate.js |   4 +-
 .../import-require-glob/test/test.validate.js |   4 +-
 .../modules/pkg-deps/test/test.validate.js    |   4 +-
 .../pkg-deps/test/test.walk_file.sync.js      |   6 +-
 .../_tools/package-json/schema/test/test.js   | 150 +++++++++---------
 .../_tools/pkgs/addons/test/test.validate.js  |   4 +-
 .../browser-compatible/test/test.validate.js  |   4 +-
 .../pkgs/browser-deps/test/test.validate.js   |   4 +-
 .../test/test.validate.js                     |   4 +-
 .../_tools/pkgs/clis/test/test.validate.js    |   4 +-
 .../_tools/pkgs/cmds/test/test.validate.js    |   4 +-
 .../pkgs/dep-list/test/test.validate.js       |   4 +-
 .../_tools/pkgs/deps/test/test.validate.js    |   4 +-
 .../pkgs/entry-points/test/test.validate.js   |   4 +-
 .../_tools/pkgs/find/test/test.validate.js    |   4 +-
 .../pkgs/includes/test/test.validate.js       |   4 +-
 .../_tools/pkgs/names/test/test.validate.js   |   4 +-
 .../pkgs/namespace-deps/test/test.validate.js |   4 +-
 .../namespace-readmes/test/test.validate.js   |   4 +-
 .../pkgs/namespaces/test/test.validate.js     |   4 +-
 .../_tools/pkgs/readmes/test/test.validate.js |   4 +-
 .../pkgs/repl-help/test/test.validate.js      |   4 +-
 .../pkgs/standalones/test/test.validate.js    |   4 +-
 .../pkgs/toposort/test/test.validate.js       |   4 +-
 .../_tools/pkgs/tree/test/test.async.js       |   8 +-
 .../_tools/pkgs/tree/test/test.sync.js        |   8 +-
 .../_tools/pkgs/tree/test/test.validate.js    |   4 +-
 .../_tools/pkgs/types/test/test.validate.js   |   4 +-
 .../_tools/pkgs/wasm/test/test.validate.js    |   4 +-
 .../readme/to-html/test/test.validate.js      |   4 +-
 .../package-json/test/test.validate.js        |   4 +-
 .../test/test.validate.js                     |   4 +-
 .../test/test.validate.js                     |   4 +-
 .../test/test.validate_config.js              |   4 +-
 .../_tools/scaffold/package-json/test/test.js |   2 +-
 .../package-json/test/test.validate.js        |   4 +-
 .../test/fixtures/cli_test.validate.js.txt    |   4 +-
 .../test/fixtures/test.validate.js_1.txt      |   4 +-
 .../test/fixtures/test.validate.js_2.txt      |   4 +-
 .../test/fixtures/test.validate.js_3.txt      |   4 +-
 .../test/fixtures/test.validate.js_4.txt      |   4 +-
 .../search/pkg-index/test/test.validate.js    |   4 +-
 .../static-analysis/js/incr/lloc/test/test.js |  52 +++---
 .../js/incr/program-summary/test/test.js      |  52 +++---
 .../static-analysis/js/incr/sloc/test/test.js |  52 +++---
 .../js/lloc-file-list/test/test.validate.js   |   4 +-
 .../js/lloc-glob/test/test.validate.js        |   4 +-
 .../js/program-summary/test/test.js           |   4 +-
 .../js/sloc-file-list/test/test.validate.js   |   4 +-
 .../js/sloc-glob/test/test.validate.js        |   4 +-
 .../summarize-file-list/test/test.validate.js |   4 +-
 .../js/summarize-glob/test/test.validate.js   |   4 +-
 .../tape-istanbul/test/test.validate.js       |   4 +-
 .../tests/browser-build/test/test.validate.js |   4 +-
 .../_tools/tests/bundle/test/test.validate.js |   4 +-
 .../_tools/tests/html/test/test.validate.js   |   4 +-
 .../utils/jsdelivr-url/test/test.validate.js  |   4 +-
 .../tex-equation-to-svg/test/test.validate.js |   4 +-
 .../@stdlib/array/bool/test/test.entries.js   |   2 +-
 .../@stdlib/array/bool/test/test.keys.js      |   6 +-
 .../@stdlib/array/bool/test/test.values.js    |   6 +-
 .../array/complex128/test/test.entries.js     |   4 +-
 .../array/complex128/test/test.keys.js        |   6 +-
 .../array/complex128/test/test.values.js      |   6 +-
 .../array/complex64/test/test.entries.js      |   4 +-
 .../@stdlib/array/complex64/test/test.keys.js |   6 +-
 .../array/complex64/test/test.values.js       |   6 +-
 .../array/mostly-safe-casts/test/test.js      |   2 +-
 .../@stdlib/array/next-dtype/test/test.js     |   2 +-
 .../@stdlib/array/pool/test/test.factory.js   |  10 +-
 .../array/promotion-rules/test/test.js        |   2 +-
 .../@stdlib/array/safe-casts/test/test.js     |   2 +-
 .../array/same-kind-casts/test/test.js        |   2 +-
 .../array/to-circular-iterator/test/test.js   |  52 +++---
 .../array/to-iterator-right/test/test.js      |  32 ++--
 .../@stdlib/array/to-iterator/test/test.js    |  40 ++---
 .../@stdlib/array/to-json/test/test.js        |   2 +-
 .../to-sparse-iterator-right/test/test.js     |  44 ++---
 .../array/to-sparse-iterator/test/test.js     |  44 ++---
 .../array/to-strided-iterator/test/test.js    |  32 ++--
 .../array/to-view-iterator-right/test/test.js |  86 +++++-----
 .../array/to-view-iterator/test/test.js       |  86 +++++-----
 .../test/test.factory.js                      |  42 ++---
 .../test/test.validate.js                     |   6 +-
 .../deep-has-property/test/test.factory.js    |  42 ++---
 .../deep-has-property/test/test.validate.js   |   6 +-
 .../@stdlib/bench/harness/test/test.bench.js  |   2 +-
 .../bench/harness/test/test.exit_harness.js   |   8 +-
 .../bench/harness/test/test.get_harness.js    |   2 +-
 .../bench/harness/test/test.harness.js        |   8 +-
 .../harness/test/test.harness.validate.js     |   4 +-
 .../@stdlib/bigint/ctor/test/test.js          |   2 +-
 .../@stdlib/buffer/to-json/test/test.js       |   4 +-
 .../@stdlib/cli/ctor/test/test.validate.js    |   4 +-
 .../@stdlib/complex/base/parse/test/test.js   |   2 +-
 .../complex/promotion-rules/test/test.js      |   2 +-
 .../datasets/cmudict/test/test.browser.js     |  10 +-
 .../@stdlib/datasets/cmudict/test/test.js     |  10 +-
 .../datasets/cmudict/test/test.validate.js    |   4 +-
 .../emoji-code-picto/test/test.browser.js     |   2 +-
 .../datasets/emoji-code-picto/test/test.js    |   2 +-
 .../emoji-picto-code/test/test.browser.js     |   2 +-
 .../datasets/emoji-picto-code/test/test.js    |   2 +-
 .../test/test.browser.js                      |   6 +-
 .../minard-napoleons-march/test/test.js       |   6 +-
 .../test/test.validate.js                     |   4 +-
 .../sotu/test/test.browser_get_file.js        |   2 +-
 .../datasets/sotu/test/test.get_file.js       |   2 +-
 .../datasets/sotu/test/test.validate.js       |   6 +-
 .../test/test.browser.js                      |   2 +-
 .../us-states-capitals-names/test/test.js     |   2 +-
 .../test/test.browser.js                      |   2 +-
 .../us-states-names-capitals/test/test.js     |   2 +-
 .../dstructs/circular-buffer/test/test.js     |   8 +-
 .../dstructs/doubly-linked-list/test/test.js  |   6 +-
 .../@stdlib/dstructs/fifo/test/test.js        |   6 +-
 .../@stdlib/dstructs/linked-list/test/test.js |   6 +-
 .../@stdlib/dstructs/stack/test/test.js       |   6 +-
 .../tools/fmtprodmsg-factory/test/test.js     |   2 +-
 .../fmtprodmsg-factory/test/test.validate.js  |   4 +-
 .../resolve-parent-path-by/test/test.async.js |   4 +-
 .../resolve-parent-path-by/test/test.sync.js  |   4 +-
 .../test/test.validate.js                     |   4 +-
 .../fs/resolve-parent-path/test/test.async.js |   4 +-
 .../fs/resolve-parent-path/test/test.sync.js  |   4 +-
 .../resolve-parent-path/test/test.validate.js |   4 +-
 .../@stdlib/iter/concat/test/test.js          |  10 +-
 .../@stdlib/iter/constant/test/test.js        |  10 +-
 .../@stdlib/iter/counter/test/test.js         |  10 +-
 .../@stdlib/iter/cuany-by/test/test.js        |   2 +-
 .../@stdlib/iter/cuany/test/test.js           |   2 +-
 .../@stdlib/iter/cuevery-by/test/test.js      |   2 +-
 .../@stdlib/iter/cuevery/test/test.js         |   2 +-
 .../@stdlib/iter/cunone-by/test/test.js       |   2 +-
 .../@stdlib/iter/cunone/test/test.js          |   2 +-
 .../@stdlib/iter/cusome-by/test/test.js       |  10 +-
 .../@stdlib/iter/cusome/test/test.js          |   2 +-
 .../@stdlib/iter/datespace/test/test.js       |   2 +-
 .../@stdlib/iter/dedupe-by/test/test.js       |  10 +-
 .../@stdlib/iter/dedupe/test/test.js          |  10 +-
 .../@stdlib/iter/do-until-each/test/test.js   |  16 +-
 .../@stdlib/iter/do-while-each/test/test.js   |  16 +-
 .../@stdlib/iter/empty/test/test.js           |   2 +-
 .../@stdlib/iter/fill/test/test.js            |  16 +-
 .../@stdlib/iter/filter-map/test/test.js      |  14 +-
 .../@stdlib/iter/filter/test/test.js          |  14 +-
 .../@stdlib/iter/flow/test/test.js            |  18 +--
 .../@stdlib/iter/for-each/test/test.js        |  16 +-
 .../@stdlib/iter/head/test/test.js            |  12 +-
 .../@stdlib/iter/incrspace/test/test.js       |  10 +-
 .../iter/intersection-by-hash/test/test.js    |  10 +-
 .../@stdlib/iter/intersection/test/test.js    |  10 +-
 .../@stdlib/iter/linspace/test/test.js        |  10 +-
 .../@stdlib/iter/logspace/test/test.js        |  10 +-
 .../@stdlib/iter/map/test/test.js             |  20 +--
 .../@stdlib/iter/mapn/test/test.js            |  10 +-
 .../@stdlib/iter/pop/test/test.js             |  10 +-
 .../@stdlib/iter/push/test/test.js            |  10 +-
 .../@stdlib/iter/reject/test/test.js          |  14 +-
 .../@stdlib/iter/replicate-by/test/test.js    |  10 +-
 .../@stdlib/iter/replicate/test/test.js       |  10 +-
 .../@stdlib/iter/shift/test/test.js           |  10 +-
 .../@stdlib/iter/slice/test/test.js           |  16 +-
 .../@stdlib/iter/step/test/test.js            |  10 +-
 .../@stdlib/iter/strided-by/test/test.js      |  26 +--
 .../@stdlib/iter/strided/test/test.js         |  26 +--
 .../@stdlib/iter/union/test/test.js           |  10 +-
 .../@stdlib/iter/unique-by-hash/test/test.js  |  10 +-
 .../@stdlib/iter/unique-by/test/test.js       |  10 +-
 .../@stdlib/iter/unique/test/test.js          |  10 +-
 .../@stdlib/iter/unitspace/test/test.js       |  10 +-
 .../@stdlib/iter/unshift/test/test.js         |  10 +-
 .../@stdlib/iter/until-each/test/test.js      |  16 +-
 .../@stdlib/iter/while-each/test/test.js      |  16 +-
 .../test/test.factory.js                      |   2 +-
 .../tools/evalrational/test/test.factory.js   |   2 +-
 .../tools/evalrationalf/test/test.factory.js  |   2 +-
 .../base/tools/fibpoly/test/test.factory.js   |   2 +-
 .../tools/hermitepoly/test/test.factory.js    |   2 +-
 .../base/tools/lucaspoly/test/test.factory.js |   2 +-
 .../normhermitepoly/test/test.factory.js      |   2 +-
 .../normhermitepolyf/test/test.factory.js     |   2 +-
 .../@stdlib/math/iter/ops/add/test/test.js    |  12 +-
 .../@stdlib/math/iter/ops/divide/test/test.js |  12 +-
 .../@stdlib/math/iter/ops/mod/test/test.js    |  12 +-
 .../math/iter/ops/multiply/test/test.js       |  12 +-
 .../math/iter/ops/subtract/test/test.js       |  12 +-
 .../iter/sequences/composites/test/test.js    |  10 +-
 .../composites/test/test.validate.js          |   4 +-
 .../sequences/continued-fraction/test/test.js |  10 +-
 .../continued-fraction/test/test.validate.js  |   4 +-
 .../math/iter/sequences/cubes/test/test.js    |  10 +-
 .../sequences/cubes/test/test.validate.js     |   4 +-
 .../iter/sequences/even-integers/test/test.js |  10 +-
 .../even-integers/test/test.validate.js       |   4 +-
 .../iter/sequences/factorials/test/test.js    |  10 +-
 .../factorials/test/test.validate.js          |   4 +-
 .../iter/sequences/fibonacci/test/test.js     |  10 +-
 .../sequences/fibonacci/test/test.validate.js |   4 +-
 .../iter/sequences/fifth-powers/test/test.js  |  10 +-
 .../fifth-powers/test/test.validate.js        |   4 +-
 .../iter/sequences/fourth-powers/test/test.js |  10 +-
 .../fourth-powers/test/test.validate.js       |   4 +-
 .../math/iter/sequences/integers/test/test.js |  10 +-
 .../sequences/integers/test/test.validate.js  |   4 +-
 .../math/iter/sequences/lucas/test/test.js    |  10 +-
 .../sequences/lucas/test/test.validate.js     |   4 +-
 .../iter/sequences/negafibonacci/test/test.js |  10 +-
 .../negafibonacci/test/test.validate.js       |   4 +-
 .../iter/sequences/negalucas/test/test.js     |  10 +-
 .../sequences/negalucas/test/test.validate.js |   4 +-
 .../negative-even-integers/test/test.js       |  10 +-
 .../test/test.validate.js                     |   4 +-
 .../sequences/negative-integers/test/test.js  |  10 +-
 .../negative-integers/test/test.validate.js   |   4 +-
 .../negative-odd-integers/test/test.js        |  10 +-
 .../test/test.validate.js                     |   4 +-
 .../iter/sequences/nonfibonacci/test/test.js  |  10 +-
 .../nonfibonacci/test/test.validate.js        |   4 +-
 .../nonnegative-even-integers/test/test.js    |  10 +-
 .../test/test.validate.js                     |   4 +-
 .../nonnegative-integers/test/test.js         |  10 +-
 .../test/test.validate.js                     |   4 +-
 .../nonpositive-even-integers/test/test.js    |  10 +-
 .../test/test.validate.js                     |   4 +-
 .../nonpositive-integers/test/test.js         |  10 +-
 .../test/test.validate.js                     |   4 +-
 .../iter/sequences/nonsquares/test/test.js    |  10 +-
 .../nonsquares/test/test.validate.js          |   4 +-
 .../iter/sequences/odd-integers/test/test.js  |  10 +-
 .../odd-integers/test/test.validate.js        |   4 +-
 .../positive-even-integers/test/test.js       |  10 +-
 .../test/test.validate.js                     |   4 +-
 .../sequences/positive-integers/test/test.js  |  10 +-
 .../positive-integers/test/test.validate.js   |   4 +-
 .../positive-odd-integers/test/test.js        |  10 +-
 .../test/test.validate.js                     |   4 +-
 .../math/iter/sequences/primes/test/test.js   |  10 +-
 .../sequences/primes/test/test.validate.js    |   4 +-
 .../sequences/squared-triangular/test/test.js |  10 +-
 .../squared-triangular/test/test.validate.js  |   4 +-
 .../math/iter/sequences/squares/test/test.js  |  10 +-
 .../sequences/squares/test/test.validate.js   |   4 +-
 .../iter/sequences/triangular/test/test.js    |  10 +-
 .../triangular/test/test.validate.js          |   4 +-
 .../iter/sequences/tribonacci/test/test.js    |  10 +-
 .../tribonacci/test/test.validate.js          |   4 +-
 .../@stdlib/math/iter/tools/map/test/test.js  |  18 +--
 .../math/iter/tools/map/test/test.validate.js |   4 +-
 .../@stdlib/math/iter/tools/map2/test/test.js |  14 +-
 .../iter/tools/map2/test/test.validate.js     |   4 +-
 .../@stdlib/math/iter/tools/map3/test/test.js |  14 +-
 .../iter/tools/map3/test/test.validate.js     |   4 +-
 .../continued-fraction/test/test.validate.js  |   4 +-
 .../tools/unary/test/test.validate_table.js   |   6 +-
 .../test/test.validate.js                     |   4 +-
 .../@stdlib/ml/incr/kmeans/test/test.js       |  10 +-
 .../ml/incr/kmeans/test/test.validate.js      |   4 +-
 .../sgd-regression/test/test.eta_factory.js   |   2 +-
 .../ml/incr/sgd-regression/test/test.main.js  |   2 +-
 .../incr/sgd-regression/test/test.validate.js |   4 +-
 .../ndarray/ctor/test/test.validate.js        |   4 +-
 .../ndarray/ind2sub/test/test.validate.js     |   4 +-
 .../ndarray/iter/column-entries/test/test.js  |   2 +-
 .../@stdlib/ndarray/iter/columns/test/test.js |   2 +-
 .../@stdlib/ndarray/iter/entries/test/test.js |   2 +-
 .../@stdlib/ndarray/iter/indices/test/test.js |   2 +-
 .../iter/interleave-subarrays/test/test.js    |   2 +-
 .../ndarray/iter/matrices/test/test.js        |   2 +-
 .../ndarray/iter/matrix-entries/test/test.js  |   2 +-
 .../ndarray/iter/row-entries/test/test.js     |   2 +-
 .../@stdlib/ndarray/iter/rows/test/test.js    |   2 +-
 .../iter/select-dimension/test/test.js        |   2 +-
 .../@stdlib/ndarray/iter/stacks/test/test.js  |   2 +-
 .../ndarray/iter/subarrays/test/test.js       |   2 +-
 .../ndarray/iter/to-array-each/test/test.js   |   2 +-
 .../@stdlib/ndarray/iter/values/test/test.js  |   2 +-
 .../ndarray/mostly-safe-casts/test/test.js    |   2 +-
 .../@stdlib/ndarray/next-dtype/test/test.js   |   2 +-
 .../ndarray/promotion-rules/test/test.js      |   2 +-
 .../@stdlib/ndarray/safe-casts/test/test.js   |   2 +-
 .../ndarray/same-kind-casts/test/test.js      |   2 +-
 .../ndarray/sub2ind/test/test.validate.js     |   6 +-
 .../test/test.validate.js                     |   4 +-
 .../@stdlib/net/http-server/test/test.js      |   2 +-
 .../net/http-server/test/test.validate.js     |   4 +-
 .../simple-http-server/test/test.validate.js  |   4 +-
 .../@stdlib/nlp/lda/test/test.validate.js     |   4 +-
 .../nlp/ordinalize/test/test.validate.js      |   4 +-
 .../@stdlib/number/ctor/test/test.js          |   2 +-
 .../number/float64/to-json/test/test.js       |   8 +-
 .../@stdlib/os/configdir/test/test.js         |   4 +-
 .../@stdlib/os/homedir/test/test.homedir.js   |   6 +-
 .../@stdlib/process/getegid/test/test.js      |   8 +-
 .../process/getegid/test/test.polyfill.js     |   8 +-
 .../@stdlib/process/geteuid/test/test.js      |   8 +-
 .../process/geteuid/test/test.polyfill.js     |   8 +-
 .../@stdlib/process/getgid/test/test.js       |   8 +-
 .../process/getgid/test/test.polyfill.js      |   8 +-
 .../@stdlib/process/getuid/test/test.js       |   8 +-
 .../process/getuid/test/test.polyfill.js      |   8 +-
 .../minstd-shuffle/test/test.validate.js      |  12 +-
 .../random/array/minstd/test/test.validate.js |  12 +-
 .../array/mt19937/test/test.validate.js       |  12 +-
 .../random/array/randu/test/test.validate.js  |   4 +-
 .../@stdlib/random/iter/arcsine/test/test.js  |  16 +-
 .../random/iter/bernoulli/test/test.js        |  16 +-
 .../@stdlib/random/iter/beta/test/test.js     |  16 +-
 .../random/iter/betaprime/test/test.js        |  16 +-
 .../@stdlib/random/iter/binomial/test/test.js |  16 +-
 .../random/iter/box-muller/test/test.js       |  16 +-
 .../@stdlib/random/iter/cauchy/test/test.js   |  16 +-
 .../@stdlib/random/iter/chi/test/test.js      |  16 +-
 .../random/iter/chisquare/test/test.js        |  16 +-
 .../@stdlib/random/iter/cosine/test/test.js   |  16 +-
 .../random/iter/discrete-uniform/test/test.js |  16 +-
 .../@stdlib/random/iter/erlang/test/test.js   |  16 +-
 .../random/iter/exponential/test/test.js      |  16 +-
 .../@stdlib/random/iter/f/test/test.js        |  16 +-
 .../@stdlib/random/iter/frechet/test/test.js  |  16 +-
 .../@stdlib/random/iter/gamma/test/test.js    |  16 +-
 .../random/iter/geometric/test/test.js        |  16 +-
 .../@stdlib/random/iter/gumbel/test/test.js   |  16 +-
 .../random/iter/hypergeometric/test/test.js   |  16 +-
 .../iter/improved-ziggurat/test/test.js       |  16 +-
 .../@stdlib/random/iter/invgamma/test/test.js |  16 +-
 .../random/iter/kumaraswamy/test/test.js      |  16 +-
 .../@stdlib/random/iter/laplace/test/test.js  |  16 +-
 .../@stdlib/random/iter/levy/test/test.js     |  16 +-
 .../@stdlib/random/iter/logistic/test/test.js |  16 +-
 .../random/iter/lognormal/test/test.js        |  16 +-
 .../random/iter/minstd-shuffle/test/test.js   |  14 +-
 .../@stdlib/random/iter/minstd/test/test.js   |  14 +-
 .../@stdlib/random/iter/mt19937/test/test.js  |  14 +-
 .../iter/negative-binomial/test/test.js       |  16 +-
 .../@stdlib/random/iter/normal/test/test.js   |  16 +-
 .../random/iter/pareto-type1/test/test.js     |  16 +-
 .../@stdlib/random/iter/poisson/test/test.js  |  16 +-
 .../@stdlib/random/iter/randi/test/test.js    |  14 +-
 .../@stdlib/random/iter/randn/test/test.js    |  16 +-
 .../@stdlib/random/iter/randu/test/test.js    |  14 +-
 .../@stdlib/random/iter/rayleigh/test/test.js |  16 +-
 .../@stdlib/random/iter/t/test/test.js        |  16 +-
 .../random/iter/triangular/test/test.js       |  16 +-
 .../@stdlib/random/iter/uniform/test/test.js  |  16 +-
 .../@stdlib/random/iter/weibull/test/test.js  |  16 +-
 .../random/sample/test/test.factory.js        |   4 +-
 .../random/sample/test/test.validate.js       |   4 +-
 .../random/shuffle/test/test.validate.js      |   4 +-
 .../streams/arcsine/test/test.factory.js      |   8 +-
 .../streams/arcsine/test/test.validate.js     |   6 +-
 .../streams/bernoulli/test/test.factory.js    |   8 +-
 .../streams/bernoulli/test/test.validate.js   |   6 +-
 .../random/streams/beta/test/test.factory.js  |   8 +-
 .../random/streams/beta/test/test.validate.js |   6 +-
 .../streams/betaprime/test/test.factory.js    |   8 +-
 .../streams/betaprime/test/test.validate.js   |   6 +-
 .../streams/binomial/test/test.factory.js     |   8 +-
 .../streams/binomial/test/test.validate.js    |   6 +-
 .../streams/box-muller/test/test.factory.js   |   4 +-
 .../streams/box-muller/test/test.validate.js  |   6 +-
 .../streams/cauchy/test/test.factory.js       |   8 +-
 .../streams/cauchy/test/test.validate.js      |   6 +-
 .../random/streams/chi/test/test.factory.js   |   8 +-
 .../random/streams/chi/test/test.validate.js  |   6 +-
 .../streams/chisquare/test/test.factory.js    |   8 +-
 .../streams/chisquare/test/test.validate.js   |   6 +-
 .../streams/cosine/test/test.factory.js       |   8 +-
 .../streams/cosine/test/test.validate.js      |   6 +-
 .../discrete-uniform/test/test.factory.js     |   8 +-
 .../discrete-uniform/test/test.validate.js    |   6 +-
 .../streams/erlang/test/test.factory.js       |   8 +-
 .../streams/erlang/test/test.validate.js      |   6 +-
 .../streams/exponential/test/test.factory.js  |   8 +-
 .../streams/exponential/test/test.validate.js |   6 +-
 .../random/streams/f/test/test.factory.js     |   8 +-
 .../random/streams/f/test/test.validate.js    |   6 +-
 .../streams/frechet/test/test.factory.js      |   8 +-
 .../streams/frechet/test/test.validate.js     |   6 +-
 .../random/streams/gamma/test/test.factory.js |   8 +-
 .../streams/gamma/test/test.validate.js       |   6 +-
 .../streams/geometric/test/test.factory.js    |   8 +-
 .../streams/geometric/test/test.validate.js   |   6 +-
 .../streams/gumbel/test/test.factory.js       |   8 +-
 .../streams/gumbel/test/test.validate.js      |   6 +-
 .../hypergeometric/test/test.factory.js       |   8 +-
 .../hypergeometric/test/test.validate.js      |   6 +-
 .../improved-ziggurat/test/test.factory.js    |   4 +-
 .../improved-ziggurat/test/test.validate.js   |   6 +-
 .../streams/invgamma/test/test.factory.js     |   8 +-
 .../streams/invgamma/test/test.validate.js    |   6 +-
 .../streams/kumaraswamy/test/test.factory.js  |   8 +-
 .../streams/kumaraswamy/test/test.validate.js |   6 +-
 .../streams/laplace/test/test.factory.js      |   8 +-
 .../streams/laplace/test/test.validate.js     |   6 +-
 .../random/streams/levy/test/test.factory.js  |   8 +-
 .../random/streams/levy/test/test.validate.js |   6 +-
 .../streams/logistic/test/test.factory.js     |   8 +-
 .../streams/logistic/test/test.validate.js    |   6 +-
 .../streams/lognormal/test/test.factory.js    |   8 +-
 .../streams/lognormal/test/test.validate.js   |   6 +-
 .../minstd-shuffle/test/test.factory.js       |   4 +-
 .../minstd-shuffle/test/test.validate.js      |   6 +-
 .../streams/minstd/test/test.factory.js       |   4 +-
 .../streams/minstd/test/test.validate.js      |   6 +-
 .../streams/mt19937/test/test.factory.js      |   4 +-
 .../streams/mt19937/test/test.validate.js     |   6 +-
 .../negative-binomial/test/test.factory.js    |   8 +-
 .../negative-binomial/test/test.validate.js   |   6 +-
 .../streams/normal/test/test.factory.js       |   8 +-
 .../streams/normal/test/test.validate.js      |   6 +-
 .../streams/pareto-type1/test/test.factory.js |   8 +-
 .../pareto-type1/test/test.validate.js        |   6 +-
 .../streams/poisson/test/test.factory.js      |   8 +-
 .../streams/poisson/test/test.validate.js     |   6 +-
 .../random/streams/randi/test/test.factory.js |   4 +-
 .../streams/randi/test/test.validate.js       |   6 +-
 .../random/streams/randn/test/test.factory.js |   4 +-
 .../streams/randn/test/test.validate.js       |   6 +-
 .../random/streams/randu/test/test.factory.js |   4 +-
 .../streams/randu/test/test.validate.js       |   6 +-
 .../streams/rayleigh/test/test.factory.js     |   8 +-
 .../streams/rayleigh/test/test.validate.js    |   6 +-
 .../random/streams/t/test/test.factory.js     |   8 +-
 .../random/streams/t/test/test.validate.js    |   6 +-
 .../streams/triangular/test/test.factory.js   |   8 +-
 .../streams/triangular/test/test.validate.js  |   6 +-
 .../streams/uniform/test/test.factory.js      |   8 +-
 .../streams/uniform/test/test.validate.js     |   6 +-
 .../streams/weibull/test/test.factory.js      |   8 +-
 .../streams/weibull/test/test.validate.js     |   6 +-
 .../decimal-number/test/test.validate.js      |   4 +-
 .../@stdlib/regexp/eol/test/test.validate.js  |   4 +-
 .../regexp/whitespace/test/test.validate.js   |   4 +-
 .../@stdlib/repl/server/test/test.example.js  |   2 +-
 .../@stdlib/repl/server/test/test.validate.js |   4 +-
 .../@stdlib/simulate/iter/awgn/test/test.js   |  34 ++--
 .../@stdlib/simulate/iter/awln/test/test.js   |  34 ++--
 .../@stdlib/simulate/iter/awun/test/test.js   |  34 ++--
 .../iter/bartlett-hann-pulse/test/test.js     |  10 +-
 .../bartlett-hann-pulse/test/test.validate.js |   4 +-
 .../simulate/iter/bartlett-pulse/test/test.js |  10 +-
 .../iter/bartlett-pulse/test/test.validate.js |   4 +-
 .../simulate/iter/cosine-wave/test/test.js    |  10 +-
 .../iter/cosine-wave/test/test.validate.js    |   4 +-
 .../simulate/iter/dirac-comb/test/test.js     |  10 +-
 .../iter/dirac-comb/test/test.validate.js     |   4 +-
 .../simulate/iter/flat-top-pulse/test/test.js |  10 +-
 .../iter/flat-top-pulse/test/test.validate.js |   4 +-
 .../simulate/iter/hann-pulse/test/test.js     |  10 +-
 .../iter/hann-pulse/test/test.validate.js     |   4 +-
 .../simulate/iter/lanczos-pulse/test/test.js  |  10 +-
 .../iter/lanczos-pulse/test/test.validate.js  |   4 +-
 .../simulate/iter/periodic-sinc/test/test.js  |  10 +-
 .../iter/periodic-sinc/test/test.validate.js  |   4 +-
 .../@stdlib/simulate/iter/pulse/test/test.js  |  10 +-
 .../simulate/iter/pulse/test/test.validate.js |   4 +-
 .../simulate/iter/sawtooth-wave/test/test.js  |  10 +-
 .../iter/sawtooth-wave/test/test.validate.js  |   4 +-
 .../simulate/iter/sine-wave/test/test.js      |  10 +-
 .../iter/sine-wave/test/test.validate.js      |   4 +-
 .../simulate/iter/square-wave/test/test.js    |  10 +-
 .../iter/square-wave/test/test.validate.js    |   4 +-
 .../simulate/iter/triangle-wave/test/test.js  |  10 +-
 .../iter/triangle-wave/test/test.validate.js  |   4 +-
 .../stats/anova1/test/test.validate.js        |   4 +-
 .../stats/bartlett-test/test/test.validate.js |   4 +-
 .../dists/arcsine/cdf/test/test.factory.js    |   2 +-
 .../dists/arcsine/logcdf/test/test.factory.js |   2 +-
 .../dists/arcsine/logpdf/test/test.factory.js |   2 +-
 .../dists/arcsine/pdf/test/test.factory.js    |   2 +-
 .../arcsine/quantile/test/test.factory.js     |   2 +-
 .../dists/bernoulli/cdf/test/test.factory.js  |   2 +-
 .../dists/bernoulli/mgf/test/test.factory.js  |   2 +-
 .../dists/bernoulli/pmf/test/test.factory.js  |   2 +-
 .../bernoulli/quantile/test/test.factory.js   |   2 +-
 .../base/dists/beta/cdf/test/test.factory.js  |   2 +-
 .../dists/beta/logcdf/test/test.factory.js    |   2 +-
 .../dists/beta/logpdf/test/test.factory.js    |   2 +-
 .../base/dists/beta/mgf/test/test.factory.js  |   2 +-
 .../base/dists/beta/pdf/test/test.factory.js  |   2 +-
 .../dists/beta/quantile/test/test.factory.js  |   2 +-
 .../dists/betaprime/cdf/test/test.factory.js  |   2 +-
 .../betaprime/logcdf/test/test.factory.js     |   2 +-
 .../betaprime/logpdf/test/test.factory.js     |   2 +-
 .../dists/betaprime/pdf/test/test.factory.js  |   2 +-
 .../betaprime/quantile/test/test.factory.js   |   2 +-
 .../dists/binomial/cdf/test/test.factory.js   |   2 +-
 .../binomial/logpmf/test/test.factory.js      |   2 +-
 .../dists/binomial/mgf/test/test.factory.js   |   2 +-
 .../dists/binomial/pmf/test/test.factory.js   |   2 +-
 .../binomial/quantile/test/test.factory.js    |   2 +-
 .../dists/bradford/cdf/test/test.factory.js   |   2 +-
 .../dists/bradford/pdf/test/test.factory.js   |   2 +-
 .../bradford/quantile/test/test.factory.js    |   2 +-
 .../dists/cauchy/cdf/test/test.factory.js     |   2 +-
 .../dists/cauchy/logcdf/test/test.factory.js  |   2 +-
 .../dists/cauchy/logpdf/test/test.factory.js  |   2 +-
 .../dists/cauchy/pdf/test/test.factory.js     |   2 +-
 .../cauchy/quantile/test/test.factory.js      |   2 +-
 .../base/dists/chi/cdf/test/test.factory.js   |   2 +-
 .../dists/chi/logpdf/test/test.factory.js     |   2 +-
 .../base/dists/chi/pdf/test/test.factory.js   |   2 +-
 .../dists/chi/quantile/test/test.factory.js   |   2 +-
 .../dists/chisquare/cdf/test/test.factory.js  |   2 +-
 .../chisquare/logpdf/test/test.factory.js     |   2 +-
 .../dists/chisquare/mgf/test/test.factory.js  |   2 +-
 .../dists/chisquare/pdf/test/test.factory.js  |   2 +-
 .../chisquare/quantile/test/test.factory.js   |   2 +-
 .../dists/cosine/cdf/test/test.factory.js     |   2 +-
 .../dists/cosine/logcdf/test/test.factory.js  |   2 +-
 .../dists/cosine/logpdf/test/test.factory.js  |   2 +-
 .../dists/cosine/mgf/test/test.factory.js     |   2 +-
 .../dists/cosine/pdf/test/test.factory.js     |   2 +-
 .../cosine/quantile/test/test.factory.js      |   2 +-
 .../dists/degenerate/cdf/test/test.factory.js |   2 +-
 .../degenerate/logcdf/test/test.factory.js    |   2 +-
 .../degenerate/logpdf/test/test.factory.js    |   2 +-
 .../degenerate/logpmf/test/test.factory.js    |   2 +-
 .../dists/degenerate/mgf/test/test.factory.js |   2 +-
 .../dists/degenerate/pdf/test/test.factory.js |   2 +-
 .../dists/degenerate/pmf/test/test.factory.js |   2 +-
 .../degenerate/quantile/test/test.factory.js  |   2 +-
 .../discrete-uniform/cdf/test/test.factory.js |   2 +-
 .../logcdf/test/test.factory.js               |   2 +-
 .../logpmf/test/test.factory.js               |   2 +-
 .../discrete-uniform/mgf/test/test.factory.js |   2 +-
 .../discrete-uniform/pmf/test/test.factory.js |   2 +-
 .../quantile/test/test.factory.js             |   2 +-
 .../dists/erlang/cdf/test/test.factory.js     |   2 +-
 .../dists/erlang/logpdf/test/test.factory.js  |   2 +-
 .../dists/erlang/mgf/test/test.factory.js     |   2 +-
 .../dists/erlang/pdf/test/test.factory.js     |   2 +-
 .../erlang/quantile/test/test.factory.js      |   2 +-
 .../exponential/cdf/test/test.factory.js      |   2 +-
 .../exponential/logcdf/test/test.factory.js   |   2 +-
 .../exponential/logpdf/test/test.factory.js   |   2 +-
 .../exponential/mgf/test/test.factory.js      |   2 +-
 .../exponential/pdf/test/test.factory.js      |   2 +-
 .../exponential/quantile/test/test.factory.js |   2 +-
 .../base/dists/f/cdf/test/test.factory.js     |   2 +-
 .../base/dists/f/pdf/test/test.factory.js     |   2 +-
 .../dists/f/quantile/test/test.factory.js     |   2 +-
 .../dists/frechet/cdf/test/test.factory.js    |   2 +-
 .../dists/frechet/logcdf/test/test.factory.js |   2 +-
 .../dists/frechet/logpdf/test/test.factory.js |   2 +-
 .../dists/frechet/pdf/test/test.factory.js    |   2 +-
 .../frechet/quantile/test/test.factory.js     |   6 +-
 .../base/dists/gamma/cdf/test/test.factory.js |   2 +-
 .../dists/gamma/logcdf/test/test.factory.js   |   2 +-
 .../dists/gamma/logpdf/test/test.factory.js   |   2 +-
 .../base/dists/gamma/mgf/test/test.factory.js |   2 +-
 .../base/dists/gamma/pdf/test/test.factory.js |   2 +-
 .../dists/gamma/quantile/test/test.factory.js |   2 +-
 .../dists/geometric/cdf/test/test.factory.js  |   2 +-
 .../geometric/logcdf/test/test.factory.js     |   2 +-
 .../geometric/logpmf/test/test.factory.js     |   2 +-
 .../dists/geometric/mgf/test/test.factory.js  |   2 +-
 .../dists/geometric/pmf/test/test.factory.js  |   2 +-
 .../geometric/quantile/test/test.factory.js   |   2 +-
 .../dists/gumbel/cdf/test/test.factory.js     |   2 +-
 .../dists/gumbel/logcdf/test/test.factory.js  |   2 +-
 .../dists/gumbel/logpdf/test/test.factory.js  |   2 +-
 .../dists/gumbel/mgf/test/test.factory.js     |   4 +-
 .../dists/gumbel/pdf/test/test.factory.js     |   2 +-
 .../gumbel/quantile/test/test.factory.js      |   2 +-
 .../hypergeometric/cdf/test/test.factory.js   |   2 +-
 .../logpmf/test/test.factory.js               |   2 +-
 .../hypergeometric/pmf/test/test.factory.js   |   2 +-
 .../quantile/test/test.factory.js             |   2 +-
 .../dists/invgamma/cdf/test/test.factory.js   |   2 +-
 .../invgamma/logpdf/test/test.factory.js      |   2 +-
 .../dists/invgamma/pdf/test/test.factory.js   |   2 +-
 .../invgamma/quantile/test/test.factory.js    |   2 +-
 .../kumaraswamy/cdf/test/test.factory.js      |   4 +-
 .../kumaraswamy/logcdf/test/test.factory.js   |   4 +-
 .../kumaraswamy/logpdf/test/test.factory.js   |   2 +-
 .../kumaraswamy/pdf/test/test.factory.js      |   4 +-
 .../kumaraswamy/quantile/test/test.factory.js |   4 +-
 .../dists/laplace/cdf/test/test.factory.js    |   2 +-
 .../dists/laplace/logcdf/test/test.factory.js |   2 +-
 .../dists/laplace/logpdf/test/test.factory.js |   2 +-
 .../dists/laplace/mgf/test/test.factory.js    |   2 +-
 .../dists/laplace/pdf/test/test.factory.js    |   2 +-
 .../laplace/quantile/test/test.factory.js     |   2 +-
 .../base/dists/levy/cdf/test/test.factory.js  |   2 +-
 .../dists/levy/logcdf/test/test.factory.js    |   2 +-
 .../dists/levy/logpdf/test/test.factory.js    |   2 +-
 .../base/dists/levy/pdf/test/test.factory.js  |   2 +-
 .../dists/levy/quantile/test/test.factory.js  |   2 +-
 .../dists/logistic/cdf/test/test.factory.js   |   2 +-
 .../logistic/logcdf/test/test.factory.js      |   2 +-
 .../logistic/logpdf/test/test.factory.js      |   2 +-
 .../dists/logistic/mgf/test/test.factory.js   |   2 +-
 .../dists/logistic/pdf/test/test.factory.js   |   2 +-
 .../logistic/quantile/test/test.factory.js    |   2 +-
 .../dists/lognormal/cdf/test/test.factory.js  |   2 +-
 .../lognormal/logcdf/test/test.factory.js     |   2 +-
 .../lognormal/logpdf/test/test.factory.js     |   2 +-
 .../dists/lognormal/pdf/test/test.factory.js  |   2 +-
 .../lognormal/quantile/test/test.factory.js   |   2 +-
 .../cdf/test/test.factory.js                  |   2 +-
 .../logpmf/test/test.factory.js               |   2 +-
 .../mgf/test/test.factory.js                  |   4 +-
 .../pmf/test/test.factory.js                  |   2 +-
 .../quantile/test/test.factory.js             |   2 +-
 .../dists/normal/cdf/test/test.factory.js     |   2 +-
 .../dists/normal/logcdf/test/test.factory.js  |   2 +-
 .../dists/normal/logpdf/test/test.factory.js  |   2 +-
 .../dists/normal/mgf/test/test.factory.js     |   2 +-
 .../dists/normal/pdf/test/test.factory.js     |   2 +-
 .../normal/quantile/test/test.factory.js      |   2 +-
 .../pareto-type1/cdf/test/test.factory.js     |   2 +-
 .../pareto-type1/logcdf/test/test.factory.js  |   2 +-
 .../pareto-type1/logpdf/test/test.factory.js  |   2 +-
 .../pareto-type1/pdf/test/test.factory.js     |   2 +-
 .../quantile/test/test.factory.js             |   2 +-
 .../dists/planck/cdf/test/test.factory.js     |   2 +-
 .../dists/planck/logcdf/test/test.factory.js  |   2 +-
 .../dists/planck/logpmf/test/test.factory.js  |   2 +-
 .../dists/planck/mgf/test/test.factory.js     |   2 +-
 .../dists/planck/pmf/test/test.factory.js     |   2 +-
 .../planck/quantile/test/test.factory.js      |   2 +-
 .../dists/poisson/cdf/test/test.factory.js    |   2 +-
 .../dists/poisson/logpmf/test/test.factory.js |   2 +-
 .../dists/poisson/mgf/test/test.factory.js    |   2 +-
 .../dists/poisson/pmf/test/test.factory.js    |   2 +-
 .../poisson/quantile/test/test.factory.js     |   2 +-
 .../dists/rayleigh/cdf/test/test.factory.js   |   2 +-
 .../rayleigh/logcdf/test/test.factory.js      |   2 +-
 .../rayleigh/logpdf/test/test.factory.js      |   2 +-
 .../dists/rayleigh/mgf/test/test.factory.js   |   4 +-
 .../dists/rayleigh/pdf/test/test.factory.js   |   2 +-
 .../rayleigh/quantile/test/test.factory.js    |   2 +-
 .../dists/signrank/cdf/test/test.factory.js   |   2 +-
 .../dists/signrank/pdf/test/test.factory.js   |   2 +-
 .../signrank/quantile/test/test.factory.js    |   2 +-
 .../cdf/test/test.factory.js                  |   2 +-
 .../quantile/test/test.factory.js             |   2 +-
 .../base/dists/t/cdf/test/test.factory.js     |   2 +-
 .../base/dists/t/logcdf/test/test.factory.js  |   2 +-
 .../base/dists/t/logpdf/test/test.factory.js  |   2 +-
 .../base/dists/t/pdf/test/test.factory.js     |   2 +-
 .../dists/t/quantile/test/test.factory.js     |   2 +-
 .../dists/triangular/cdf/test/test.factory.js |   2 +-
 .../triangular/logcdf/test/test.factory.js    |   2 +-
 .../triangular/logpdf/test/test.factory.js    |   2 +-
 .../dists/triangular/mgf/test/test.factory.js |   2 +-
 .../dists/triangular/pdf/test/test.factory.js |   2 +-
 .../triangular/quantile/test/test.factory.js  |   2 +-
 .../dists/uniform/cdf/test/test.factory.js    |   2 +-
 .../dists/uniform/logcdf/test/test.factory.js |   2 +-
 .../dists/uniform/logpdf/test/test.factory.js |   2 +-
 .../dists/uniform/mgf/test/test.factory.js    |   2 +-
 .../dists/uniform/pdf/test/test.factory.js    |   2 +-
 .../uniform/quantile/test/test.factory.js     |   2 +-
 .../dists/weibull/cdf/test/test.factory.js    |   2 +-
 .../dists/weibull/logcdf/test/test.factory.js |   2 +-
 .../dists/weibull/logpdf/test/test.factory.js |   2 +-
 .../dists/weibull/mgf/test/test.factory.js    |   4 +-
 .../dists/weibull/pdf/test/test.factory.js    |   2 +-
 .../weibull/quantile/test/test.factory.js     |   2 +-
 .../stats/binomial-test/test/test.validate.js |   4 +-
 .../stats/chi2gof/test/test.validate.js       |   4 +-
 .../stats/chi2test/test/test.validate.js      |   4 +-
 .../stats/fligner-test/test/test.validate.js  |   4 +-
 .../@stdlib/stats/incr/apcorr/test/test.js    |   8 +-
 .../@stdlib/stats/incr/count/test/test.js     |   2 +-
 .../stats/incr/covariance/test/test.js        |   8 +-
 .../@stdlib/stats/incr/covmat/test/test.js    |   8 +-
 .../@stdlib/stats/incr/cv/test/test.js        |   8 +-
 .../@stdlib/stats/incr/ewmean/test/test.js    |   2 +-
 .../@stdlib/stats/incr/ewstdev/test/test.js   |   2 +-
 .../stats/incr/ewvariance/test/test.js        |   2 +-
 .../@stdlib/stats/incr/gmean/test/test.js     |   2 +-
 .../@stdlib/stats/incr/grubbs/test/test.js    |   4 +-
 .../@stdlib/stats/incr/hmean/test/test.js     |   2 +-
 .../@stdlib/stats/incr/kurtosis/test/test.js  |  12 +-
 .../@stdlib/stats/incr/maape/test/test.js     |   2 +-
 .../@stdlib/stats/incr/mae/test/test.js       |   2 +-
 .../@stdlib/stats/incr/mapcorr/test/test.js   |   8 +-
 .../@stdlib/stats/incr/mape/test/test.js      |   2 +-
 .../@stdlib/stats/incr/max/test/test.js       |   4 +-
 .../@stdlib/stats/incr/maxabs/test/test.js    |   4 +-
 .../stats/incr/mcovariance/test/test.js       |   8 +-
 .../@stdlib/stats/incr/mcv/test/test.js       |   8 +-
 .../@stdlib/stats/incr/mda/test/test.js       |   2 +-
 .../@stdlib/stats/incr/me/test/test.js        |   2 +-
 .../@stdlib/stats/incr/mean/test/test.js      |   2 +-
 .../@stdlib/stats/incr/meanabs/test/test.js   |   2 +-
 .../@stdlib/stats/incr/meanabs2/test/test.js  |   2 +-
 .../@stdlib/stats/incr/meanstdev/test/test.js |  12 +-
 .../@stdlib/stats/incr/meanvar/test/test.js   |  12 +-
 .../@stdlib/stats/incr/mgmean/test/test.js    |   4 +-
 .../@stdlib/stats/incr/mgrubbs/test/test.js   |   4 +-
 .../stats/incr/mgrubbs/test/test.meanstdev.js |   2 +-
 .../stats/incr/mgrubbs/test/test.minmax.js    |   2 +-
 .../@stdlib/stats/incr/mhmean/test/test.js    |   4 +-
 .../@stdlib/stats/incr/midrange/test/test.js  |   4 +-
 .../@stdlib/stats/incr/min/test/test.js       |   4 +-
 .../@stdlib/stats/incr/minabs/test/test.js    |   4 +-
 .../@stdlib/stats/incr/minmax/test/test.js    |   6 +-
 .../@stdlib/stats/incr/minmaxabs/test/test.js |   6 +-
 .../@stdlib/stats/incr/mmaape/test/test.js    |   4 +-
 .../@stdlib/stats/incr/mmae/test/test.js      |   4 +-
 .../@stdlib/stats/incr/mmape/test/test.js     |   4 +-
 .../@stdlib/stats/incr/mmax/test/test.js      |   4 +-
 .../@stdlib/stats/incr/mmaxabs/test/test.js   |   4 +-
 .../@stdlib/stats/incr/mmda/test/test.js      |   4 +-
 .../@stdlib/stats/incr/mme/test/test.js       |   4 +-
 .../@stdlib/stats/incr/mmean/test/test.js     |   4 +-
 .../@stdlib/stats/incr/mmeanabs/test/test.js  |   4 +-
 .../@stdlib/stats/incr/mmeanabs2/test/test.js |   4 +-
 .../stats/incr/mmeanstdev/test/test.js        |   6 +-
 .../@stdlib/stats/incr/mmeanvar/test/test.js  |   6 +-
 .../@stdlib/stats/incr/mmidrange/test/test.js |   4 +-
 .../@stdlib/stats/incr/mmin/test/test.js      |   4 +-
 .../@stdlib/stats/incr/mminabs/test/test.js   |   4 +-
 .../@stdlib/stats/incr/mminmax/test/test.js   |   6 +-
 .../stats/incr/mminmaxabs/test/test.js        |   6 +-
 .../@stdlib/stats/incr/mmpe/test/test.js      |   4 +-
 .../@stdlib/stats/incr/mmse/test/test.js      |   4 +-
 .../@stdlib/stats/incr/mpcorr/test/test.js    |   8 +-
 .../@stdlib/stats/incr/mpcorr2/test/test.js   |   8 +-
 .../stats/incr/mpcorrdist/test/test.js        |   8 +-
 .../@stdlib/stats/incr/mpe/test/test.js       |   2 +-
 .../@stdlib/stats/incr/mprod/test/test.js     |   4 +-
 .../@stdlib/stats/incr/mrange/test/test.js    |   4 +-
 .../@stdlib/stats/incr/mrmse/test/test.js     |   4 +-
 .../@stdlib/stats/incr/mrss/test/test.js      |   4 +-
 .../@stdlib/stats/incr/mse/test/test.js       |   2 +-
 .../@stdlib/stats/incr/mstdev/test/test.js    |   8 +-
 .../@stdlib/stats/incr/msum/test/test.js      |   4 +-
 .../@stdlib/stats/incr/msumabs/test/test.js   |   4 +-
 .../@stdlib/stats/incr/msumabs2/test/test.js  |   4 +-
 .../@stdlib/stats/incr/msummary/test/test.js  |   2 +-
 .../@stdlib/stats/incr/msumprod/test/test.js  |   4 +-
 .../@stdlib/stats/incr/mvariance/test/test.js |   8 +-
 .../@stdlib/stats/incr/mvmr/test/test.js      |   8 +-
 .../@stdlib/stats/incr/nancount/test/test.js  |   2 +-
 .../@stdlib/stats/incr/nanmaxabs/test/test.js |   4 +-
 .../stats/incr/nanmeanabs/test/test.js        |   2 +-
 .../@stdlib/stats/incr/nanmstdev/test/test.js |   8 +-
 .../@stdlib/stats/incr/nanmsum/test/test.js   |   2 +-
 .../stats/incr/nanskewness/test/test.js       |   4 +-
 .../@stdlib/stats/incr/nansum/test/test.js    |   2 +-
 .../@stdlib/stats/incr/nansumabs/test/test.js |   2 +-
 .../stats/incr/nansumabs2/test/test.js        |   2 +-
 .../@stdlib/stats/incr/pcorr/test/test.js     |   8 +-
 .../@stdlib/stats/incr/pcorr2/test/test.js    |   8 +-
 .../@stdlib/stats/incr/pcorrdist/test/test.js |   8 +-
 .../stats/incr/pcorrdistmat/test/test.js      |   8 +-
 .../@stdlib/stats/incr/pcorrmat/test/test.js  |   8 +-
 .../@stdlib/stats/incr/prod/test/test.js      |   9 +-
 .../@stdlib/stats/incr/range/test/test.js     |   4 +-
 .../@stdlib/stats/incr/rmse/test/test.js      |   2 +-
 .../@stdlib/stats/incr/rss/test/test.js       |   2 +-
 .../@stdlib/stats/incr/skewness/test/test.js  |  10 +-
 .../@stdlib/stats/incr/sum/test/test.js       |   2 +-
 .../@stdlib/stats/incr/sumabs/test/test.js    |   2 +-
 .../@stdlib/stats/incr/sumabs2/test/test.js   |   2 +-
 .../@stdlib/stats/incr/summary/test/test.js   |   2 +-
 .../@stdlib/stats/incr/sumprod/test/test.js   |   2 +-
 .../@stdlib/stats/incr/variance/test/test.js  |   8 +-
 .../@stdlib/stats/incr/vmr/test/test.js       |   8 +-
 .../@stdlib/stats/incr/wmean/test/test.js     |   2 +-
 .../@stdlib/stats/iter/cugmean/test/test.js   |  14 +-
 .../@stdlib/stats/iter/cuhmean/test/test.js   |  14 +-
 .../@stdlib/stats/iter/cumax/test/test.js     |  14 +-
 .../@stdlib/stats/iter/cumaxabs/test/test.js  |  14 +-
 .../@stdlib/stats/iter/cumean/test/test.js    |  14 +-
 .../@stdlib/stats/iter/cumeanabs/test/test.js |  14 +-
 .../stats/iter/cumeanabs2/test/test.js        |  14 +-
 .../stats/iter/cumidrange/test/test.js        |  14 +-
 .../@stdlib/stats/iter/cumin/test/test.js     |  14 +-
 .../@stdlib/stats/iter/cuminabs/test/test.js  |  14 +-
 .../@stdlib/stats/iter/cuprod/test/test.js    |  14 +-
 .../@stdlib/stats/iter/curange/test/test.js   |  14 +-
 .../@stdlib/stats/iter/cusum/test/test.js     |  14 +-
 .../@stdlib/stats/iter/cusumabs/test/test.js  |  14 +-
 .../@stdlib/stats/iter/cusumabs2/test/test.js |  14 +-
 .../@stdlib/stats/iter/mmax/test/test.js      |  14 +-
 .../@stdlib/stats/iter/mmaxabs/test/test.js   |  14 +-
 .../@stdlib/stats/iter/mmean/test/test.js     |  14 +-
 .../@stdlib/stats/iter/mmeanabs/test/test.js  |  14 +-
 .../@stdlib/stats/iter/mmeanabs2/test/test.js |  14 +-
 .../@stdlib/stats/iter/mmidrange/test/test.js |  14 +-
 .../@stdlib/stats/iter/mmin/test/test.js      |  14 +-
 .../@stdlib/stats/iter/mminabs/test/test.js   |  14 +-
 .../@stdlib/stats/iter/mprod/test/test.js     |  14 +-
 .../@stdlib/stats/iter/mrange/test/test.js    |  14 +-
 .../@stdlib/stats/iter/msum/test/test.js      |  14 +-
 .../@stdlib/stats/iter/msumabs/test/test.js   |  14 +-
 .../@stdlib/stats/iter/msumabs2/test/test.js  |  14 +-
 .../@stdlib/stats/kde2d/test/test.validate.js |   4 +-
 .../stats/kruskal-test/test/test.validate.js  |   4 +-
 .../stats/kstest/test/test.validate.js        |   4 +-
 .../stats/levene-test/test/test.validate.js   |   4 +-
 .../stats/lowess/test/test.validate.js        |   4 +-
 .../stats/pcorrtest/test/test.validate.js     |   4 +-
 .../@stdlib/stats/ranks/test/test.validate.js |   4 +-
 .../@stdlib/stats/ttest/test/test.validate.js |   4 +-
 .../stats/ttest2/test/test.validate.js        |   4 +-
 .../stats/vartest/test/test.validate.js       |   4 +-
 .../stats/wilcoxon/test/test.validate.js      |   4 +-
 .../@stdlib/stats/ztest/test/test.validate.js |   4 +-
 .../stats/ztest2/test/test.validate.js        |   4 +-
 .../node/debug-sink/test/test.factory.js      |   4 +-
 .../node/debug-sink/test/test.validate.js     |   4 +-
 .../streams/node/debug/test/test.factory.js   |   4 +-
 .../streams/node/debug/test/test.validate.js  |   4 +-
 .../streams/node/empty/test/test.factory.js   |   4 +-
 .../streams/node/empty/test/test.validate.js  |   6 +-
 .../node/from-array/test/test.factory.js      |   4 +-
 .../node/from-array/test/test.validate.js     |   6 +-
 .../from-circular-array/test/test.factory.js  |   4 +-
 .../from-circular-array/test/test.validate.js |   6 +-
 .../node/from-constant/test/test.factory.js   |   8 +-
 .../node/from-constant/test/test.validate.js  |   6 +-
 .../node/from-iterator/test/test.factory.js   |   4 +-
 .../node/from-iterator/test/test.validate.js  |   6 +-
 .../from-strided-array/test/test.factory.js   |   4 +-
 .../from-strided-array/test/test.validate.js  |   6 +-
 .../node/inspect-sink/test/test.factory.js    |   4 +-
 .../node/inspect-sink/test/test.validate.js   |   4 +-
 .../streams/node/inspect/test/test.factory.js |   4 +-
 .../node/inspect/test/test.validate.js        |   4 +-
 .../streams/node/join/test/test.factory.js    |   4 +-
 .../streams/node/join/test/test.validate.js   |   4 +-
 .../streams/node/split/test/test.factory.js   |   4 +-
 .../streams/node/split/test/test.validate.js  |   4 +-
 .../node/transform/test/test.factory.js       |   4 +-
 .../node/transform/test/test.validate.js      |   4 +-
 .../string/acronym/test/test.validate.js      |   4 +-
 .../string/num2words/test/test.validate.js    |   4 +-
 .../@stdlib/string/pad/test/test.validate.js  |   4 +-
 .../test/test.js                              |  32 ++--
 .../to-grapheme-cluster-iterator/test/test.js |  32 ++--
 .../@stdlib/symbol/ctor/test/test.js          |   4 +-
 .../utils/argument-function/test/test.js      |   2 +-
 .../async/any-by-right/test/test.factory.js   |  42 ++---
 .../async/any-by-right/test/test.validate.js  |   4 +-
 .../utils/async/any-by/test/test.factory.js   |  42 ++---
 .../utils/async/any-by/test/test.validate.js  |   4 +-
 .../async/bifurcate-by/test/test.factory.js   |   4 +-
 .../async/bifurcate-by/test/test.validate.js  |   4 +-
 .../@stdlib/utils/async/compose/test/test.js  |   2 +-
 .../utils/async/count-by/test/test.factory.js |   4 +-
 .../async/count-by/test/test.validate.js      |   4 +-
 .../async/every-by-right/test/test.factory.js |  42 ++---
 .../every-by-right/test/test.validate.js      |   4 +-
 .../utils/async/every-by/test/test.factory.js |  42 ++---
 .../async/every-by/test/test.validate.js      |   4 +-
 .../async/for-each-right/test/test.factory.js |   4 +-
 .../for-each-right/test/test.validate.js      |   4 +-
 .../utils/async/for-each/test/test.factory.js |   4 +-
 .../async/for-each/test/test.validate.js      |   4 +-
 .../async/function-sequence/test/test.js      |   2 +-
 .../utils/async/group-by/test/test.factory.js |   4 +-
 .../async/group-by/test/test.validate.js      |   4 +-
 .../async/inmap-right/test/test.factory.js    |   4 +-
 .../async/inmap-right/test/test.validate.js   |   4 +-
 .../utils/async/inmap/test/test.factory.js    |   4 +-
 .../utils/async/inmap/test/test.validate.js   |   4 +-
 .../async/map-function/test/test.factory.js   |   4 +-
 .../async/map-function/test/test.validate.js  |   4 +-
 .../utils/async/map-keys/test/test.factory.js |   4 +-
 .../async/map-keys/test/test.validate.js      |   4 +-
 .../async/map-values/test/test.factory.js     |   4 +-
 .../async/map-values/test/test.validate.js    |   4 +-
 .../async/none-by-right/test/test.factory.js  |  42 ++---
 .../async/none-by-right/test/test.validate.js |   4 +-
 .../utils/async/none-by/test/test.factory.js  |  42 ++---
 .../utils/async/none-by/test/test.validate.js |   4 +-
 .../async/reduce-right/test/test.factory.js   |   4 +-
 .../async/reduce-right/test/test.validate.js  |   4 +-
 .../utils/async/reduce/test/test.factory.js   |   4 +-
 .../utils/async/reduce/test/test.validate.js  |   4 +-
 .../series-waterfall/test/test.factory.js     |   2 +-
 .../async/some-by-right/test/test.factory.js  |  42 ++---
 .../async/some-by-right/test/test.validate.js |   4 +-
 .../utils/async/some-by/test/test.factory.js  |  42 ++---
 .../utils/async/some-by/test/test.validate.js |   4 +-
 .../async/tabulate-by/test/test.factory.js    |   4 +-
 .../async/tabulate-by/test/test.validate.js   |   4 +-
 .../utils/bifurcate-by/test/test.validate.js  |   4 +-
 .../utils/bifurcate-in/test/test.validate.js  |   4 +-
 .../utils/bifurcate-own/test/test.validate.js |   4 +-
 .../utils/bifurcate/test/test.validate.js     |   4 +-
 .../@stdlib/utils/compose/test/test.js        |   2 +-
 .../utils/constant-function/test/test.js      |   2 +-
 .../utils/count-by/test/test.validate.js      |   4 +-
 .../@stdlib/utils/curry-right/test/test.js    |  30 ++--
 .../@stdlib/utils/curry/test/test.js          |  30 ++--
 .../utils/deep-get/test/test.factory.js       |   2 +-
 .../utils/deep-get/test/test.validate.js      |   4 +-
 .../utils/deep-pluck/test/test.validate.js    |   4 +-
 .../utils/deep-set/test/test.factory.js       |  14 +-
 .../utils/deep-set/test/test.validate.js      |   4 +-
 .../utils/filter-arguments/test/test.js       |   2 +-
 .../utils/flatten-array/test/test.factory.js  |   4 +-
 .../utils/flatten-array/test/test.validate.js |   4 +-
 .../utils/flatten-object/test/test.factory.js |   2 +-
 .../flatten-object/test/test.validate.js      |   4 +-
 .../utils/function-sequence/test/test.js      |   2 +-
 .../utils/get-prototype-of/test/test.js       |   2 +-
 .../get-prototype-of/test/test.native.js      |   2 +-
 .../get-prototype-of/test/test.polyfill.js    |   2 +-
 .../@stdlib/utils/global/test/test.browser.js |   2 +-
 .../@stdlib/utils/global/test/test.js         |   2 +-
 .../utils/group-by/test/test.validate.js      |   4 +-
 .../utils/group-in/test/test.validate.js      |   4 +-
 .../utils/group-own/test/test.validate.js     |   4 +-
 .../@stdlib/utils/group/test/test.validate.js |   4 +-
 .../@stdlib/utils/key-by-right/test/test.js   |   2 +-
 .../@stdlib/utils/key-by/test/test.js         |   2 +-
 .../utils/library-manifest/test/test.cli.js   |   2 +-
 .../utils/library-manifest/test/test.js       |  18 +--
 .../library-manifest/test/test.validate.js    |   4 +-
 .../@stdlib/utils/map-arguments/test/test.js  |   2 +-
 .../@stdlib/utils/mask-arguments/test/test.js |   2 +-
 .../@stdlib/utils/memoize/test/test.js        |   5 +-
 .../@stdlib/utils/merge/test/test.defaults.js |   2 +-
 .../@stdlib/utils/merge/test/test.factory.js  |   2 +-
 .../@stdlib/utils/merge/test/test.validate.js |   4 +-
 .../@stdlib/utils/nary-function/test/test.js  |   2 +-
 .../@stdlib/utils/papply-right/test/test.js   |   4 +-
 .../@stdlib/utils/papply/test/test.js         |   4 +-
 .../utils/parallel/test/test.node.env.js      |   2 +-
 .../utils/parallel/test/test.node.options.js  |   2 +-
 .../utils/parallel/test/test.validate.js      |   4 +-
 .../@stdlib/utils/parse-json/test/test.js     |   4 +-
 .../@stdlib/utils/pick-arguments/test/test.js |   2 +-
 .../@stdlib/utils/pluck/test/test.validate.js |   4 +-
 .../utils/reject-arguments/test/test.js       |   2 +-
 .../utils/reorder-arguments/test/test.js      |   2 +-
 .../utils/reverse-arguments/test/test.js      |   2 +-
 .../utils/tabulate-by/test/test.validate.js   |   4 +-
 .../utils/timeit/test/test.validate.js        |   4 +-
 .../utils/timeit/test/test.vm_compile.js      |   2 +-
 .../@stdlib/utils/try-function/test/test.js   |   2 +-
 .../@stdlib/utils/uncurry-right/test/test.js  |   2 +-
 .../@stdlib/utils/uncurry/test/test.js        |   2 +-
 1041 files changed, 3391 insertions(+), 3387 deletions(-)

diff --git a/lib/node_modules/@stdlib/_tools/benchmarks/browser-build/test/test.validate.js b/lib/node_modules/@stdlib/_tools/benchmarks/browser-build/test/test.validate.js
index 39a85a542a76..55a007b5965a 100644
--- a/lib/node_modules/@stdlib/_tools/benchmarks/browser-build/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/benchmarks/browser-build/test/test.validate.js
@@ -201,7 +201,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -220,7 +220,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.validate.js b/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.validate.js
index 46ac1c52a011..a0a3e59d49e0 100644
--- a/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/benchmarks/bundle/test/test.validate.js
@@ -120,7 +120,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -139,7 +139,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/benchmarks/html/test/test.validate.js b/lib/node_modules/@stdlib/_tools/benchmarks/html/test/test.validate.js
index 8a388b894d9b..1ac37ff0baa1 100644
--- a/lib/node_modules/@stdlib/_tools/benchmarks/html/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/benchmarks/html/test/test.validate.js
@@ -120,7 +120,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -139,7 +139,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.validate.js b/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.validate.js
index 7c0150579f8d..10529d6ab22a 100644
--- a/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/bib/citation-reference/test/test.validate.js
@@ -123,7 +123,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.database, opts.database, 'sets database option' );
 	t.strictEqual( obj.csl, opts.csl, 'sets csl option' );
 
@@ -143,7 +143,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/bundle/pkg-list/test/test.validate.js b/lib/node_modules/@stdlib/_tools/bundle/pkg-list/test/test.validate.js
index 61554176ab83..bf78f5ffe26e 100644
--- a/lib/node_modules/@stdlib/_tools/bundle/pkg-list/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/bundle/pkg-list/test/test.validate.js
@@ -378,7 +378,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -396,7 +396,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/changelog/generate/test/test.validate.js b/lib/node_modules/@stdlib/_tools/changelog/generate/test/test.validate.js
index 241ad78045bc..a2d54ba1507a 100644
--- a/lib/node_modules/@stdlib/_tools/changelog/generate/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/changelog/generate/test/test.validate.js
@@ -142,7 +142,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.copy, opts.copy, 'sets copy option' );
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.validate.js b/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.validate.js
index c1950740bdba..e0e3484a5ff3 100644
--- a/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/changelog/parse-commits/test/test.validate.js
@@ -176,7 +176,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.issueURL, opts.issueURL, 'sets issueURL option' );
 	t.strictEqual( obj.prURL, opts.prURL, 'sets prURL option' );
@@ -197,7 +197,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/doctest/compare-values/test/test.js b/lib/node_modules/@stdlib/_tools/doctest/compare-values/test/test.js
index 8e0aff9d4741..c43cf8c857a1 100644
--- a/lib/node_modules/@stdlib/_tools/doctest/compare-values/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/doctest/compare-values/test/test.js
@@ -55,35 +55,35 @@ tape( 'the function compares primitives and a corresponding matching return anno
 
 	actual = NaN;
 	expected = 'NaN';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = true;
 	expected = 'true';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = null;
 	expected = 'null';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = undefined;
 	expected = 'undefined';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = 2.13;
 	expected = '2.13';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = 2.133131;
 	expected = '~2.13';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = 2.133131e-10;
 	expected = '~2.13e-10';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = '2.13';
 	expected = '\'2.13\'';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	t.end();
 });
@@ -143,11 +143,11 @@ tape( 'the function compares an array and a corresponding return annotation', fu
 
 	actual = [ 0, 2, 3 ];
 	expected = '[ 0, 2, 3 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 0, 2, 3 ];
 	expected = '[ <number>, <number>,  <number> ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 0, 2, 3 ];
 	expected = '[ <number>, <number>, <boolean> ]';
@@ -156,51 +156,51 @@ tape( 'the function compares an array and a corresponding return annotation', fu
 
 	actual = [ +0, -0 ];
 	expected = '[ +0, -0 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ true, false, 0, 1 ];
 	expected = '[ <boolean>, ... ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [];
 	expected = '[]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ NaN, null ];
 	expected = '[ NaN, null ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ NaN, NaN ];
 	expected = '[ NaN, NaN ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 1, void 0, void 0, 0.5 ];
 	expected = '[ 1, , , 0.5 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 1, void 0, void 0, 0.5 ];
 	expected = '[ 1,,,0.5 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 1, void 0, void 0, 0.5 ];
 	expected = '[ 1, undefined, undefined, 0.5 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 2, Infinity ];
 	expected = '[ 2, Infinity ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 2, +Infinity ];
 	expected = '[ 2, Infinity ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 2, Infinity ];
 	expected = '[ 2, +Infinity ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 2, -Infinity ];
 	expected = '[ 2, -Infinity ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 0, 2, 3 ];
 	expected = '[ 0, 2, 2 ]';
@@ -209,11 +209,11 @@ tape( 'the function compares an array and a corresponding return annotation', fu
 
 	actual = [ 0, 20, 40, 60, 80, 100 ];
 	expected = '[ 0, 20, 40, 60, 80, 100 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 1, 2.51188643150958, 6.309573444801933, 15.848931924611142 ];
 	expected = '[ 1, ~2.5, ~6.31, ~15.85 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 1, 2.51188643150958, 6.309573444801933, 15.848931924611142 ];
 	expected = '[ 1, ~2.5, ~6.31, 15.85 ]';
@@ -222,11 +222,11 @@ tape( 'the function compares an array and a corresponding return annotation', fu
 
 	actual = [ -3.8111, 3.8111 ];
 	expected = '[ ~-3.81, ~3.81 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ [ 3, 60 ], [ 2, 50 ] ];
 	expected = '[ [3, 60], [2, 50] ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [
 		{
@@ -240,11 +240,11 @@ tape( 'the function compares an array and a corresponding return annotation', fu
 		}
 	];
 	expected = '[ {...}, 222 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 1, undefined, undefined, 2 ];
 	expected = '[ 1, undefined, undefined, 2 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ 1, null, null, 2 ];
 	expected = '[ 1, null, undefined, 2 ]';
@@ -253,7 +253,7 @@ tape( 'the function compares an array and a corresponding return annotation', fu
 
 	actual = [ /beep/, /boop/ ];
 	expected = '[ /beep/, /boop/ ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = [ /beep/, /boop/ ];
 	expected = '[ /beep/, /boop/i ]';
@@ -267,12 +267,12 @@ tape( 'the function compares an array and a corresponding return annotation', fu
 		null
 	];
 	expected = '[ ..., \'c\', \'bip\', ... ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	// eslint-disable-next-line
 	actual = [[[10,8.04],[8,6.95],[13,7.58],[9,8.81],[11,8.33],[14,9.96],[6,7.24],[4,4.26],[12,10.84],[7,4.82],[5,5.68]],[[10,9.14],[8,8.14],[13,8.74],[9,8.77],[11,9.26],[14,8.1],[6,6.13],[4,3.1],[12,9.13],[7,7.26],[5,4.74]],[[10,7.46],[8,6.77],[13,12.74],[9,7.11],[11,7.81],[14,8.84],[6,6.08],[4,5.39],[12,8.15],[7,6.42],[5,5.73]],[[8,6.58],[8,5.76],[8,7.71],[8,8.84],[8,8.47],[8,7.04],[8,5.25],[19,12.5],[8,5.56],[8,7.91],[8,6.89]]];
 	expected = '[[[10,8.04],...],[[10,9.14],...],[[10,7.46],...],[[8,6.58],...]]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	t.end();
 });
@@ -285,11 +285,11 @@ tape( 'the function compares a typed array and a corresponding return annotation
 
 	actual = new Float64Array( [ 0, 2, 3 ] );
 	expected = '<Float64Array>[ 0, 2, 3 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = new Float64Array( [ 0.16666666666666666, 0.5158304763865204 ] );
 	expected = '<Float64Array>[ ~0.167, ~0.516 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = new Float64Array( [ 0, 2, 3 ] );
 	expected = '<Float64Array>[ 0, 2, 2 ]';
@@ -304,12 +304,12 @@ tape( 'the function compares a typed array and a corresponding return annotation
 	buf = new Float32Array( [ 1.0, -1.0, 2.0, -2.0 ] );
 	actual = new Complex64Array( buf );
 	expected = '<Complex64Array>[ 1.0, -1.0, 2.0, -2.0 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	buf = new Float64Array( [ 1.0, -1.0, 2.0, -2.0 ] );
 	actual = new Complex128Array( buf );
 	expected = '<Complex128Array>[ 1.0, -1.0, 2.0, -2.0 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	buf = new Float64Array( [ 1.0, -1.0, 2.0, -2.0 ] );
 	actual = new Complex128Array( buf );
@@ -319,7 +319,7 @@ tape( 'the function compares a typed array and a corresponding return annotation
 
 	actual = new BooleanArray( [ true, false, true, false ] );
 	expected = '<BooleanArray>[ true, false, true, false ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = new BooleanArray( [ true, false, true, false ] );
 	expected = '<BooleanArray>[ true, true, true, true ]';
@@ -336,11 +336,11 @@ tape( 'the function compares a complex number and a corresponding return annotat
 
 	actual = new Complex64( 2.0, 3.0 );
 	expected = '<Complex64>';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = new Complex64( 2.0, 3.0 );
 	expected = '<Complex64>[ 2.0, 3.0 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = new Complex64( 2.0, 3.0 );
 	expected = '<Complex64>[ 2.0, 4.0 ]';
@@ -349,11 +349,11 @@ tape( 'the function compares a complex number and a corresponding return annotat
 
 	actual = new Complex128( 2.0, 3.0 );
 	expected = '<Complex128>';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = new Complex128( 2.0, 3.0 );
 	expected = '<Complex128>[ 2.0, 3.0 ]';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = new Complex128( 2.0, 3.0 );
 	expected = '<Complex128>[ 2.0, 4.0 ]';
@@ -375,7 +375,7 @@ tape( 'the function compares a value with a type equality return annotation', fu
 
 	actual = 2.3;
 	expected = '<number>';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = 2.3;
 	expected = '<string>';
@@ -389,7 +389,7 @@ tape( 'the function compares a value with a type equality return annotation', fu
 
 	actual = true;
 	expected = '<boolean>';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = true;
 	expected = '<number>';
@@ -403,11 +403,11 @@ tape( 'the function compares a value with a type equality return annotation', fu
 
 	actual = new ArrayBuffer( 10 );
 	expected = '<ArrayBuffer>';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = compareValues;
 	expected = '<Function>';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	t.end();
 });
@@ -419,7 +419,7 @@ tape( 'the function differentiates between boxed and primitive values', function
 
 	actual = 2.3;
 	expected = '<number>';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = 2.3;
 	expected = '<Number>';
@@ -433,7 +433,7 @@ tape( 'the function differentiates between boxed and primitive values', function
 
 	actual = 2.3;
 	expected = '<number>';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = 'beep';
 	expected = '<String>';
@@ -457,7 +457,7 @@ tape( 'the function differentiates between boxed and primitive values', function
 
 	actual = false;
 	expected = '<boolean>';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	t.end();
 });
@@ -473,7 +473,7 @@ tape( 'the function compares plain objects and corresponding return annotations'
 		'd:bar': 'bar'
 	};
 	expected = '{ \'a:beep\': \'beep\', \'b:boop\': \'boop\', \'c:foo\': \'foo\', \'d:bar\': \'bar\' }';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = {
 		'beep': {
@@ -483,21 +483,21 @@ tape( 'the function compares plain objects and corresponding return annotations'
 		'boop': 'baz'
 	};
 	expected = '{ \'beep\': {...}, ... }';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = {
 		'b': 2,
 		'c': NaN
 	};
 	expected = '{ \'b\': 2, \'c\': NaN }';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = {
 		'constructor': function Foo() {},
 		'beep': 'boop'
 	};
 	expected = '{ \'beep\': {...}, ... }';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	t.end();
 });
@@ -509,19 +509,19 @@ tape( 'the function compares a regular expression and a corresponding return ann
 
 	actual = /beep/;
 	expected = '/beep/';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = /[0-9]+/g;
 	expected = '/[0-9]+/g';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = /[0-9a-z]+/gi;
 	expected = '/[0-9a-z]+/gi';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = /[0-9a-z]+/gim;
 	expected = '/[0-9a-z]+/gim';
-	t.strictEqual( compareValues( actual, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( actual, expected ), null, 'returns expected value' );
 
 	actual = /[0-9a-z]+/gi;
 	expected = '/[0-9a-z]+/g';
@@ -541,7 +541,7 @@ tape( 'the function compares a function and a corresponding return annotation',
 	var msg;
 
 	expected = 'function identity( x ) {\n\t\treturn x;\n\t}';
-	t.strictEqual( compareValues( identity, expected ), null, 'returns null' );
+	t.strictEqual( compareValues( identity, expected ), null, 'returns expected value' );
 
 	expected = 'function noop() {}';
 	msg = 'Displayed return value is `function noop() {}`, but expected `function identity( x ) {\n\t\treturn x;\n\t}` instead';
diff --git a/lib/node_modules/@stdlib/_tools/doctest/create-annotation-value/test/test.validate.js b/lib/node_modules/@stdlib/_tools/doctest/create-annotation-value/test/test.validate.js
index 5a9dd0e2b74b..b87c83e154c9 100644
--- a/lib/node_modules/@stdlib/_tools/doctest/create-annotation-value/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/doctest/create-annotation-value/test/test.validate.js
@@ -166,7 +166,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'decimal': true
 	};
 	obj = {};
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.strictEqual( obj.decimal, true, 'sets decimal option' );
 
 	opts = {
@@ -174,7 +174,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'boop': false
 	};
 	obj = {};
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.headers.js
index 23914b75c73e..11b08b6fb712 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.headers.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.options.js
index 119ee7e2928c..bb2000201739 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.options.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.ratelimit.js
index eecf98077f9b..2eaa8fd1f738 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.ratelimit.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.strictEqual( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.request.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.request.js
index f3de46ffc618..112c53ddf955 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.request.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.request.js
@@ -141,7 +141,7 @@ tape( 'if a query is successful, a JSON object is returned to a provided callbac
 			t.fail( error.message );
 		} else {
 			t.strictEqual( typeof response, 'object', 'second argument is an object' );
-			t.strictEqual( typeof body, 'object', 'returns an object' );
+			t.strictEqual( typeof body, 'object', 'returns expected value' );
 			t.deepEqual( body, data, 'returns expected value' );
 		}
 		t.end();
@@ -169,7 +169,7 @@ tape( 'the function supports HTTPS', function test( t ) {
 			t.fail( error.message );
 		} else {
 			t.strictEqual( typeof response, 'object', 'second argument is an object' );
-			t.strictEqual( typeof body, 'object', 'returns an object' );
+			t.strictEqual( typeof body, 'object', 'returns expected value' );
 			t.deepEqual( body, data, 'returns expected value' );
 		}
 		t.end();
diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.validate.js
index 9c77322a7ba6..6222f2bff979 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.validate.js
@@ -386,7 +386,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -411,7 +411,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.factory.js
index 83c4e7dd88dc..5cd158ef83af 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.factory.js
@@ -87,7 +87,7 @@ tape( 'the function throws if provided a callback argument which is not a functi
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.headers.js
index 9a1820b7f112..e61a0c1bf39f 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.headers.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.options.js
index 88ee51955fcd..496754004150 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.options.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.ratelimit.js
index 7b604422ded7..a411edd0e67a 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.ratelimit.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.strictEqual( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.request.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.request.js
index 5a02d32da63c..38ec576311ef 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.request.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.request.js
@@ -149,7 +149,7 @@ tape( 'if a query is successful, a JSON object is returned to a provided callbac
 		}
 		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.strictEqual( typeof body, 'object', 'returns an object' );
+		t.strictEqual( typeof body, 'object', 'returns expected value' );
 		t.deepEqual( body, data, 'deep equal' );
 
 		t.end();
@@ -180,7 +180,7 @@ tape( 'HTTPS is supported', function test( t ) {
 		}
 		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.strictEqual( typeof body, 'object', 'returns an object' );
+		t.strictEqual( typeof body, 'object', 'returns expected value' );
 
 		t.deepEqual( body, data, 'deep equal' );
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.validate.js
index a093341ab051..b6e8eaa62dff 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.validate.js
@@ -535,7 +535,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets all options' );
 
 	t.end();
@@ -551,7 +551,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.headers.js
index 07c26f966e53..40959c8e895d 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.headers.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.options.js
index ba3845cab823..554e87c979c6 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.options.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.ratelimit.js
index 7b604422ded7..a411edd0e67a 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.ratelimit.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.strictEqual( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.request.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.request.js
index a39c95b25562..9457d4db136e 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.request.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.request.js
@@ -149,7 +149,7 @@ tape( 'if a query is successful, a JSON object is returned to a provided callbac
 		}
 		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.strictEqual( typeof body, 'object', 'returns an object' );
+		t.strictEqual( typeof body, 'object', 'returns expected value' );
 		t.deepEqual( body, data, 'deep equal' );
 
 		t.end();
@@ -180,7 +180,7 @@ tape( 'HTTPS is supported', function test( t ) {
 		}
 		t.strictEqual( typeof response, 'object', 'second argument is an object' );
 
-		t.strictEqual( typeof body, 'object', 'returns an object' );
+		t.strictEqual( typeof body, 'object', 'returns expected value' );
 
 		t.deepEqual( body, data, 'deep equal' );
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.validate.js
index 38837c6a942b..cc6913e826d6 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.validate.js
@@ -409,7 +409,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets all options' );
 
 	t.end();
@@ -428,7 +428,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.headers.js
index c6edc2d9319e..142d5d43c019 100644
--- a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.headers.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.options.js
index 593eb517258f..0865ae899077 100644
--- a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.options.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.ratelimit.js
index 7b604422ded7..a411edd0e67a 100644
--- a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.ratelimit.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.strictEqual( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.validate.js
index 13861587c9b7..b56b50bacf06 100644
--- a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.validate.js
@@ -192,7 +192,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets all options' );
 
 	t.end();
@@ -209,7 +209,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.headers.js
index f01ccb8dba2b..7077a8498d73 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.headers.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.options.js
index 0680d6b40a02..c36a22d64dda 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.options.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.ratelimit.js
index bbcc90900aa6..f8799b0daaf4 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.ratelimit.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.strictEqual( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.validate.js
index 69f2595d5bca..4aeb528ee1a7 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.validate.js
@@ -295,7 +295,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -320,7 +320,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.factory.js
index fbab8e4ba790..ed5412d78fbf 100644
--- a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.factory.js
@@ -125,7 +125,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( 'README.md', repos, noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( 'README.md', repos, noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.options.js
index c4865dcd3754..73dcbad76c7f 100644
--- a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.options.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.resolve.js b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.resolve.js
index 880bb0802dca..15d6cbb0e6c6 100644
--- a/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.resolve.js
+++ b/lib/node_modules/@stdlib/_tools/github/fetch-file/test/test.resolve.js
@@ -119,7 +119,7 @@ tape( 'the function returns a JSON object upon attempting to resolve a file from
 		if ( error ) {
 			t.ok( false, error.message );
 		} else {
-			t.strictEqual( typeof results, 'object', 'returns an object' );
+			t.strictEqual( typeof results, 'object', 'returns expected value' );
 		}
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/followers/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/followers/test/test.factory.js
index 65432485cb2f..e6aa419f11b3 100644
--- a/lib/node_modules/@stdlib/_tools/github/followers/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/followers/test/test.factory.js
@@ -97,7 +97,7 @@ tape( 'function throws if not provided either a username or token', function tes
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/followers/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/followers/test/test.validate.js
index d01a55d4fcc6..bb98256ad819 100644
--- a/lib/node_modules/@stdlib/_tools/github/followers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/followers/test/test.validate.js
@@ -138,7 +138,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'username': 'beepboop',
 		'useragent': 'beeper-booper'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/following/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/following/test/test.factory.js
index 6086cec13916..e1047774df43 100644
--- a/lib/node_modules/@stdlib/_tools/github/following/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/following/test/test.factory.js
@@ -97,7 +97,7 @@ tape( 'function throws if not provided either a username or token', function tes
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/following/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/following/test/test.validate.js
index d01a55d4fcc6..bb98256ad819 100644
--- a/lib/node_modules/@stdlib/_tools/github/following/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/following/test/test.validate.js
@@ -138,7 +138,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'username': 'beepboop',
 		'useragent': 'beeper-booper'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.factory.js
index 75876ee52f81..cd134f6637ab 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.factory.js
@@ -129,7 +129,7 @@ tape( 'the function throws if provided a callback argument which is not a functi
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.headers.js
index 890fcee7b969..e335b402f95d 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.headers.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.options.js
index 974b8ceb7dce..4b85fa771f80 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.options.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.ratelimit.js
index 1cfad1e1b077..a270d9c9b0a9 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.ratelimit.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.strictEqual( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.request.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.request.js
index 8b940c0a9d23..b86996096216 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.request.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.request.js
@@ -140,7 +140,7 @@ tape( 'if a query is successful, a JSON object is returned to a provided callbac
 			t.fail( error.message );
 		} else {
 			t.strictEqual( typeof response, 'object', 'second argument is an object' );
-			t.strictEqual( typeof body, 'object', 'returns an object' );
+			t.strictEqual( typeof body, 'object', 'returns expected value' );
 			t.deepEqual( body, data, 'returns expected value' );
 		}
 		t.end();
@@ -168,7 +168,7 @@ tape( 'the function supports HTTPS', function test( t ) {
 			t.fail( error.message );
 		} else {
 			t.strictEqual( typeof response, 'object', 'second argument is an object' );
-			t.strictEqual( typeof body, 'object', 'returns an object' );
+			t.strictEqual( typeof body, 'object', 'returns expected value' );
 			t.deepEqual( body, data, 'returns expected value' );
 		}
 		t.end();
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.validate.js
index ee71637a8e23..18dcd24fe209 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.validate.js
@@ -418,7 +418,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -438,7 +438,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.factory.js
index bab40a31ba8e..293f069f01c7 100644
--- a/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.factory.js
@@ -95,7 +95,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.validate.js
index ed1ce9408991..528eaa65a3a0 100644
--- a/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/org-repos/test/test.validate.js
@@ -173,7 +173,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'type': 'forks',
 		'useragent': 'beeper-booper'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
@@ -188,7 +188,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.factory.js
index f01173cbb8e3..9f5f0af6d659 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.factory.js
@@ -97,7 +97,7 @@ tape( 'function throws if not provided either a username or token', function tes
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.validate.js
index fdcc7873477d..8095627de239 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-followers/test/test.validate.js
@@ -164,7 +164,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'useragent': 'beeper-booper',
 		'method': 'followers'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
@@ -178,7 +178,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.factory.js
index dad93053ecdc..405cc5adf071 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.factory.js
@@ -95,7 +95,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.validate.js
index 3d4575e064de..374bb14f9507 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.validate.js
@@ -161,7 +161,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'useragent': 'beeper-booper',
 		'method': 'followers'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
@@ -175,7 +175,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.factory.js
index 7f74707f92b6..6e8b559c143d 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.factory.js
@@ -86,7 +86,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.headers.js
index c593f2485ff2..0d84d522148f 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.headers.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.options.js
index 520d2d6af252..dc3ced292694 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.options.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.ratelimit.js
index 7b604422ded7..a411edd0e67a 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.ratelimit.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.strictEqual( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.validate.js
index 92abc7e470ce..75b0d38cd27d 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.validate.js
@@ -125,7 +125,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets all options' );
 
 	t.end();
@@ -141,7 +141,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.factory.js
index 35074e16ee27..8c27beb84402 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.factory.js
@@ -86,7 +86,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.headers.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.headers.js
index e63dc6cb0316..33a13e08cb38 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.headers.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.headers.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof headers( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof headers( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.options.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.options.js
index 13b164af2999..656223d22add 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.options.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.options.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof options( setup() ), 'object', 'returns an object' );
+	t.strictEqual( typeof options( setup() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.ratelimit.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.ratelimit.js
index 7b604422ded7..a411edd0e67a 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.ratelimit.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.ratelimit.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var info = ratelimit( setup() );
-	t.strictEqual( typeof info, 'object', 'returns an object' );
+	t.strictEqual( typeof info, 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.validate.js
index 92abc7e470ce..75b0d38cd27d 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.validate.js
@@ -125,7 +125,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets all options' );
 
 	t.end();
@@ -141,7 +141,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/starred/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/starred/test/test.factory.js
index 8fea0f698295..e97c99f93268 100644
--- a/lib/node_modules/@stdlib/_tools/github/starred/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/starred/test/test.factory.js
@@ -97,7 +97,7 @@ tape( 'function throws if not provided either a username or token', function tes
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/starred/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/starred/test/test.validate.js
index 0791c2c4e3fd..1f267570f65d 100644
--- a/lib/node_modules/@stdlib/_tools/github/starred/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/starred/test/test.validate.js
@@ -190,7 +190,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'sort': 'updated',
 		'direction': 'asc'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
@@ -204,7 +204,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.factory.js
index 943cb3d9434f..86d04e2d6c1d 100644
--- a/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.factory.js
@@ -97,7 +97,7 @@ tape( 'function throws if not provided either a username or token', function tes
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.validate.js
index d01a55d4fcc6..bb98256ad819 100644
--- a/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/subscriptions/test/test.validate.js
@@ -138,7 +138,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'username': 'beepboop',
 		'useragent': 'beeper-booper'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.factory.js
index ab9067546db9..39707d60df80 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.factory.js
@@ -109,7 +109,7 @@ tape( 'function throws if not provided usernames', function test( t ) {
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.get.js b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.get.js
index d8d184fed10c..871f3df476ca 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.get.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.get.js
@@ -123,7 +123,7 @@ tape( 'the function returns a JSON object upon attempting to resolve all specifi
 		if ( error ) {
 			t.ok( false, error.message );
 		} else {
-			t.strictEqual( typeof data, 'object', 'returns an object' );
+			t.strictEqual( typeof data, 'object', 'returns expected value' );
 		}
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.validate.js
index cbb91395dd89..a5d494b92e2d 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-details/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-details/test/test.validate.js
@@ -149,7 +149,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'token': 'abcdefg',
 		'useragent': 'beeper-booper'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
@@ -164,7 +164,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.factory.js
index ecac65cac20e..c66e309df415 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.factory.js
@@ -97,7 +97,7 @@ tape( 'function throws if not provided either a username or token', function tes
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.validate.js
index b125a7a2e94a..4344df5eb12d 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-orgs/test/test.validate.js
@@ -164,7 +164,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'useragent': 'beeper-booper',
 		'state': 'active'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
@@ -178,7 +178,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.factory.js
index 6e60248eb653..05ce9701d550 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.factory.js
@@ -97,7 +97,7 @@ tape( 'function throws if not provided a token', function test( t ) {
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.validate.js
index 7c79a8a399be..2afb8c3ccb80 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-rate-limit/test/test.validate.js
@@ -119,7 +119,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'token': 'abcdefg',
 		'useragent': 'beeper-booper'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.factory.js
index f00a34c76581..3b6733585a9b 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.factory.js
@@ -97,7 +97,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.validate.js
index a642bb5f2951..4980ea28c103 100644
--- a/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/user-repos/test/test.validate.js
@@ -268,7 +268,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'visibility': 'all',
 		'affiliation': 'owner,collaborator,organization_member'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
@@ -282,7 +282,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.factory.js b/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.factory.js
index 8bfbb9f2248c..4bd6085bb290 100644
--- a/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.factory.js
@@ -95,7 +95,7 @@ tape( 'function throws if provided a callback argument which is not a function',
 });
 
 tape( 'function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( getOpts(), noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.validate.js b/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.validate.js
index 875587ecad65..1b5b2287a45f 100644
--- a/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/github/workflow-runs/test/test.validate.js
@@ -147,7 +147,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'type': 'forks',
 		'useragent': 'beeper-booper'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
@@ -162,7 +162,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 		'b': null,
 		'c': 'woot'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/licenses/header-regexp-table/test/test.js b/lib/node_modules/@stdlib/_tools/licenses/header-regexp-table/test/test.js
index 5c1ef250507c..f581b8b2e0e6 100644
--- a/lib/node_modules/@stdlib/_tools/licenses/header-regexp-table/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/licenses/header-regexp-table/test/test.js
@@ -233,7 +233,7 @@ tape( 'if provided an empty `types` argument, the function returns an empty obje
 	out = createTable( 'Apache-2.0', [] );
 	keys = objectKeys( out );
 
-	t.strictEqual( isObject( out ), true, 'returns an object' );
+	t.strictEqual( isObject( out ), true, 'returns expected value' );
 	t.strictEqual( keys.length, 0, 'is empty' );
 
 	t.end();
@@ -246,7 +246,7 @@ tape( 'the function returns an object mapping file types to license header regul
 	var i;
 
 	out = createTable( 'Apache-2.0' );
-	t.strictEqual( isObject( out ), true, 'returns an object' );
+	t.strictEqual( isObject( out ), true, 'returns expected value' );
 
 	keys = objectKeys( out );
 	for ( i = 0; i < keys.length; i++ ) {
@@ -264,7 +264,7 @@ tape( 'the function returns an object mapping file types to license header regul
 	var i;
 
 	out = createTable( 'Apache-2.0', LANGS );
-	t.strictEqual( isObject( out ), true, 'returns an object' );
+	t.strictEqual( isObject( out ), true, 'returns expected value' );
 
 	for ( i = 0; i < LANGS.length; i++ ) {
 		re = out[ LANGS[ i ] ];
diff --git a/lib/node_modules/@stdlib/_tools/licenses/header/test/test.validate.js b/lib/node_modules/@stdlib/_tools/licenses/header/test/test.validate.js
index 5bf5396e8721..29b29ba94ca3 100644
--- a/lib/node_modules/@stdlib/_tools/licenses/header/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/licenses/header/test/test.validate.js
@@ -127,7 +127,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -145,7 +145,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/links/create/test/test.sync.js b/lib/node_modules/@stdlib/_tools/links/create/test/test.sync.js
index 5d999f9db866..69fe12fd4036 100644
--- a/lib/node_modules/@stdlib/_tools/links/create/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/links/create/test/test.sync.js
@@ -105,7 +105,7 @@ tape( 'the function inserts a link to a link database', function test( t ) {
 		]
 	};
 	out = create( opts );
-	t.strictEqual( out, null, 'returns null' );
+	t.strictEqual( out, null, 'returns expected value' );
 	t.end();
 
 	function mock( database, out ) {
@@ -136,7 +136,7 @@ tape( 'the created entry will have a period at the end of description even if fo
 		'database': database
 	};
 	out = create( opts );
-	t.strictEqual( out, null, 'returns null' );
+	t.strictEqual( out, null, 'returns expected value' );
 	t.end();
 
 	function mock( database, out ) {
@@ -171,7 +171,7 @@ tape( 'the keywords of the created entry will have whitespace trimmed from both
 		]
 	};
 	out = create( opts );
-	t.strictEqual( out, null, 'returns null' );
+	t.strictEqual( out, null, 'returns expected value' );
 	t.end();
 
 	function mock( database, out ) {
diff --git a/lib/node_modules/@stdlib/_tools/links/create/test/test.validate.js b/lib/node_modules/@stdlib/_tools/links/create/test/test.validate.js
index eff55bdbeb0e..919d6e433197 100644
--- a/lib/node_modules/@stdlib/_tools/links/create/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/links/create/test/test.validate.js
@@ -241,7 +241,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -268,7 +268,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'only sets mandatory options' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.async.js b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.async.js
index 2fa6cb476396..56be0ca9d911 100644
--- a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.async.js
@@ -172,7 +172,7 @@ tape( 'the function returns `null` if the id is not found in the database', func
 		if ( error ) {
 			t.ok( false, 'did not expect an error' );
 		}
-		t.strictEqual( uri, null, 'returns null' );
+		t.strictEqual( uri, null, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.sync.js b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.sync.js
index 3a13bebd8c1f..0e65fbccfc41 100644
--- a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.sync.js
@@ -75,7 +75,7 @@ tape( 'the function returns the URI corresponding to a given id', function test(
 
 tape( 'the function returns `null` if the id is not found in the database', function test( t ) {
 	var out = id2uri( 'not-there' );
-	t.strictEqual( out, null, 'returns null' );
+	t.strictEqual( out, null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.validate.js b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.validate.js
index 6c3886d76000..553075ce509f 100644
--- a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.validate.js
@@ -90,7 +90,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -108,7 +108,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.async.js b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.async.js
index 501ad115a823..6bf00966f8e9 100644
--- a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.async.js
@@ -173,7 +173,7 @@ tape( 'the function returns `null` if the URI is not found in the database', fun
 		if ( error ) {
 			t.ok( false, 'did not expect an error' );
 		}
-		t.strictEqual( uri, null, 'returns null' );
+		t.strictEqual( uri, null, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.sync.js b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.sync.js
index 8be719262bea..37b53bac762b 100644
--- a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.sync.js
@@ -76,7 +76,7 @@ tape( 'the function returns the id corresponding to a given URI', function test(
 
 tape( 'the function returns `null` if the URI is not found in the database', function test( t ) {
 	var out = uri2id( 'https://www.not-there.com' );
-	t.strictEqual( out, null, 'returns null' );
+	t.strictEqual( out, null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.validate.js b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.validate.js
index 6c3886d76000..553075ce509f 100644
--- a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.validate.js
@@ -90,7 +90,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -108,7 +108,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/validate/test/test.validate.js b/lib/node_modules/@stdlib/_tools/links/validate/test/test.validate.js
index 49da082ccad6..cf4093631a3c 100644
--- a/lib/node_modules/@stdlib/_tools/links/validate/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/links/validate/test/test.validate.js
@@ -90,7 +90,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -108,7 +108,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.validate.js b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.validate.js
index dd420e4d9a2f..fb2073434af2 100644
--- a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.validate.js
@@ -123,7 +123,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 
@@ -143,7 +143,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.validate.js b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.validate.js
index 49808b06bf6b..aa3e6949d5eb 100644
--- a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.validate.js
@@ -95,7 +95,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.validate.js b/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.validate.js
index 05058de573d8..668392ad008f 100644
--- a/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.validate.js
@@ -207,7 +207,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 
@@ -227,7 +227,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/lint/namespace-aliases/test/test.validate.js b/lib/node_modules/@stdlib/_tools/lint/namespace-aliases/test/test.validate.js
index 85319125198f..bb00990e3a4d 100644
--- a/lib/node_modules/@stdlib/_tools/lint/namespace-aliases/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/lint/namespace-aliases/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
@@ -116,7 +116,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/lint/pkg-json/test/test.sync.js b/lib/node_modules/@stdlib/_tools/lint/pkg-json/test/test.sync.js
index 1e03ce30cd78..b5fe25d79f5f 100644
--- a/lib/node_modules/@stdlib/_tools/lint/pkg-json/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/lint/pkg-json/test/test.sync.js
@@ -119,7 +119,7 @@ tape( 'the function returns `null` if unable to resolve any `package.json` files
 	});
 
 	errs = lint();
-	t.strictEqual( errs, null, 'returns null' );
+	t.strictEqual( errs, null, 'returns expected value' );
 	t.end();
 
 	function glob() {
diff --git a/lib/node_modules/@stdlib/_tools/lint/pkg-json/test/test.validate.js b/lib/node_modules/@stdlib/_tools/lint/pkg-json/test/test.validate.js
index e412bea5affb..4d2914e12950 100644
--- a/lib/node_modules/@stdlib/_tools/lint/pkg-json/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/lint/pkg-json/test/test.validate.js
@@ -177,7 +177,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -198,7 +198,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/lint/repl-txt/test/test.sync.js b/lib/node_modules/@stdlib/_tools/lint/repl-txt/test/test.sync.js
index 5d37f64e62bf..368c2819e10a 100644
--- a/lib/node_modules/@stdlib/_tools/lint/repl-txt/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/lint/repl-txt/test/test.sync.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if unable to resolve any `repl.txt` files', f
 	});
 
 	errs = lint();
-	t.strictEqual( errs, null, 'returns null' );
+	t.strictEqual( errs, null, 'returns expected value' );
 	t.end();
 
 	function glob() {
diff --git a/lib/node_modules/@stdlib/_tools/lint/repl-txt/test/test.validate.js b/lib/node_modules/@stdlib/_tools/lint/repl-txt/test/test.validate.js
index e3d4a4970bc8..5a16546528ec 100644
--- a/lib/node_modules/@stdlib/_tools/lint/repl-txt/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/lint/repl-txt/test/test.validate.js
@@ -154,7 +154,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -175,7 +175,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/manifest-json/schema/test/test.js b/lib/node_modules/@stdlib/_tools/manifest-json/schema/test/test.js
index 57b76b77215d..66966bdddc03 100644
--- a/lib/node_modules/@stdlib/_tools/manifest-json/schema/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/manifest-json/schema/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a JSON schema', function test( t ) {
 	var json = schema();
-	t.strictEqual( isObject( json ), true, 'returns an object' );
+	t.strictEqual( isObject( json ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -53,7 +53,7 @@ tape( 'the function returns `true` if provided a valid manifest JSON', function
 	pkg = require( './fixtures/good.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,7 +65,7 @@ tape( 'the function returns `false` if provided a manifest JSON missing a `confs
 	pkg = require( './fixtures/missing_confs.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -77,7 +77,7 @@ tape( 'the function returns `false` if provided a manifest JSON missing a `field
 	pkg = require( './fixtures/missing_fields.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns `false` if provided a manifest JSON missing an `opti
 	pkg = require( './fixtures/missing_options.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -101,7 +101,7 @@ tape( 'the function returns `false` if provided a manifest JSON having an invali
 	pkg = require( './fixtures/bad_fields1.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function returns `false` if provided a manifest JSON having an invali
 	pkg = require( './fixtures/bad_fields2.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -125,7 +125,7 @@ tape( 'the function returns `false` if provided a manifest JSON having an invali
 	pkg = require( './fixtures/bad_fields3.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'the function returns `false` if provided a manifest JSON having an invali
 	pkg = require( './fixtures/bad_confs1.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -149,7 +149,7 @@ tape( 'the function returns `false` if provided a manifest JSON having an invali
 	pkg = require( './fixtures/bad_confs2.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -161,7 +161,7 @@ tape( 'the function returns `false` if provided a manifest JSON having an invali
 	pkg = require( './fixtures/bad_confs3.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -173,7 +173,7 @@ tape( 'the function returns `false` if provided a manifest JSON having an invali
 	pkg = require( './fixtures/bad_confs4.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.validate.js b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.validate.js
index 9d5a8f035662..2fe963463422 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.validate.js
@@ -234,7 +234,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( obj, opts, 'updates destination object' );
 	t.end();
@@ -251,7 +251,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 			'b': 'c'
 		}
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'destination object is empty' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.validate.js b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.validate.js
index 497048ad04d2..b4ef9b80b9ff 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.validate.js
@@ -176,7 +176,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( obj, opts, 'updates destination object' );
 	t.end();
@@ -193,7 +193,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 			'b': 'c'
 		}
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'destination object is empty' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.validate.js b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.validate.js
index a4a8592d02fb..04290a9a7774 100644
--- a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.validate.js
@@ -123,7 +123,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
@@ -142,7 +142,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.validate.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.validate.js
index f62fb94dea09..a82cf8d7ccee 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.validate.js
@@ -152,7 +152,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.builtins, opts.builtins, 'sets builtins option' );
 	t.strictEqual( obj.walk, opts.walk, 'sets walk option' );
 	t.deepEqual( obj.aliases, opts.aliases, 'sets aliases option' );
@@ -173,7 +173,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.sync.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.sync.js
index ba966c32bbea..db27ba80508b 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.sync.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.sync.js
@@ -69,7 +69,7 @@ tape( 'the function synchronously walks a file\'s relative dependencies', functi
 	tmp = join( __dirname, 'fixtures', 'bool.js' );
 	expected[ tmp ] = [];
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( cache, expected, 'updates dependency cache' );
 
 	t.end();
@@ -106,7 +106,7 @@ tape( 'the function synchronously walks a file\'s relative dependencies (exclude
 	tmp = join( __dirname, 'fixtures', 'bool.js' );
 	expected[ tmp ] = [];
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( cache, expected, 'updates dependency cache' );
 
 	t.end();
@@ -133,7 +133,7 @@ tape( 'the function synchronously walks a file\'s relative dependencies (no walk
 		'fs'
 	];
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( cache, expected, 'updates dependency cache' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/package-json/schema/test/test.js b/lib/node_modules/@stdlib/_tools/package-json/schema/test/test.js
index 44df0fe4cf3e..0c49685c7095 100644
--- a/lib/node_modules/@stdlib/_tools/package-json/schema/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/package-json/schema/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a JSON schema', function test( t ) {
 	var json = schema();
-	t.strictEqual( isObject( json ), true, 'returns an object' );
+	t.strictEqual( isObject( json ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'the function returns `true` if provided a valid package JSON', function t
 	pkg = require( './fixtures/good.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -64,7 +64,7 @@ tape( 'the function returns `false` if provided a package JSON missing an `autho
 	pkg = require( './fixtures/missing_author.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns `false` if provided a package JSON missing a `bugs`
 	pkg = require( './fixtures/missing_bugs.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function returns `false` if provided a package JSON missing a `contri
 	pkg = require( './fixtures/missing_contributors.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'the function returns `false` if provided a package JSON missing a `depend
 	pkg = require( './fixtures/missing_dependencies.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -112,7 +112,7 @@ tape( 'the function returns `false` if provided a package JSON missing a `descri
 	pkg = require( './fixtures/missing_description.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns `false` if provided a package JSON missing a `devDep
 	pkg = require( './fixtures/missing_devdependencies.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -136,7 +136,7 @@ tape( 'the function returns `false` if provided a package JSON missing an `engin
 	pkg = require( './fixtures/missing_engines.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -148,7 +148,7 @@ tape( 'the function returns `false` if provided a package JSON missing a `homepa
 	pkg = require( './fixtures/missing_homepage.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -160,7 +160,7 @@ tape( 'the function returns `false` if provided a package JSON missing a `keywor
 	pkg = require( './fixtures/missing_keywords.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -172,7 +172,7 @@ tape( 'the function returns `false` if provided a package JSON missing a `licens
 	pkg = require( './fixtures/missing_license.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -184,7 +184,7 @@ tape( 'the function returns `false` if provided a package JSON missing a `main`
 	pkg = require( './fixtures/missing_main.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -196,7 +196,7 @@ tape( 'the function returns `false` if provided a package JSON missing a `name`
 	pkg = require( './fixtures/missing_name.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -208,7 +208,7 @@ tape( 'the function returns `false` if provided a package JSON missing a `reposi
 	pkg = require( './fixtures/missing_repository.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -220,7 +220,7 @@ tape( 'the function returns `false` if provided a package JSON missing a `script
 	pkg = require( './fixtures/missing_scripts.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -232,7 +232,7 @@ tape( 'the function returns `false` if provided a package JSON missing a `versio
 	pkg = require( './fixtures/missing_version.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -244,7 +244,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_author1.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -256,7 +256,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_author2.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -268,7 +268,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_author3.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -280,7 +280,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_bin.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -292,7 +292,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_browser.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -304,7 +304,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_browser_map.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -316,7 +316,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_gypfile.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -328,7 +328,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_bugs.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -340,7 +340,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_contributors1.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -352,7 +352,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_contributors2.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -364,7 +364,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_contributors3.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -376,7 +376,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_contributors4.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -388,7 +388,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_dependencies.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -400,7 +400,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_description.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -412,7 +412,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_devdependencies.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -424,7 +424,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_directories1.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -436,7 +436,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_directories2.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -448,7 +448,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_directories3.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -460,7 +460,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_directories4.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -472,7 +472,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_directories5.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -484,7 +484,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_directories6.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -496,7 +496,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_directories7.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -508,7 +508,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_directories8.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -520,7 +520,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_engines.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -532,7 +532,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_exports1.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -544,7 +544,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_exports2.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -556,7 +556,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_exports3.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -568,7 +568,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_exports4.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -580,7 +580,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_exports5.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -592,7 +592,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_exports6.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -604,7 +604,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_exports7.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -616,7 +616,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_homepage.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -628,7 +628,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_keywords1.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -640,7 +640,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_keywords2.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -652,7 +652,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_license.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -664,7 +664,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_licenses1.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -676,7 +676,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_licenses2.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -688,7 +688,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_licenses3.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -700,7 +700,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_main.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -712,7 +712,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_maintainers1.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -724,7 +724,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_maintainers2.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -736,7 +736,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_maintainers3.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -748,7 +748,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_maintainers4.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -760,7 +760,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_name.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -772,7 +772,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_os1.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -784,7 +784,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_os2.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -796,7 +796,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_repository1.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -808,7 +808,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_repository2.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -820,7 +820,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_repositories1.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -832,7 +832,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_repositories2.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -844,7 +844,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_repositories3.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -856,7 +856,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_scripts.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -868,7 +868,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_stdlib.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -880,7 +880,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_stdlib_stability.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -892,7 +892,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_stdlib_envs.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -904,7 +904,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_types.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -916,7 +916,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_unpkg.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -928,7 +928,7 @@ tape( 'the function returns `false` if provided a package JSON having an invalid
 	pkg = require( './fixtures/bad_version.json' );
 
 	bool = validate( pkg );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.validate.js
index 53703bae7f65..00e9bd499d0d 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.validate.js
@@ -177,7 +177,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -198,7 +198,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.validate.js
index 0991f2aefd96..dbdfbed7d8a9 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.validate.js
@@ -181,7 +181,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -202,7 +202,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.validate.js
index 054fcc3e8aaf..2ef964fb7366 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-deps/test/test.validate.js
@@ -151,7 +151,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.builtins, opts.builtins, 'sets builtins option' );
 	t.strictEqual( obj.dev, opts.dev, 'sets dev option' );
@@ -172,7 +172,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.validate.js
index 663632c5b03e..8e64a760de71 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-entry-points/test/test.validate.js
@@ -95,7 +95,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.validate.js
index e412bea5affb..4d2914e12950 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.validate.js
@@ -177,7 +177,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -198,7 +198,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.validate.js
index a93b1b55e745..7ac2994f6c2a 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.validate.js
@@ -181,7 +181,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -202,7 +202,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.validate.js
index 5e14bb3aa509..22788d30f2ce 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.validate.js
@@ -96,7 +96,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dev, opts.dev, 'sets dev option' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.validate.js
index ce07cb34f65e..500c7c1f5708 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/deps/test/test.validate.js
@@ -151,7 +151,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.builtins, opts.builtins, 'sets builtins option' );
 	t.strictEqual( obj.dev, opts.dev, 'sets dev option' );
@@ -172,7 +172,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.validate.js
index 55c2be78ac8c..ad4c094f4dda 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/entry-points/test/test.validate.js
@@ -95,7 +95,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.validate.js
index e496f6001760..a5915c034b90 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.validate.js
@@ -154,7 +154,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -175,7 +175,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.validate.js
index 0c858977d04b..a8a0a6e0f7e2 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.validate.js
@@ -177,7 +177,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -198,7 +198,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.validate.js
index d103bd59e2f8..8a1571a41c94 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.validate.js
@@ -181,7 +181,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -202,7 +202,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.validate.js
index b8953b17ecc1..ef12f84634e1 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.validate.js
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.level, opts.level, 'sets level option' );
 	t.strictEqual( obj.dev, opts.dev, 'sets dev option' );
 
@@ -144,7 +144,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.validate.js
index 0c858977d04b..a8a0a6e0f7e2 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.validate.js
@@ -177,7 +177,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -198,7 +198,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.validate.js
index 0991f2aefd96..dbdfbed7d8a9 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.validate.js
@@ -181,7 +181,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -202,7 +202,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.validate.js
index 53703bae7f65..00e9bd499d0d 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.validate.js
@@ -177,7 +177,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -198,7 +198,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.validate.js
index dccd930edeae..b57448efe351 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.validate.js
@@ -205,7 +205,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -226,7 +226,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.validate.js
index bb12d1f04606..0209443fa601 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.validate.js
@@ -181,7 +181,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -202,7 +202,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.validate.js
index bb12d1f04606..0209443fa601 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.validate.js
@@ -181,7 +181,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -202,7 +202,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.async.js
index f15fe3a9e0f0..66566f9f642d 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.async.js
@@ -158,7 +158,7 @@ tape( 'the function returns an object', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObject( tree ), true, 'returns an object' );
+		t.strictEqual( isObject( tree ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -172,7 +172,7 @@ tape( 'the function returns an object (dir option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObject( tree ), true, 'returns an object' );
+		t.strictEqual( isObject( tree ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -186,7 +186,7 @@ tape( 'the function returns an object (pattern option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObject( tree ), true, 'returns an object' );
+		t.strictEqual( isObject( tree ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -203,7 +203,7 @@ tape( 'the function returns an empty object if unable to resolve any packages (i
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObject( tree ), true, 'returns an object' );
+		t.strictEqual( isObject( tree ), true, 'returns expected value' );
 		t.strictEqual( isEmptyObject( tree ), true, 'returns an empty object' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.sync.js
index aba7ab8474f8..0e1f222b9f80 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.sync.js
@@ -75,7 +75,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns an object', function test( t ) {
 	var tree = pkgTree();
-	t.strictEqual( isObject( tree ), true, 'returns an object' );
+	t.strictEqual( isObject( tree ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -87,7 +87,7 @@ tape( 'the function returns an object (dir option)', function test( t ) {
 		'dir': './@stdlib/math/base'
 	};
 	tree = pkgTree( opts );
-	t.strictEqual( isObject( tree ), true, 'returns an object' );
+	t.strictEqual( isObject( tree ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -100,7 +100,7 @@ tape( 'the function returns an object (pattern option)', function test( t ) {
 	};
 	tree = pkgTree( opts );
 
-	t.strictEqual( isObject( tree ), true, 'returns an object' );
+	t.strictEqual( isObject( tree ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -116,7 +116,7 @@ tape( 'the function returns an empty object if unable to resolve any packages (i
 	};
 	tree = pkgTree( opts );
 
-	t.strictEqual( isObject( tree ), true, 'returns an object' );
+	t.strictEqual( isObject( tree ), true, 'returns expected value' );
 	t.strictEqual( isEmptyObject( tree ), true, 'returns an empty object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.validate.js
index d103bd59e2f8..8a1571a41c94 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.validate.js
@@ -181,7 +181,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -202,7 +202,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.validate.js
index 4e59a6f90a91..748a3ca53ea0 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.validate.js
@@ -177,7 +177,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -198,7 +198,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.validate.js b/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.validate.js
index 53703bae7f65..00e9bd499d0d 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.validate.js
@@ -177,7 +177,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -198,7 +198,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/readme/to-html/test/test.validate.js b/lib/node_modules/@stdlib/_tools/readme/to-html/test/test.validate.js
index a2cd46fa1b5a..ed71b3e830d3 100644
--- a/lib/node_modules/@stdlib/_tools/readme/to-html/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/readme/to-html/test/test.validate.js
@@ -308,7 +308,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -327,7 +327,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/release/package-json/test/test.validate.js b/lib/node_modules/@stdlib/_tools/release/package-json/test/test.validate.js
index 245ea3d2f6af..6d062999cf3e 100644
--- a/lib/node_modules/@stdlib/_tools/release/package-json/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/release/package-json/test/test.validate.js
@@ -99,7 +99,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -117,7 +117,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/remark/plugins/remark-lint-expected-html-sections/test/test.validate.js b/lib/node_modules/@stdlib/_tools/remark/plugins/remark-lint-expected-html-sections/test/test.validate.js
index 86c8b4a1ec87..00c12ec07fe1 100644
--- a/lib/node_modules/@stdlib/_tools/remark/plugins/remark-lint-expected-html-sections/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/remark/plugins/remark-lint-expected-html-sections/test/test.validate.js
@@ -182,7 +182,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -200,7 +200,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/remark/plugins/remark-run-javascript-examples/test/test.validate.js b/lib/node_modules/@stdlib/_tools/remark/plugins/remark-run-javascript-examples/test/test.validate.js
index 5d74345ed629..366e036c86b2 100644
--- a/lib/node_modules/@stdlib/_tools/remark/plugins/remark-run-javascript-examples/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/remark/plugins/remark-run-javascript-examples/test/test.validate.js
@@ -242,7 +242,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -260,7 +260,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/remark/plugins/remark-run-javascript-examples/test/test.validate_config.js b/lib/node_modules/@stdlib/_tools/remark/plugins/remark-run-javascript-examples/test/test.validate_config.js
index 7afa7177acb6..9e09e81a53e9 100644
--- a/lib/node_modules/@stdlib/_tools/remark/plugins/remark-run-javascript-examples/test/test.validate_config.js
+++ b/lib/node_modules/@stdlib/_tools/remark/plugins/remark-run-javascript-examples/test/test.validate_config.js
@@ -160,7 +160,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
@@ -175,7 +175,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/package-json/test/test.js b/lib/node_modules/@stdlib/_tools/scaffold/package-json/test/test.js
index 5ca49e8878eb..a68cecff9988 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/package-json/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/scaffold/package-json/test/test.js
@@ -47,7 +47,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns an object', function test( t ) {
 	var pkg = create();
-	t.strictEqual( isObject( pkg ), true, 'returns an object' );
+	t.strictEqual( isObject( pkg ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/package-json/test/test.validate.js b/lib/node_modules/@stdlib/_tools/scaffold/package-json/test/test.validate.js
index 7645163d8428..6c88ea403197 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/package-json/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/scaffold/package-json/test/test.validate.js
@@ -243,7 +243,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, opts, 'sets options' );
 
 	t.end();
@@ -262,7 +262,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/cli_test.validate.js.txt b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/cli_test.validate.js.txt
index 174afd3f1b67..5fdc2b3b3e58 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/cli_test.validate.js.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/cli_test.validate.js.txt
@@ -93,7 +93,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -112,7 +112,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_1.txt b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_1.txt
index 17b6c1f57401..f8c75b97787e 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_1.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_1.txt
@@ -119,7 +119,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -138,7 +138,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_2.txt b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_2.txt
index 062c5e2902e0..00c4dc93b66f 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_2.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_2.txt
@@ -266,7 +266,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -285,7 +285,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_3.txt b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_3.txt
index 8718ffcf38fb..3d6d4306fd57 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_3.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_3.txt
@@ -144,7 +144,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -163,7 +163,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_4.txt b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_4.txt
index 17b6c1f57401..f8c75b97787e 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_4.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/test.validate.js_4.txt
@@ -119,7 +119,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -138,7 +138,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/search/pkg-index/test/test.validate.js b/lib/node_modules/@stdlib/_tools/search/pkg-index/test/test.validate.js
index e412bea5affb..4d2914e12950 100644
--- a/lib/node_modules/@stdlib/_tools/search/pkg-index/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/search/pkg-index/test/test.validate.js
@@ -177,7 +177,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 	t.strictEqual( obj.pattern, opts.pattern, 'sets pattern option' );
 	t.deepEqual( obj.ignore, opts.ignore, 'sets ignore option' );
@@ -198,7 +198,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/incr/lloc/test/test.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/incr/lloc/test/test.js
index d2d9ff1be87b..f4bb8e9d702f 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/incr/lloc/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/incr/lloc/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var f = incrlloc();
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -75,95 +75,95 @@ tape( 'the function returns a function which incrementally calculates a logical
 	var o;
 
 	o = f( 'var x = 5;' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'y = foo( x );' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'if ( x < y ) {\n\tconsole.log( "x < y" );\n} else {\n\tconsole.log( "x >= y " );\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'function foo( x ) {\n\treturn bar;\n\n\tfunction bar( y ) {\n\t\tvar z = 5 * y;\n\t\treturn z;\n\t}\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'for ( i = 0; i < 10; i++ ) {\n\tconsole.log( i );\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'i = 0;\nwhile ( i < 10 ) {\n\tconsole.log( i );\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'var f = function() {\n\treturn "beep";\n};\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'switch ( i ) {\ncase 0:\n\tbreak;\ncase 1:\n\tbreak;\ndefault:\n\tbreak;\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'var arr = [ 1, 2, 3 ];\nfor ( i in arr ) {\n\tif ( hasOwnProp( arr, i ) ) {\n\t\tconsole.log( i );\n\t}\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'var arr = [ 1, 2, 3 ];\nfor ( v of arr ) {\n\tconsole.log( v );\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'o = {\n\t"x": 1,\n\t"y": 2\n};\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'arr = [ 1, 2, 3 ];' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'i += 1;\ni += 2;\ni *= 3;\ni /= 4;\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'x = 5, y = 10;' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'i = 0;\ndo {\n\ti += 1;\n} while ( i < 10 );\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'z = ( x < 10 ) ? -y : y;' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( '// this is a comment' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( '/* this is a comment */' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( '/**\n* this is a comment.\n*/\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'f = new Foo();' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'var self = this;' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'try {\n\tthrow new Error( "BEEP!" );\n} catch ( err ) {\n\tthrow err;\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'function* gen() {\n\tyield 5;\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function returns a function which returns the accumulated summary whe
 	var o;
 
 	o = f();
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length, 0, 'has no keys' );
 
 	f( 'var x = 5;' );
@@ -182,7 +182,7 @@ tape( 'the function returns a function which returns the accumulated summary whe
 	f( 'if ( x < y ) {\n\tconsole.log( "x < y" );\n}\n' );
 
 	o = f();
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/incr/program-summary/test/test.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/incr/program-summary/test/test.js
index bfcb0b559805..51512c754335 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/incr/program-summary/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/incr/program-summary/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var f = incrsummary();
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -75,95 +75,95 @@ tape( 'the function returns a function which incrementally generates a program s
 	var o;
 
 	o = f( 'var x = 5;' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'y = foo( x );' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'if ( x < y ) {\n\tconsole.log( "x < y" );\n} else {\n\tconsole.log( "x >= y " );\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'function foo( x ) {\n\treturn bar;\n\n\tfunction bar( y ) {\n\t\tvar z = 5 * y;\n\t\treturn z;\n\t}\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'for ( i = 0; i < 10; i++ ) {\n\tconsole.log( i );\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'i = 0;\nwhile ( i < 10 ) {\n\tconsole.log( i );\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'var f = function() {\n\treturn "beep";\n};\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'switch ( i ) {\ncase 0:\n\tbreak;\ncase 1:\n\tbreak;\ndefault:\n\tbreak;\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'var arr = [ 1, 2, 3 ];\nfor ( i in arr ) {\n\tif ( hasOwnProp( arr, i ) ) {\n\t\tconsole.log( i );\n\t}\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'var arr = [ 1, 2, 3 ];\nfor ( v of arr ) {\n\tconsole.log( v );\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'o = {\n\t"x": 1,\n\t"y": 2\n};\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'arr = [ 1, 2, 3 ];' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'i += 1;\ni += 2;\ni *= 3;\ni /= 4;\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'x = 5, y = 10;' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'i = 0;\ndo {\n\ti += 1;\n} while ( i < 10 );\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'z = ( x < 10 ) ? -y : y;' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( '// this is a comment' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( '/* this is a comment */' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( '/**\n* this is a comment.\n*/\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'f = new Foo();' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'var self = this;' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'try {\n\tthrow new Error( "BEEP!" );\n} catch ( err ) {\n\tthrow err;\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'function* gen() {\n\tyield 5;\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function returns a function which returns the accumulated summary whe
 	var o;
 
 	o = f();
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	f( 'var x = 5;' );
@@ -182,7 +182,7 @@ tape( 'the function returns a function which returns the accumulated summary whe
 	f( 'if ( x < y ) {\n\tconsole.log( "x < y" );\n}\n' );
 
 	o = f();
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/incr/sloc/test/test.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/incr/sloc/test/test.js
index 96f9811c454f..1d869c3abc36 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/incr/sloc/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/incr/sloc/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var f = incrsloc();
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -75,95 +75,95 @@ tape( 'the function returns a function which incrementally calculates a source l
 	var o;
 
 	o = f( 'var x = 5;' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'y = foo( x );' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'if ( x < y ) {\n\tconsole.log( "x < y" );\n} else {\n\tconsole.log( "x >= y " );\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'function foo( x ) {\n\treturn bar;\n\n\tfunction bar( y ) {\n\t\tvar z = 5 * y;\n\t\treturn z;\n\t}\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'for ( i = 0; i < 10; i++ ) {\n\tconsole.log( i );\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'i = 0;\nwhile ( i < 10 ) {\n\tconsole.log( i );\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'var f = function() {\n\treturn "beep";\n};\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'switch ( i ) {\ncase 0:\n\tbreak;\ncase 1:\n\tbreak;\ndefault:\n\tbreak;\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'var arr = [ 1, 2, 3 ];\nfor ( i in arr ) {\n\tif ( hasOwnProp( arr, i ) ) {\n\t\tconsole.log( i );\n\t}\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'var arr = [ 1, 2, 3 ];\nfor ( v of arr ) {\n\tconsole.log( v );\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'o = {\n\t"x": 1,\n\t"y": 2\n};\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'arr = [ 1, 2, 3 ];' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'i += 1;\ni += 2;\ni *= 3;\ni /= 4;\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'x = 5, y = 10;' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'i = 0;\ndo {\n\ti += 1;\n} while ( i < 10 );\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'z = ( x < 10 ) ? -y : y;' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( '// this is a comment' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( '/* this is a comment */' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( '/**\n* this is a comment.\n*/\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'f = new Foo();' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'var self = this;' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'try {\n\tthrow new Error( "BEEP!" );\n} catch ( err ) {\n\tthrow err;\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	o = f( 'function* gen() {\n\tyield 5;\n}\n' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function returns a function which returns the accumulated summary whe
 	var o;
 
 	o = f();
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length, 0, 'has no keys' );
 
 	f( 'var x = 5;' );
@@ -182,7 +182,7 @@ tape( 'the function returns a function which returns the accumulated summary whe
 	f( 'if ( x < y ) {\n\tconsole.log( "x < y" );\n}\n' );
 
 	o = f();
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has keys' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-file-list/test/test.validate.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-file-list/test/test.validate.js
index ca123d856e59..66827e139f2a 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-file-list/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-file-list/test/test.validate.js
@@ -94,7 +94,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -112,7 +112,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.validate.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.validate.js
index d5271cb62f63..0dbaf9731a3a 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.validate.js
@@ -184,7 +184,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -202,7 +202,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/program-summary/test/test.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/program-summary/test/test.js
index 4eed9e02e0ac..418ec639bb32 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/program-summary/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/program-summary/test/test.js
@@ -74,13 +74,13 @@ tape( 'the function throws an error if not provided a string or a Buffer', funct
 
 tape( 'the function returns a object (string)', function test( t ) {
 	var o = analyze( 'var beep = "boop";' );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a object (Buffer)', function test( t ) {
 	var o = analyze( string2buffer( 'var beep = "boop";' ) );
-	t.strictEqual( isPlainObject( o ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-file-list/test/test.validate.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-file-list/test/test.validate.js
index ca123d856e59..66827e139f2a 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-file-list/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-file-list/test/test.validate.js
@@ -94,7 +94,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -112,7 +112,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.validate.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.validate.js
index d5271cb62f63..0dbaf9731a3a 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.validate.js
@@ -184,7 +184,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -202,7 +202,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-file-list/test/test.validate.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-file-list/test/test.validate.js
index ca123d856e59..66827e139f2a 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-file-list/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-file-list/test/test.validate.js
@@ -94,7 +94,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -112,7 +112,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.validate.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.validate.js
index d5271cb62f63..0dbaf9731a3a 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.validate.js
@@ -184,7 +184,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -202,7 +202,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/test-cov/tape-istanbul/test/test.validate.js b/lib/node_modules/@stdlib/_tools/test-cov/tape-istanbul/test/test.validate.js
index cd149839dff6..7609f13a8b3a 100644
--- a/lib/node_modules/@stdlib/_tools/test-cov/tape-istanbul/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/test-cov/tape-istanbul/test/test.validate.js
@@ -120,7 +120,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -139,7 +139,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/tests/browser-build/test/test.validate.js b/lib/node_modules/@stdlib/_tools/tests/browser-build/test/test.validate.js
index 0cafe1eb6078..913f7dfc058b 100644
--- a/lib/node_modules/@stdlib/_tools/tests/browser-build/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/tests/browser-build/test/test.validate.js
@@ -201,7 +201,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -220,7 +220,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.validate.js b/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.validate.js
index 66171c1ec14e..e52eae02021c 100644
--- a/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/tests/bundle/test/test.validate.js
@@ -120,7 +120,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -139,7 +139,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/tests/html/test/test.validate.js b/lib/node_modules/@stdlib/_tools/tests/html/test/test.validate.js
index 8a388b894d9b..1ac37ff0baa1 100644
--- a/lib/node_modules/@stdlib/_tools/tests/html/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/tests/html/test/test.validate.js
@@ -120,7 +120,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -139,7 +139,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/utils/jsdelivr-url/test/test.validate.js b/lib/node_modules/@stdlib/_tools/utils/jsdelivr-url/test/test.validate.js
index e9c6c59d7bd3..a83f46b3e84c 100644
--- a/lib/node_modules/@stdlib/_tools/utils/jsdelivr-url/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/utils/jsdelivr-url/test/test.validate.js
@@ -135,7 +135,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'slug': 'stdlib-js/stdlib/develop',
 		'file': 'lib/index.js'
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.slug, 'stdlib-js/stdlib/develop', 'sets slug option' );
 	t.strictEqual( obj.file, 'lib/index.js', 'sets file option' );
 
@@ -155,6 +155,6 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 			'b': 'c'
 		}
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.validate.js b/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.validate.js
index 54d320628983..6aecab9aad08 100644
--- a/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.validate.js
+++ b/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.validate.js
@@ -173,7 +173,7 @@ tape( 'the function returns `null` if provided valid options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.width, 200, 'sets width' );
 	t.strictEqual( obj.ex, 2, 'sets ex' );
 	t.strictEqual( obj.inline, true, 'sets inline' );
@@ -193,6 +193,6 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 		'c': 'What?!'
 	};
 	err = validate( {}, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/bool/test/test.entries.js b/lib/node_modules/@stdlib/array/bool/test/test.entries.js
index 1d85b375b8de..0915407d98b8 100644
--- a/lib/node_modules/@stdlib/array/bool/test/test.entries.js
+++ b/lib/node_modules/@stdlib/array/bool/test/test.entries.js
@@ -204,7 +204,7 @@ tape( 'if an environment supports `Symbol.iterator`, the method returns an itera
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/array/bool/test/test.keys.js b/lib/node_modules/@stdlib/array/bool/test/test.keys.js
index 5aa8284d11a5..6a539b8d44f5 100644
--- a/lib/node_modules/@stdlib/array/bool/test/test.keys.js
+++ b/lib/node_modules/@stdlib/array/bool/test/test.keys.js
@@ -97,7 +97,7 @@ tape( 'the method returns an iterator protocol-compliant object', function test(
 	];
 	it = arr.keys();
 
-	t.strictEqual( typeof it, 'object', 'returns an object' );
+	t.strictEqual( typeof it, 'object', 'returns expected value' );
 	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < expected.length; i++ ) {
@@ -135,7 +135,7 @@ tape( 'the method returns an iterator which does not iterate over empty arrays',
 	];
 	it = arr.keys();
 
-	t.strictEqual( typeof it, 'object', 'returns an object' );
+	t.strictEqual( typeof it, 'object', 'returns expected value' );
 	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < expected.length; i++ ) {
@@ -229,7 +229,7 @@ tape( 'if an environment supports `Symbol.iterator`, the method returns an itera
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/array/bool/test/test.values.js b/lib/node_modules/@stdlib/array/bool/test/test.values.js
index 39e73e034d12..6e5caaad3086 100644
--- a/lib/node_modules/@stdlib/array/bool/test/test.values.js
+++ b/lib/node_modules/@stdlib/array/bool/test/test.values.js
@@ -98,7 +98,7 @@ tape( 'the method returns an iterator protocol-compliant object', function test(
 	];
 	it = arr.values();
 
-	t.strictEqual( typeof it, 'object', 'returns an object' );
+	t.strictEqual( typeof it, 'object', 'returns expected value' );
 	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < expected.length; i++ ) {
@@ -137,7 +137,7 @@ tape( 'the method returns an iterator which does not iterate over empty arrays',
 	];
 	it = arr.values();
 
-	t.strictEqual( typeof it, 'object', 'returns an object' );
+	t.strictEqual( typeof it, 'object', 'returns expected value' );
 	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < expected.length; i++ ) {
@@ -231,7 +231,7 @@ tape( 'if an environment supports `Symbol.iterator`, the method returns an itera
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/array/complex128/test/test.entries.js b/lib/node_modules/@stdlib/array/complex128/test/test.entries.js
index 7bcbd416da56..b1090c3e4154 100644
--- a/lib/node_modules/@stdlib/array/complex128/test/test.entries.js
+++ b/lib/node_modules/@stdlib/array/complex128/test/test.entries.js
@@ -98,7 +98,7 @@ tape( 'the method returns an iterator protocol-compliant object', function test(
 		t.strictEqual( isComplex128( v.value[ 1 ] ), true, 'returns a complex number' );
 		t.strictEqual( real( v.value[ 1 ] ), buf[ j ], 'returns expected real component' );
 		t.strictEqual( imag( v.value[ 1 ] ), buf[ j+1 ], 'returns expected imaginary component' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 
 		j += 2; // stride
 	}
@@ -215,7 +215,7 @@ tape( 'if an environment supports `Symbol.iterator`, the method returns an itera
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/array/complex128/test/test.keys.js b/lib/node_modules/@stdlib/array/complex128/test/test.keys.js
index 21ca92b560d4..a95980bbb7d1 100644
--- a/lib/node_modules/@stdlib/array/complex128/test/test.keys.js
+++ b/lib/node_modules/@stdlib/array/complex128/test/test.keys.js
@@ -97,7 +97,7 @@ tape( 'the method returns an iterator protocol-compliant object', function test(
 	];
 	it = arr.keys();
 
-	t.strictEqual( typeof it, 'object', 'returns an object' );
+	t.strictEqual( typeof it, 'object', 'returns expected value' );
 	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < expected.length; i++ ) {
@@ -135,7 +135,7 @@ tape( 'the method returns an iterator which does not iterate over empty arrays',
 	];
 	it = arr.keys();
 
-	t.strictEqual( typeof it, 'object', 'returns an object' );
+	t.strictEqual( typeof it, 'object', 'returns expected value' );
 	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < expected.length; i++ ) {
@@ -229,7 +229,7 @@ tape( 'if an environment supports `Symbol.iterator`, the method returns an itera
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/array/complex128/test/test.values.js b/lib/node_modules/@stdlib/array/complex128/test/test.values.js
index 5a74e272ba45..fce98045b2b4 100644
--- a/lib/node_modules/@stdlib/array/complex128/test/test.values.js
+++ b/lib/node_modules/@stdlib/array/complex128/test/test.values.js
@@ -101,7 +101,7 @@ tape( 'the method returns an iterator protocol-compliant object', function test(
 	];
 	it = arr.values();
 
-	t.strictEqual( typeof it, 'object', 'returns an object' );
+	t.strictEqual( typeof it, 'object', 'returns expected value' );
 	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < expected.length; i++ ) {
@@ -141,7 +141,7 @@ tape( 'the method returns an iterator which does not iterate over empty arrays',
 	];
 	it = arr.values();
 
-	t.strictEqual( typeof it, 'object', 'returns an object' );
+	t.strictEqual( typeof it, 'object', 'returns expected value' );
 	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < expected.length; i++ ) {
@@ -239,7 +239,7 @@ tape( 'if an environment supports `Symbol.iterator`, the method returns an itera
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/array/complex64/test/test.entries.js b/lib/node_modules/@stdlib/array/complex64/test/test.entries.js
index 15bc88f6a613..cc40b95cb24d 100644
--- a/lib/node_modules/@stdlib/array/complex64/test/test.entries.js
+++ b/lib/node_modules/@stdlib/array/complex64/test/test.entries.js
@@ -98,7 +98,7 @@ tape( 'the method returns an iterator protocol-compliant object', function test(
 		t.strictEqual( isComplex64( v.value[ 1 ] ), true, 'returns a complex number' );
 		t.strictEqual( realf( v.value[ 1 ] ), buf[ j ], 'returns expected real component' );
 		t.strictEqual( imagf( v.value[ 1 ] ), buf[ j+1 ], 'returns expected imaginary component' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 
 		j += 2; // stride
 	}
@@ -215,7 +215,7 @@ tape( 'if an environment supports `Symbol.iterator`, the method returns an itera
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/array/complex64/test/test.keys.js b/lib/node_modules/@stdlib/array/complex64/test/test.keys.js
index 9fba96201e6b..30f51117307a 100644
--- a/lib/node_modules/@stdlib/array/complex64/test/test.keys.js
+++ b/lib/node_modules/@stdlib/array/complex64/test/test.keys.js
@@ -97,7 +97,7 @@ tape( 'the method returns an iterator protocol-compliant object', function test(
 	];
 	it = arr.keys();
 
-	t.strictEqual( typeof it, 'object', 'returns an object' );
+	t.strictEqual( typeof it, 'object', 'returns expected value' );
 	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < expected.length; i++ ) {
@@ -135,7 +135,7 @@ tape( 'the method returns an iterator which does not iterate over empty arrays',
 	];
 	it = arr.keys();
 
-	t.strictEqual( typeof it, 'object', 'returns an object' );
+	t.strictEqual( typeof it, 'object', 'returns expected value' );
 	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < expected.length; i++ ) {
@@ -229,7 +229,7 @@ tape( 'if an environment supports `Symbol.iterator`, the method returns an itera
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/array/complex64/test/test.values.js b/lib/node_modules/@stdlib/array/complex64/test/test.values.js
index ea28ee6bddd9..912d7c84a396 100644
--- a/lib/node_modules/@stdlib/array/complex64/test/test.values.js
+++ b/lib/node_modules/@stdlib/array/complex64/test/test.values.js
@@ -101,7 +101,7 @@ tape( 'the method returns an iterator protocol-compliant object', function test(
 	];
 	it = arr.values();
 
-	t.strictEqual( typeof it, 'object', 'returns an object' );
+	t.strictEqual( typeof it, 'object', 'returns expected value' );
 	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < expected.length; i++ ) {
@@ -141,7 +141,7 @@ tape( 'the method returns an iterator which does not iterate over empty arrays',
 	];
 	it = arr.values();
 
-	t.strictEqual( typeof it, 'object', 'returns an object' );
+	t.strictEqual( typeof it, 'object', 'returns expected value' );
 	t.strictEqual( typeof it.next, 'function', 'has next method' );
 
 	for ( i = 0; i < expected.length; i++ ) {
@@ -239,7 +239,7 @@ tape( 'if an environment supports `Symbol.iterator`, the method returns an itera
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/array/mostly-safe-casts/test/test.js b/lib/node_modules/@stdlib/array/mostly-safe-casts/test/test.js
index d2ed3110d0ad..ff3f51717fdf 100644
--- a/lib/node_modules/@stdlib/array/mostly-safe-casts/test/test.js
+++ b/lib/node_modules/@stdlib/array/mostly-safe-casts/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if not provided a data type, the function returns a table', function test( t ) {
 	var out = mostlySafeCasts();
-	t.strictEqual( typeof out, 'object', 'returns an object' );
+	t.strictEqual( typeof out, 'object', 'returns expected value' );
 	t.strictEqual( out[ 'float32' ][ 'float64' ], 1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/next-dtype/test/test.js b/lib/node_modules/@stdlib/array/next-dtype/test/test.js
index e231464be800..d0eb1a90be93 100644
--- a/lib/node_modules/@stdlib/array/next-dtype/test/test.js
+++ b/lib/node_modules/@stdlib/array/next-dtype/test/test.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if not provided a data type, the function returns a table', function test( t ) {
 	var out = nextDataType();
-	t.strictEqual( typeof out, 'object', 'returns an object' );
+	t.strictEqual( typeof out, 'object', 'returns expected value' );
 	t.strictEqual( out[ 'float32' ], 'float64', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/pool/test/test.factory.js b/lib/node_modules/@stdlib/array/pool/test/test.factory.js
index 73f3eef10cec..56f42b9bbcf9 100644
--- a/lib/node_modules/@stdlib/array/pool/test/test.factory.js
+++ b/lib/node_modules/@stdlib/array/pool/test/test.factory.js
@@ -56,12 +56,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a function (no options)', function test( t ) {
-	t.strictEqual( typeof factory(), 'function', 'returns a function' );
+	t.strictEqual( typeof factory(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a function (options)', function test( t ) {
-	t.strictEqual( typeof factory( {} ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {} ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -2384,9 +2384,9 @@ tape( 'attached to the returned function is a method for clearing a typed array
 	typedarraypool.clear();
 	t.strictEqual( typedarraypool.nbytes, 0, 'returns expected value' );
 
-	arrs = new Array( 10 );
-	for ( i = 0; i < arrs.length; i++ ) {
-		arrs[ i ] = typedarraypool( 10, 'uint8' );
+	arrs = [];
+	for ( i = 0; i < 10; i++ ) {
+		arrs.push( typedarraypool( 10, 'uint8' ) );
 		t.strictEqual( typedarraypool.nbytes > 0 && typedarraypool.nbytes < typedarraypool.highWaterMark, true, 'returns expected value' );
 	}
 	for ( i = 0; i < arrs.length; i++ ) {
diff --git a/lib/node_modules/@stdlib/array/promotion-rules/test/test.js b/lib/node_modules/@stdlib/array/promotion-rules/test/test.js
index 3bccf41eaa2f..f699daa1d282 100644
--- a/lib/node_modules/@stdlib/array/promotion-rules/test/test.js
+++ b/lib/node_modules/@stdlib/array/promotion-rules/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if not provided data types, the function returns a table', function test( t ) {
 	var out = promotionRules();
-	t.strictEqual( isObject( out ), true, 'returns an object' );
+	t.strictEqual( isObject( out ), true, 'returns expected value' );
 	t.strictEqual( out[ 'float32' ][ 'uint32' ], 'float64', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/safe-casts/test/test.js b/lib/node_modules/@stdlib/array/safe-casts/test/test.js
index fb234a86088c..d865f2ccca80 100644
--- a/lib/node_modules/@stdlib/array/safe-casts/test/test.js
+++ b/lib/node_modules/@stdlib/array/safe-casts/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if not provided a data type, the function returns a table', function test( t ) {
 	var out = safeCasts();
-	t.strictEqual( typeof out, 'object', 'returns an object' );
+	t.strictEqual( typeof out, 'object', 'returns expected value' );
 	t.strictEqual( out[ 'float32' ][ 'float64' ], 1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/same-kind-casts/test/test.js b/lib/node_modules/@stdlib/array/same-kind-casts/test/test.js
index 4f69b474cbfa..1aabc59b2dcf 100644
--- a/lib/node_modules/@stdlib/array/same-kind-casts/test/test.js
+++ b/lib/node_modules/@stdlib/array/same-kind-casts/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if not provided a data type, the function returns a table', function test( t ) {
 	var out = sameKindCasts();
-	t.strictEqual( typeof out, 'object', 'returns an object' );
+	t.strictEqual( typeof out, 'object', 'returns expected value' );
 	t.strictEqual( out[ 'float32' ][ 'float64' ], 1, 'returns expected value' );
 	t.strictEqual( out[ 'float32' ][ 'int8' ], 0, 'returns expected value' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/array/to-circular-iterator/test/test.js b/lib/node_modules/@stdlib/array/to-circular-iterator/test/test.js
index b7917fd4a72e..97e453e52e53 100644
--- a/lib/node_modules/@stdlib/array/to-circular-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-circular-iterator/test/test.js
@@ -357,8 +357,8 @@ tape( 'the function returns an iterator protocol-compliant object which repeated
 	for ( i = 0; i < values.length*2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
 	t.end();
@@ -415,8 +415,8 @@ tape( 'the function returns an iterator protocol-compliant object which repeated
 	for ( i = 0; i < values.length*2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
 	t.end();
@@ -479,8 +479,8 @@ tape( 'the function returns an iterator protocol-compliant object which repeated
 	for ( i = 0; i < values.length*2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.deepEqual( actual, expected, 'returns expected values' );
 	t.end();
@@ -523,7 +523,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -561,7 +561,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -658,8 +658,8 @@ tape( 'the function supports limiting the number of iterations', function test(
 	for ( i = 0; i < opts.iter; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -721,8 +721,8 @@ tape( 'the function supports limiting the number of iterations (callback)', func
 	for ( i = 0; i < opts.iter; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -789,8 +789,8 @@ tape( 'the function supports specifying the iteration direction', function test(
 	for ( i = 0; i < opts.iter; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -853,8 +853,8 @@ tape( 'the function supports specifying the iteration direction (callback)', fun
 	for ( i = 0; i < opts.iter; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -873,11 +873,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = circarray2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -898,11 +898,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = circarray2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -927,11 +927,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = circarray2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -952,11 +952,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = circarray2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -992,7 +992,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -1020,7 +1020,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/array/to-iterator-right/test/test.js b/lib/node_modules/@stdlib/array/to-iterator-right/test/test.js
index 1a1534dab46c..822341132cde 100644
--- a/lib/node_modules/@stdlib/array/to-iterator-right/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-iterator-right/test/test.js
@@ -157,8 +157,8 @@ tape( 'the function returns an iterator protocol-compliant object, iterating fro
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -210,8 +210,8 @@ tape( 'the function returns an iterator protocol-compliant object, iterating fro
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -235,7 +235,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -274,7 +274,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -298,11 +298,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = array2iteratorRight( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -323,11 +323,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = array2iteratorRight( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -352,11 +352,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = array2iteratorRight( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -377,11 +377,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = array2iteratorRight( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -417,7 +417,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -445,7 +445,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/array/to-iterator/test/test.js b/lib/node_modules/@stdlib/array/to-iterator/test/test.js
index a3554675cb1c..3e78a11b5e95 100644
--- a/lib/node_modules/@stdlib/array/to-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-iterator/test/test.js
@@ -161,8 +161,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -214,8 +214,8 @@ tape( 'the function returns an iterator protocol-compliant object (array-like ob
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -263,8 +263,8 @@ tape( 'the function returns an iterator protocol-compliant object (accessors)',
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'object', 'returns an object' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'object', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -297,7 +297,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -336,7 +336,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -393,8 +393,8 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'object', 'returns an object' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'object', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -422,11 +422,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = array2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -447,11 +447,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = array2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -476,11 +476,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = array2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -501,11 +501,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = array2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -541,7 +541,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -569,7 +569,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/array/to-json/test/test.js b/lib/node_modules/@stdlib/array/to-json/test/test.js
index 9313ef8ca341..e1a96ea80c7c 100644
--- a/lib/node_modules/@stdlib/array/to-json/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-json/test/test.js
@@ -99,7 +99,7 @@ tape( 'the function returns a JSON object', function test( t ) {
 
 	arr = new Float64Array( [ 5.0, 3.0 ] );
 	json = toJSON( arr );
-	t.strictEqual( isPlainObject( json ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( json ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/array/to-sparse-iterator-right/test/test.js b/lib/node_modules/@stdlib/array/to-sparse-iterator-right/test/test.js
index 7770cc75274e..24f80280c6fc 100644
--- a/lib/node_modules/@stdlib/array/to-sparse-iterator-right/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-sparse-iterator-right/test/test.js
@@ -150,8 +150,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -221,8 +221,8 @@ tape( 'the function returns an iterator protocol-compliant object (empty end)',
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -270,8 +270,8 @@ tape( 'the function returns an iterator protocol-compliant object (empty start)'
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -315,8 +315,8 @@ tape( 'the function returns an iterator protocol-compliant object (empty start+e
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -363,8 +363,8 @@ tape( 'the function returns an iterator protocol-compliant object (array-like ob
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -393,7 +393,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
@@ -431,7 +431,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
@@ -537,11 +537,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = sparsearray2iteratorRight( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -562,11 +562,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = sparsearray2iteratorRight( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -591,11 +591,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = sparsearray2iteratorRight( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -616,11 +616,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = sparsearray2iteratorRight( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -656,7 +656,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -684,7 +684,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/array/to-sparse-iterator/test/test.js b/lib/node_modules/@stdlib/array/to-sparse-iterator/test/test.js
index 85981549b1de..b714cc6f278a 100644
--- a/lib/node_modules/@stdlib/array/to-sparse-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-sparse-iterator/test/test.js
@@ -150,8 +150,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -221,8 +221,8 @@ tape( 'the function returns an iterator protocol-compliant object (empty end)',
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -270,8 +270,8 @@ tape( 'the function returns an iterator protocol-compliant object (empty start)'
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -315,8 +315,8 @@ tape( 'the function returns an iterator protocol-compliant object (empty start+e
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -363,8 +363,8 @@ tape( 'the function returns an iterator protocol-compliant object (array-like ob
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -393,7 +393,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
@@ -431,7 +431,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
@@ -537,11 +537,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = sparsearray2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -562,11 +562,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = sparsearray2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -591,11 +591,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = sparsearray2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -616,11 +616,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = sparsearray2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -656,7 +656,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -684,7 +684,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/array/to-strided-iterator/test/test.js b/lib/node_modules/@stdlib/array/to-strided-iterator/test/test.js
index 4816473d8246..3e983864292f 100644
--- a/lib/node_modules/@stdlib/array/to-strided-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-strided-iterator/test/test.js
@@ -329,8 +329,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	for ( i = 0; i < 4; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -390,8 +390,8 @@ tape( 'the function returns an iterator protocol-compliant object (array-like ob
 	for ( i = 0; i < 5; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -415,7 +415,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -453,7 +453,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -566,11 +566,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = stridedarray2iterator( 4, [ 1, 2, 3, 4 ], 1, 0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -591,11 +591,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = stridedarray2iterator( 4, [ 1, 2, 3, 4 ], 1, 0, scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -620,11 +620,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = stridedarray2iterator( 4, [ 1, 2, 3, 4 ], 1, 0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -645,11 +645,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = stridedarray2iterator( 4, [ 1, 2, 3, 4 ], 1, 0, scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -685,7 +685,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -713,7 +713,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/array/to-view-iterator-right/test/test.js b/lib/node_modules/@stdlib/array/to-view-iterator-right/test/test.js
index 51e31db06cf7..290d7091e7e3 100644
--- a/lib/node_modules/@stdlib/array/to-view-iterator-right/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-view-iterator-right/test/test.js
@@ -382,8 +382,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -421,8 +421,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin)', func
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -460,8 +460,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end)',
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -503,8 +503,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end)',
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -546,8 +546,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0)', fu
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -593,8 +593,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0)', fu
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -632,8 +632,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0+end)'
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -671,8 +671,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end<0)'
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -733,8 +733,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0+end<0
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -786,8 +786,8 @@ tape( 'the function returns an iterator protocol-compliant object (array-like ob
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -811,7 +811,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -848,7 +848,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -884,7 +884,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
@@ -917,7 +917,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
@@ -950,7 +950,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
@@ -983,7 +983,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
@@ -1016,7 +1016,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
@@ -1049,7 +1049,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
@@ -1088,7 +1088,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -1112,11 +1112,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -1137,11 +1137,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -1166,11 +1166,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -1191,11 +1191,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = arrayview2iteratorRight( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -1231,7 +1231,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -1259,7 +1259,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -1287,7 +1287,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -1315,7 +1315,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -1347,7 +1347,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -1379,7 +1379,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/array/to-view-iterator/test/test.js b/lib/node_modules/@stdlib/array/to-view-iterator/test/test.js
index be0a7ecfdbdf..893c7846e822 100644
--- a/lib/node_modules/@stdlib/array/to-view-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/array/to-view-iterator/test/test.js
@@ -382,8 +382,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -421,8 +421,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin)', func
 	for ( i = 0; i < 2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -460,8 +460,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end)',
 	for ( i = 0; i < 2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -503,8 +503,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end)',
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -546,8 +546,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0)', fu
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -593,8 +593,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0)', fu
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -632,8 +632,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0+end)'
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -671,8 +671,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin+end<0)'
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -733,8 +733,8 @@ tape( 'the function returns an iterator protocol-compliant object (begin<0+end<0
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -786,8 +786,8 @@ tape( 'the function returns an iterator protocol-compliant object (array-like ob
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -811,7 +811,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -848,7 +848,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -884,7 +884,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
@@ -917,7 +917,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-1; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-1, 'has expected length' );
 
@@ -950,7 +950,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
@@ -983,7 +983,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
@@ -1016,7 +1016,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
@@ -1049,7 +1049,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length-2; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length-2, 'has expected length' );
 
@@ -1088,7 +1088,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < values.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -1112,11 +1112,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = arrayview2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -1137,11 +1137,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = arrayview2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -1166,11 +1166,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = arrayview2iterator( [ 1, 2, 3, 4 ] );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -1191,11 +1191,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = arrayview2iterator( [ 1, 2, 3, 4 ], scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -1231,7 +1231,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -1259,7 +1259,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -1287,7 +1287,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -1315,7 +1315,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -1347,7 +1347,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -1379,7 +1379,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.factory.js b/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.factory.js
index 350390adaf9a..a581ee5e957a 100644
--- a/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.factory.js
+++ b/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.factory.js
@@ -119,7 +119,7 @@ tape( 'the function throws an error if an invalid option', function test( t ) {
 
 tape( 'the function returns a function (no options)', function test( t ) {
 	var has = factory( 'a.b.c' );
-	t.strictEqual( typeof has, 'function', 'returns a function' );
+	t.strictEqual( typeof has, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -132,7 +132,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	};
 	has = factory( 'a/b/c', opts );
 
-	t.strictEqual( typeof has, 'function', 'returns a function' );
+	t.strictEqual( typeof has, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -193,7 +193,7 @@ tape( 'the returned function returns `true` if an object has a specified path (d
 	};
 	bool = has( obj );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -217,7 +217,7 @@ tape( 'the returned function returns `true` if an object has a specified path (k
 	};
 	bool = has( obj );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -243,7 +243,7 @@ tape( 'the returned function returns `true` if an object has a specified path (c
 	};
 	bool = has( obj );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -264,7 +264,7 @@ tape( 'the returned function returns `false` if an object does not have a specif
 	};
 	bool = has( obj );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -288,7 +288,7 @@ tape( 'the returned function returns `false` if an object does not have a specif
 	};
 	bool = has( obj );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -314,7 +314,7 @@ tape( 'the returned function returns `false` if an object does not have a specif
 	};
 	bool = has( obj );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -325,16 +325,16 @@ tape( 'the returned function returns `false` if provided an empty object (no opt
 
 	has = factory( 'a.b.c' );
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	path = [ 'a', 'b', 'c' ];
 	has = factory( path );
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	has = factory( '' );
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -351,16 +351,16 @@ tape( 'the returned function returns `false` if provided an empty object (option
 
 	has = factory( 'a/b/c', opts );
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	path = [ 'a', 'b', 'c' ];
 	has = factory( path, opts );
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	has = factory( '', opts );
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -375,7 +375,7 @@ tape( 'the returned function can return `true` if provided an empty key path (st
 		'': 'b'
 	};
 	bool = has( obj );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -395,7 +395,7 @@ tape( 'the returned function can return `true` if provided an empty key path (st
 		'': 'b'
 	};
 	bool = has( obj );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -410,10 +410,10 @@ tape( 'the returned function always returns `false` if provided an empty key pat
 		'': 'b'
 	};
 	bool = has( obj );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -433,11 +433,11 @@ tape( 'the returned function only returns `true` for "own" properties', function
 
 	has = factory( 'a' );
 	bool = has( foo );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	has = factory( 'c' );
 	bool = has( foo );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -449,6 +449,6 @@ tape( 'the returned function coerces primitives to objects', function test( t )
 	has = factory( 'length' );
 	bool = has( 'beep' );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.validate.js b/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.validate.js
index 6985e0dfd798..d1d07bf9b0c0 100644
--- a/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.validate.js
+++ b/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.validate.js
@@ -95,7 +95,7 @@ tape( 'the function will ignore unrecognized properties', function test( t ) {
 	};
 	obj = {};
 
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 
 	t.end();
@@ -110,7 +110,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.strictEqual( obj.sep, '_', 'sets option value' );
 
 	opts = {
@@ -118,7 +118,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.strictEqual( obj.sep, '/', 'sets option value' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/assert/deep-has-property/test/test.factory.js b/lib/node_modules/@stdlib/assert/deep-has-property/test/test.factory.js
index 5d15cf08a425..14ea2fe020b7 100644
--- a/lib/node_modules/@stdlib/assert/deep-has-property/test/test.factory.js
+++ b/lib/node_modules/@stdlib/assert/deep-has-property/test/test.factory.js
@@ -119,7 +119,7 @@ tape( 'the function throws an error if an invalid option', function test( t ) {
 
 tape( 'the function returns a function (no options)', function test( t ) {
 	var has = factory( 'a.b.c' );
-	t.strictEqual( typeof has, 'function', 'returns a function' );
+	t.strictEqual( typeof has, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -132,7 +132,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	};
 	has = factory( 'a/b/c', opts );
 
-	t.strictEqual( typeof has, 'function', 'returns a function' );
+	t.strictEqual( typeof has, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -193,7 +193,7 @@ tape( 'the returned function returns `true` if an object has a specified path (d
 	};
 	bool = has( obj );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -217,7 +217,7 @@ tape( 'the returned function returns `true` if an object has a specified path (k
 	};
 	bool = has( obj );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -243,7 +243,7 @@ tape( 'the returned function returns `true` if an object has a specified path (c
 	};
 	bool = has( obj );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -264,7 +264,7 @@ tape( 'the returned function returns `false` if an object does not have a specif
 	};
 	bool = has( obj );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -288,7 +288,7 @@ tape( 'the returned function returns `false` if an object does not have a specif
 	};
 	bool = has( obj );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -314,7 +314,7 @@ tape( 'the returned function returns `false` if an object does not have a specif
 	};
 	bool = has( obj );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -325,16 +325,16 @@ tape( 'the returned function returns `false` if provided an empty object (no opt
 
 	has = factory( 'a.b.c' );
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	path = [ 'a', 'b', 'c' ];
 	has = factory( path );
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	has = factory( '' );
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -351,16 +351,16 @@ tape( 'the returned function returns `false` if provided an empty object (option
 
 	has = factory( 'a/b/c', opts );
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	path = [ 'a', 'b', 'c' ];
 	has = factory( path, opts );
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	has = factory( '', opts );
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -375,7 +375,7 @@ tape( 'the returned function can return `true` if provided an empty key path (st
 		'': 'b'
 	};
 	bool = has( obj );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -395,7 +395,7 @@ tape( 'the returned function can return `true` if provided an empty key path (st
 		'': 'b'
 	};
 	bool = has( obj );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -410,10 +410,10 @@ tape( 'the returned function always returns `false` if provided an empty key pat
 		'': 'b'
 	};
 	bool = has( obj );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = has( {} );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -433,11 +433,11 @@ tape( 'the returned function supports paths containing inherited properties', fu
 
 	has = factory( 'a' );
 	bool = has( foo );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	has = factory( 'c' );
 	bool = has( foo );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -449,6 +449,6 @@ tape( 'the returned function coerces primitives to objects', function test( t )
 	has = factory( 'length' );
 	bool = has( 'beep' );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/deep-has-property/test/test.validate.js b/lib/node_modules/@stdlib/assert/deep-has-property/test/test.validate.js
index 6985e0dfd798..d1d07bf9b0c0 100644
--- a/lib/node_modules/@stdlib/assert/deep-has-property/test/test.validate.js
+++ b/lib/node_modules/@stdlib/assert/deep-has-property/test/test.validate.js
@@ -95,7 +95,7 @@ tape( 'the function will ignore unrecognized properties', function test( t ) {
 	};
 	obj = {};
 
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 
 	t.end();
@@ -110,7 +110,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.strictEqual( obj.sep, '_', 'sets option value' );
 
 	opts = {
@@ -118,7 +118,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.strictEqual( obj.sep, '/', 'sets option value' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/bench/harness/test/test.bench.js b/lib/node_modules/@stdlib/bench/harness/test/test.bench.js
index 00452a9724e7..824792d1943b 100644
--- a/lib/node_modules/@stdlib/bench/harness/test/test.bench.js
+++ b/lib/node_modules/@stdlib/bench/harness/test/test.bench.js
@@ -1013,7 +1013,7 @@ tape( 'if `createStream` is called before providing adding one or more benchmark
 
 	function onData( data ) {
 		flg = true;
-		t.strictEqual( typeof data, 'object', 'returns an object' );
+		t.strictEqual( typeof data, 'object', 'returns expected value' );
 	}
 
 	function onFinish() {
diff --git a/lib/node_modules/@stdlib/bench/harness/test/test.exit_harness.js b/lib/node_modules/@stdlib/bench/harness/test/test.exit_harness.js
index a1db38fa4d0c..1be64634a33d 100644
--- a/lib/node_modules/@stdlib/bench/harness/test/test.exit_harness.js
+++ b/lib/node_modules/@stdlib/bench/harness/test/test.exit_harness.js
@@ -23,7 +23,7 @@
 var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
 var noop = require( '@stdlib/utils/noop' );
-var TransformStream = require( '@stdlib/streams/node/transform' );
+var TransformStream = require( '@stdlib/streams/node/transform' ); // eslint-disable-line stdlib/no-redeclare
 var exitHarness = require( './../lib/exit_harness.js' );
 
 
@@ -250,19 +250,19 @@ tape( 'the function throws an error if provided a `stream` option which is not s
 
 tape( 'the function returns a function (no arguments)', function test( t ) {
 	var harness = exitHarness();
-	t.strictEqual( typeof harness, 'function', 'returns a function' );
+	t.strictEqual( typeof harness, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a function (one argument)', function test( t ) {
 	var harness = exitHarness( {} );
-	t.strictEqual( typeof harness, 'function', 'returns a function' );
+	t.strictEqual( typeof harness, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a function (more than one argument)', function test( t ) {
 	var harness = exitHarness( {}, noop );
-	t.strictEqual( typeof harness, 'function', 'returns a function' );
+	t.strictEqual( typeof harness, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/bench/harness/test/test.get_harness.js b/lib/node_modules/@stdlib/bench/harness/test/test.get_harness.js
index d0d10842cdc6..e494565eac55 100644
--- a/lib/node_modules/@stdlib/bench/harness/test/test.get_harness.js
+++ b/lib/node_modules/@stdlib/bench/harness/test/test.get_harness.js
@@ -44,7 +44,7 @@ tape( 'the function returns a function, which is cached and returned for subsequ
 	t.notEqual( getHarness.cached, true, 'does not have a cached harness' );
 
 	harness = getHarness( {}, noop );
-	t.strictEqual( typeof harness, 'function', 'returns a function' );
+	t.strictEqual( typeof harness, 'function', 'returns expected value' );
 
 	t.strictEqual( getHarness.cached, true, 'has a cached harness' );
 
diff --git a/lib/node_modules/@stdlib/bench/harness/test/test.harness.js b/lib/node_modules/@stdlib/bench/harness/test/test.harness.js
index 7bf1bca424ca..eca145cc9385 100644
--- a/lib/node_modules/@stdlib/bench/harness/test/test.harness.js
+++ b/lib/node_modules/@stdlib/bench/harness/test/test.harness.js
@@ -156,25 +156,25 @@ tape( 'the function throws an error if provided an callback argument which is no
 
 tape( 'the function returns a function (no arguments)', function test( t ) {
 	var harness = createHarness();
-	t.strictEqual( typeof harness, 'function', 'returns a function' );
+	t.strictEqual( typeof harness, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a function (options)', function test( t ) {
 	var harness = createHarness({} );
-	t.strictEqual( typeof harness, 'function', 'returns a function' );
+	t.strictEqual( typeof harness, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a function (callback)', function test( t ) {
 	var harness = createHarness( noop );
-	t.strictEqual( typeof harness, 'function', 'returns a function' );
+	t.strictEqual( typeof harness, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a function (more than 1 argument)', function test( t ) {
 	var harness = createHarness({}, noop );
-	t.strictEqual( typeof harness, 'function', 'returns a function' );
+	t.strictEqual( typeof harness, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/bench/harness/test/test.harness.validate.js b/lib/node_modules/@stdlib/bench/harness/test/test.harness.validate.js
index 85002d84bec2..489dd0127b21 100644
--- a/lib/node_modules/@stdlib/bench/harness/test/test.harness.validate.js
+++ b/lib/node_modules/@stdlib/bench/harness/test/test.harness.validate.js
@@ -189,7 +189,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -207,7 +207,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/bigint/ctor/test/test.js b/lib/node_modules/@stdlib/bigint/ctor/test/test.js
index 5369e0560ab8..261e510c6037 100644
--- a/lib/node_modules/@stdlib/bigint/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/bigint/ctor/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function returns BigInts', opts, function test( t ) {
 tape( 'to generate a BigInt object, must wrap in `Object` call', opts, function test( t ) {
 	var v = Object( BigInteger( '1' ) );
 	t.strictEqual( isBigInt.isPrimitive( v ), false, 'does not return a primitive' );
-	t.strictEqual( isBigInt.isObject( v ), true, 'returns an object' );
+	t.strictEqual( isBigInt.isObject( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/buffer/to-json/test/test.js b/lib/node_modules/@stdlib/buffer/to-json/test/test.js
index 3a212775b3cf..15026f89052d 100644
--- a/lib/node_modules/@stdlib/buffer/to-json/test/test.js
+++ b/lib/node_modules/@stdlib/buffer/to-json/test/test.js
@@ -73,7 +73,7 @@ tape( 'the function returns a JSON object', function test( t ) {
 	buf = array2buffer( [ 1, 2 ] );
 	json = toJSON( buf );
 
-	t.strictEqual( isPlainObject( json ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( json ), true, 'returns expected value' );
 
 	expected = {
 		'type': 'Buffer',
@@ -93,7 +93,7 @@ tape( 'the function returns a JSON object (empty)', function test( t ) {
 	buf = array2buffer( [] );
 	json = toJSON( buf );
 
-	t.strictEqual( isPlainObject( json ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( json ), true, 'returns expected value' );
 
 	expected = {
 		'type': 'Buffer',
diff --git a/lib/node_modules/@stdlib/cli/ctor/test/test.validate.js b/lib/node_modules/@stdlib/cli/ctor/test/test.validate.js
index 683a1df4cb10..3c8574eed658 100644
--- a/lib/node_modules/@stdlib/cli/ctor/test/test.validate.js
+++ b/lib/node_modules/@stdlib/cli/ctor/test/test.validate.js
@@ -269,7 +269,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -287,7 +287,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/complex/base/parse/test/test.js b/lib/node_modules/@stdlib/complex/base/parse/test/test.js
index a3c8bfaf0348..7dcee4c10063 100644
--- a/lib/node_modules/@stdlib/complex/base/parse/test/test.js
+++ b/lib/node_modules/@stdlib/complex/base/parse/test/test.js
@@ -165,7 +165,7 @@ tape( 'the function returns null if provided input is not a complex number strin
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( parse( values[ i ] ), null, 'returns null' );
+		t.strictEqual( parse( values[ i ] ), null, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/promotion-rules/test/test.js b/lib/node_modules/@stdlib/complex/promotion-rules/test/test.js
index 1e209b1ac850..196865493ce4 100644
--- a/lib/node_modules/@stdlib/complex/promotion-rules/test/test.js
+++ b/lib/node_modules/@stdlib/complex/promotion-rules/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if not provided data types, the function returns a table', function test( t ) {
 	var out = promotionRules();
-	t.strictEqual( isObject( out ), true, 'returns an object' );
+	t.strictEqual( isObject( out ), true, 'returns expected value' );
 	t.strictEqual( out[ 'complex128' ][ 'uint32' ], 'complex128', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/cmudict/test/test.browser.js b/lib/node_modules/@stdlib/datasets/cmudict/test/test.browser.js
index a68cc5666ca5..ad14bf50dc59 100644
--- a/lib/node_modules/@stdlib/datasets/cmudict/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/cmudict/test/test.browser.js
@@ -107,7 +107,7 @@ tape( 'if not provided a `data` option, the function returns an `object`', funct
 	var d2;
 
 	data = cmudict();
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 	t.strictEqual( hasOwnProp( data, 'dict' ), true, 'has `dict` property' );
 	t.strictEqual( hasOwnProp( data, 'phones' ), true, 'has `phones` property' );
 	t.strictEqual( hasOwnProp( data, 'symbols' ), true, 'has `symbols` property' );
@@ -129,7 +129,7 @@ tape( 'if not provided a `data` option, the function returns an `object` (option
 	var d2;
 
 	data = cmudict( {} );
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 	t.strictEqual( hasOwnProp( data, 'dict' ), true, 'has `dict` property' );
 	t.strictEqual( hasOwnProp( data, 'phones' ), true, 'has `phones` property' );
 	t.strictEqual( hasOwnProp( data, 'symbols' ), true, 'has `symbols` property' );
@@ -156,7 +156,7 @@ tape( 'if the `data` option is `dict`, the function returns an object', function
 	};
 	data = cmudict( opts );
 
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
@@ -174,7 +174,7 @@ tape( 'if the `data` option is `phones`, the function returns an object', functi
 	};
 	data = cmudict( opts );
 
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
@@ -210,7 +210,7 @@ tape( 'if the `data` option is `vp`, the function returns an object', function t
 	};
 	data = cmudict( opts );
 
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
diff --git a/lib/node_modules/@stdlib/datasets/cmudict/test/test.js b/lib/node_modules/@stdlib/datasets/cmudict/test/test.js
index 16a4cac05966..3bd0cf9bb7e7 100644
--- a/lib/node_modules/@stdlib/datasets/cmudict/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/cmudict/test/test.js
@@ -115,7 +115,7 @@ tape( 'if not provided a `data` option, the function returns an `object`', opts,
 	var d2;
 
 	data = cmudict();
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 	t.strictEqual( hasOwnProp( data, 'dict' ), true, 'has `dict` property' );
 	t.strictEqual( hasOwnProp( data, 'phones' ), true, 'has `phones` property' );
 	t.strictEqual( hasOwnProp( data, 'symbols' ), true, 'has `symbols` property' );
@@ -137,7 +137,7 @@ tape( 'if not provided a `data` option, the function returns an `object` (option
 	var d2;
 
 	data = cmudict( {} );
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 	t.strictEqual( hasOwnProp( data, 'dict' ), true, 'has `dict` property' );
 	t.strictEqual( hasOwnProp( data, 'phones' ), true, 'has `phones` property' );
 	t.strictEqual( hasOwnProp( data, 'symbols' ), true, 'has `symbols` property' );
@@ -164,7 +164,7 @@ tape( 'if the `data` option is `dict`, the function returns an object', opts, fu
 	};
 	data = cmudict( opts );
 
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
@@ -182,7 +182,7 @@ tape( 'if the `data` option is `phones`, the function returns an object', opts,
 	};
 	data = cmudict( opts );
 
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
@@ -218,7 +218,7 @@ tape( 'if the `data` option is `vp`, the function returns an object', opts, func
 	};
 	data = cmudict( opts );
 
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 
 	// Should return a copy...
 	d2 = cmudict( opts );
diff --git a/lib/node_modules/@stdlib/datasets/cmudict/test/test.validate.js b/lib/node_modules/@stdlib/datasets/cmudict/test/test.validate.js
index dd07d8d40569..8bca1e7946d0 100644
--- a/lib/node_modules/@stdlib/datasets/cmudict/test/test.validate.js
+++ b/lib/node_modules/@stdlib/datasets/cmudict/test/test.validate.js
@@ -96,7 +96,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'sets option values' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.browser.js b/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.browser.js
index 652d852410bc..9f8c966eee0d 100644
--- a/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.browser.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var tbl = table();
-	t.strictEqual( isPlainObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( tbl ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.js b/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.js
index 2d5577eafa3d..fc739f050642 100644
--- a/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/emoji-code-picto/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', opts, function test( t ) {
 	var tbl = table();
-	t.strictEqual( isPlainObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( tbl ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.browser.js b/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.browser.js
index 4270b9f97d6b..431694ada6c1 100644
--- a/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.browser.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var tbl = table();
-	t.strictEqual( isPlainObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( tbl ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.js b/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.js
index b7ca8f157320..5f65aeddaaef 100644
--- a/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/emoji-picto-code/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', opts, function test( t ) {
 	var tbl = table();
-	t.strictEqual( isPlainObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( tbl ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.browser.js b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.browser.js
index 4b4e15150dbb..8fd07673c01c 100644
--- a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.browser.js
@@ -107,7 +107,7 @@ tape( 'if not provided a `data` option, the function returns an `object`', funct
 	var d2;
 
 	data = minard();
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 	t.strictEqual( hasOwnProp( data, 'army' ), true, 'has `army` property' );
 	t.strictEqual( hasOwnProp( data, 'cities' ), true, 'has `cities` property' );
 	t.strictEqual( hasOwnProp( data, 'labels' ), true, 'has `labels` property' );
@@ -131,7 +131,7 @@ tape( 'if not provided a `data` option, the function returns an `object` (option
 	var d2;
 
 	data = minard( {} );
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 	t.strictEqual( hasOwnProp( data, 'army' ), true, 'has `army` property' );
 	t.strictEqual( hasOwnProp( data, 'cities' ), true, 'has `cities` property' );
 	t.strictEqual( hasOwnProp( data, 'labels' ), true, 'has `labels` property' );
@@ -220,7 +220,7 @@ tape( 'if the `data` option is `rivers`, the function returns an object', functi
 	};
 	data = minard( opts );
 
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
diff --git a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.js b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.js
index 5206c3509d4d..595ef28ede99 100644
--- a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.js
@@ -115,7 +115,7 @@ tape( 'if not provided a `data` option, the function returns an `object`', opts,
 	var d2;
 
 	data = minard();
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 	t.strictEqual( hasOwnProp( data, 'army' ), true, 'has `army` property' );
 	t.strictEqual( hasOwnProp( data, 'cities' ), true, 'has `cities` property' );
 	t.strictEqual( hasOwnProp( data, 'labels' ), true, 'has `labels` property' );
@@ -139,7 +139,7 @@ tape( 'if not provided a `data` option, the function returns an `object` (option
 	var d2;
 
 	data = minard( {} );
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 	t.strictEqual( hasOwnProp( data, 'army' ), true, 'has `army` property' );
 	t.strictEqual( hasOwnProp( data, 'cities' ), true, 'has `cities` property' );
 	t.strictEqual( hasOwnProp( data, 'labels' ), true, 'has `labels` property' );
@@ -228,7 +228,7 @@ tape( 'if the `data` option is `rivers`, the function returns an object', opts,
 	};
 	data = minard( opts );
 
-	t.strictEqual( isObject( data ), true, 'returns an object' );
+	t.strictEqual( isObject( data ), true, 'returns expected value' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
diff --git a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.validate.js b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.validate.js
index 7ab2438a2dde..cd33fd8643d9 100644
--- a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.validate.js
+++ b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.validate.js
@@ -96,7 +96,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'sets option values' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_get_file.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_get_file.js
index 1be478c7e9cd..99c3d378b192 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_get_file.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.browser_get_file.js
@@ -47,6 +47,6 @@ tape( 'the function returns an object', function test( t ) {
 			'./db.js': db
 		});
 	}
-	t.strictEqual( isObject( fcn( 0 ) ), true, 'returns an object' );
+	t.strictEqual( isObject( fcn( 0 ) ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.get_file.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.get_file.js
index 2c3e71985fd9..60fb947555cc 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.get_file.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.get_file.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( isObject( getFile( 0 ) ), true, 'returns an object' );
+	t.strictEqual( isObject( getFile( 0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.validate.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.validate.js
index fcfb0ae62265..0e265e83e2dd 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.validate.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.validate.js
@@ -223,7 +223,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'sets option values' );
 
 	options = {
@@ -242,7 +242,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'sets option values' );
 
 	t.end();
@@ -260,7 +260,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.browser.js b/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.browser.js
index 86618474dd28..440423ce33be 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.browser.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var tbl = table();
-	t.strictEqual( isObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isObject( tbl ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.js b/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.js
index 7f87b43c2aeb..8b3e66149b9e 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-capitals-names/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', opts, function test( t ) {
 	var tbl = table();
-	t.strictEqual( isObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isObject( tbl ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.browser.js b/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.browser.js
index d309081284f0..ba4d48018391 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.browser.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', function test( t ) {
 	var tbl = table();
-	t.strictEqual( isObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isObject( tbl ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.js b/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.js
index 7bc853f33d0c..ac8ded993bcd 100644
--- a/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/us-states-names-capitals/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an object', opts, function test( t ) {
 	var tbl = table();
-	t.strictEqual( isObject( tbl ), true, 'returns an object' );
+	t.strictEqual( isObject( tbl ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/dstructs/circular-buffer/test/test.js b/lib/node_modules/@stdlib/dstructs/circular-buffer/test/test.js
index ef150d78aaeb..0ccb1a2301dd 100644
--- a/lib/node_modules/@stdlib/dstructs/circular-buffer/test/test.js
+++ b/lib/node_modules/@stdlib/dstructs/circular-buffer/test/test.js
@@ -196,7 +196,7 @@ tape( 'the constructor returns a circular buffer instance which has an `iterator
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'string', 'returns a string' );
+		t.strictEqual( typeof v.value, 'string', 'returns expected value' );
 		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
@@ -217,7 +217,7 @@ tape( 'the constructor returns a circular buffer instance which has an `iterator
 	it = buf.iterator( buf.length );
 	for ( i = 0; i < buf.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'string', 'returns a string' );
+		t.strictEqual( typeof v.value, 'string', 'returns expected value' );
 		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	v = it.next();
@@ -308,7 +308,7 @@ tape( 'a returned iterator does support iterating over a buffer which, while not
 
 	for ( i = 0; i < 100; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'string', 'returns a string' );
+		t.strictEqual( typeof v.value, 'string', 'returns expected value' );
 		t.strictEqual( v.done, false, 'returns expected value' );
 	}
 	t.end();
@@ -412,7 +412,7 @@ tape( 'if an environment supports `Symbol.iterator`, a circular buffer instance
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/dstructs/doubly-linked-list/test/test.js b/lib/node_modules/@stdlib/dstructs/doubly-linked-list/test/test.js
index 1b6c7bb8ea07..9c47be38c867 100644
--- a/lib/node_modules/@stdlib/dstructs/doubly-linked-list/test/test.js
+++ b/lib/node_modules/@stdlib/dstructs/doubly-linked-list/test/test.js
@@ -303,8 +303,8 @@ tape( 'the constructor returns a linked list instance which has an `iterator` me
 
 	for ( i = 0; i < list.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'string', 'returns a string' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'string', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -488,7 +488,7 @@ tape( 'if an environment supports `Symbol.iterator`, a list instance iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/dstructs/fifo/test/test.js b/lib/node_modules/@stdlib/dstructs/fifo/test/test.js
index 75bc5fbe2d94..83772cc0c643 100644
--- a/lib/node_modules/@stdlib/dstructs/fifo/test/test.js
+++ b/lib/node_modules/@stdlib/dstructs/fifo/test/test.js
@@ -113,8 +113,8 @@ tape( 'the constructor returns a queue instance which has an `iterator` method w
 
 	for ( i = 0; i < q.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'string', 'returns a string' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'string', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -244,7 +244,7 @@ tape( 'if an environment supports `Symbol.iterator`, a queue instance iterator i
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/dstructs/linked-list/test/test.js b/lib/node_modules/@stdlib/dstructs/linked-list/test/test.js
index f21afb0396e1..777e483fad55 100644
--- a/lib/node_modules/@stdlib/dstructs/linked-list/test/test.js
+++ b/lib/node_modules/@stdlib/dstructs/linked-list/test/test.js
@@ -156,8 +156,8 @@ tape( 'the constructor returns a linked list instance which has an `iterator` me
 
 	for ( i = 0; i < list.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'string', 'returns a string' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'string', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -287,7 +287,7 @@ tape( 'if an environment supports `Symbol.iterator`, a list instance iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/dstructs/stack/test/test.js b/lib/node_modules/@stdlib/dstructs/stack/test/test.js
index 542b374be7e7..d15c6504d0aa 100644
--- a/lib/node_modules/@stdlib/dstructs/stack/test/test.js
+++ b/lib/node_modules/@stdlib/dstructs/stack/test/test.js
@@ -113,8 +113,8 @@ tape( 'the constructor returns a stack instance which has an `iterator` method w
 
 	for ( i = 0; i < s.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'string', 'returns a string' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'string', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -244,7 +244,7 @@ tape( 'if an environment supports `Symbol.iterator`, a stack instance iterator i
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has `next` method' );
 	t.strictEqual( typeof it2.return, 'function', 'has `return` method' );
 
diff --git a/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.js b/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.js
index 77ad8865a8be..97cf9a5713af 100644
--- a/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.js
+++ b/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.js
@@ -94,7 +94,7 @@ tape( 'the function returns an error message function', function test( t ) {
 	formatProdErrorMessage = fmtprodmsgFactory( opts );
 	str = formatProdErrorMessage( '6', 'boop' );
 
-	t.strictEqual( typeof formatProdErrorMessage, 'function', 'returns a function' );
+	t.strictEqual( typeof formatProdErrorMessage, 'function', 'returns expected value' );
 	t.strictEqual( typeof str, 'string', 'returned function returns a string' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.validate.js b/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.validate.js
index b1536ce0be2a..51166088a832 100644
--- a/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.validate.js
+++ b/lib/node_modules/@stdlib/error/tools/fmtprodmsg-factory/test/test.validate.js
@@ -118,7 +118,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.url, opts.url, 'sets url option' );
 	t.strictEqual( obj.message, opts.message, 'sets message option' );
 
@@ -138,7 +138,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.async.js b/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.async.js
index 1e4b655c875c..ab9960518145 100644
--- a/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.async.js
+++ b/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.async.js
@@ -343,7 +343,7 @@ tape( 'the function returns `null` if unable to resolve a parent path', opts, fu
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( actual, null, 'returns null' );
+		t.strictEqual( actual, null, 'returns expected value' );
 		t.end();
 	}
 
@@ -362,7 +362,7 @@ tape( 'the function returns `null` if unable to resolve a parent path (options)'
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( actual, null, 'returns null' );
+		t.strictEqual( actual, null, 'returns expected value' );
 		t.end();
 	}
 
diff --git a/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.sync.js b/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.sync.js
index b811a94fb3a7..0e0812415f49 100644
--- a/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.sync.js
@@ -268,7 +268,7 @@ tape( 'the function resolves a path by walking parent directories (dir option)',
 tape( 'the function returns `null` if unable to resolve a parent path', opts, function test( t ) {
 	var actual = resolveParentPathBy( 'beep-boop!!!hello world!?!', predicate );
 
-	t.strictEqual( actual, null, 'returns null' );
+	t.strictEqual( actual, null, 'returns expected value' );
 	t.end();
 
 	function predicate() {
@@ -285,7 +285,7 @@ tape( 'the function returns `null` if unable to resolve a parent path (options)'
 	};
 	actual = resolveParentPathBy( 'beep-boop!!!hello world!?!', opts, predicate );
 
-	t.strictEqual( actual, null, 'returns null' );
+	t.strictEqual( actual, null, 'returns expected value' );
 	t.end();
 
 	function predicate() {
diff --git a/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.validate.js b/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.validate.js
index 8f2432fbb6cf..7535c7250d24 100644
--- a/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/fs/resolve-parent-path-by/test/test.validate.js
@@ -95,7 +95,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.async.js b/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.async.js
index 60f35e1cf7f9..e407300493a9 100644
--- a/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.async.js
+++ b/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.async.js
@@ -256,7 +256,7 @@ tape( 'the function returns `null` if unable to resolve a parent path', opts, fu
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( actual, null, 'returns null' );
+		t.strictEqual( actual, null, 'returns expected value' );
 		t.end();
 	}
 });
@@ -271,7 +271,7 @@ tape( 'the function returns `null` if unable to resolve a parent path (options)'
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( actual, null, 'returns null' );
+		t.strictEqual( actual, null, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.sync.js b/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.sync.js
index 4c3a7bdba58f..aaad6234cb88 100644
--- a/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.sync.js
@@ -189,7 +189,7 @@ tape( 'the function resolves a path by walking parent directories (dir option)',
 tape( 'the function returns `null` if unable to resolve a parent path', opts, function test( t ) {
 	var actual = resolveParentPath( 'beep-boop!!!hello world!?!' );
 
-	t.strictEqual( actual, null, 'returns null' );
+	t.strictEqual( actual, null, 'returns expected value' );
 	t.end();
 });
 
@@ -202,6 +202,6 @@ tape( 'the function returns `null` if unable to resolve a parent path (options)'
 	};
 	actual = resolveParentPath( 'beep-boop!!!hello world!?!', opts );
 
-	t.strictEqual( actual, null, 'returns null' );
+	t.strictEqual( actual, null, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.validate.js b/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.validate.js
index 0128fe87cbd2..30d5631c0594 100644
--- a/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.validate.js
+++ b/lib/node_modules/@stdlib/fs/resolve-parent-path/test/test.validate.js
@@ -95,7 +95,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.dir, opts.dir, 'sets dir option' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/iter/concat/test/test.js b/lib/node_modules/@stdlib/iter/concat/test/test.js
index ba97edc36552..b3a544648b28 100644
--- a/lib/node_modules/@stdlib/iter/concat/test/test.js
+++ b/lib/node_modules/@stdlib/iter/concat/test/test.js
@@ -425,11 +425,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterConcat( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -450,11 +450,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterConcat( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -491,7 +491,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/constant/test/test.js b/lib/node_modules/@stdlib/iter/constant/test/test.js
index 1175e33fdba4..2952f5d91694 100644
--- a/lib/node_modules/@stdlib/iter/constant/test/test.js
+++ b/lib/node_modules/@stdlib/iter/constant/test/test.js
@@ -250,11 +250,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterConstant( 3.14 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -275,11 +275,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterConstant( 3.14 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -308,7 +308,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/counter/test/test.js b/lib/node_modules/@stdlib/iter/counter/test/test.js
index b5e9fc8d79f5..90ea3049b269 100644
--- a/lib/node_modules/@stdlib/iter/counter/test/test.js
+++ b/lib/node_modules/@stdlib/iter/counter/test/test.js
@@ -137,11 +137,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCounter( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -162,11 +162,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCounter( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -203,7 +203,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/cuany-by/test/test.js b/lib/node_modules/@stdlib/iter/cuany-by/test/test.js
index 3605358d5068..648d781d7b22 100644
--- a/lib/node_modules/@stdlib/iter/cuany-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cuany-by/test/test.js
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/cuany/test/test.js b/lib/node_modules/@stdlib/iter/cuany/test/test.js
index 41fbd12c3661..999f33a92140 100644
--- a/lib/node_modules/@stdlib/iter/cuany/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cuany/test/test.js
@@ -275,7 +275,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/cuevery-by/test/test.js b/lib/node_modules/@stdlib/iter/cuevery-by/test/test.js
index 1d237c51af1d..3e3b9dd0a54c 100644
--- a/lib/node_modules/@stdlib/iter/cuevery-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cuevery-by/test/test.js
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/cuevery/test/test.js b/lib/node_modules/@stdlib/iter/cuevery/test/test.js
index 7d3329f1965e..4d46a9b488f1 100644
--- a/lib/node_modules/@stdlib/iter/cuevery/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cuevery/test/test.js
@@ -275,7 +275,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/cunone-by/test/test.js b/lib/node_modules/@stdlib/iter/cunone-by/test/test.js
index 632c68ab1033..6bc43f15863a 100644
--- a/lib/node_modules/@stdlib/iter/cunone-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cunone-by/test/test.js
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/cunone/test/test.js b/lib/node_modules/@stdlib/iter/cunone/test/test.js
index 490ecc9b3842..45ab0365c7cd 100644
--- a/lib/node_modules/@stdlib/iter/cunone/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cunone/test/test.js
@@ -275,7 +275,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/cusome-by/test/test.js b/lib/node_modules/@stdlib/iter/cusome-by/test/test.js
index f0cdbeac1edf..bd29329de4dd 100644
--- a/lib/node_modules/@stdlib/iter/cusome-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cusome-by/test/test.js
@@ -265,11 +265,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCuSomeBy( array2iterator( [ 1, 1, 1, 0, 0 ] ), 3, predicate );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
@@ -301,11 +301,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCuSomeBy( array2iterator( [ 1, 1, 1, 0, 0 ] ), 3, predicate );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof r.value, 'boolean', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -339,7 +339,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( typeof it1[ Symbol.iterator ], 'function', 'has method' );
 
 	it2 = it1[ Symbol.iterator ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/cusome/test/test.js b/lib/node_modules/@stdlib/iter/cusome/test/test.js
index f3d6c339eef8..930ae841ee35 100644
--- a/lib/node_modules/@stdlib/iter/cusome/test/test.js
+++ b/lib/node_modules/@stdlib/iter/cusome/test/test.js
@@ -296,7 +296,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/datespace/test/test.js b/lib/node_modules/@stdlib/iter/datespace/test/test.js
index 120ad5e18cec..d641513520d3 100644
--- a/lib/node_modules/@stdlib/iter/datespace/test/test.js
+++ b/lib/node_modules/@stdlib/iter/datespace/test/test.js
@@ -944,7 +944,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/dedupe-by/test/test.js b/lib/node_modules/@stdlib/iter/dedupe-by/test/test.js
index 9c3849323e0c..1a130c864ef4 100644
--- a/lib/node_modules/@stdlib/iter/dedupe-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/dedupe-by/test/test.js
@@ -551,11 +551,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDedupeBy( randu(), fcn );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -580,11 +580,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDedupeBy( randu(), fcn );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -625,7 +625,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/dedupe/test/test.js b/lib/node_modules/@stdlib/iter/dedupe/test/test.js
index 0ccb4329cf1e..2166f99247c5 100644
--- a/lib/node_modules/@stdlib/iter/dedupe/test/test.js
+++ b/lib/node_modules/@stdlib/iter/dedupe/test/test.js
@@ -355,11 +355,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDedupe( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -380,11 +380,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDedupe( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -421,7 +421,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/do-until-each/test/test.js b/lib/node_modules/@stdlib/iter/do-until-each/test/test.js
index 9720e55ff21c..13dc24aefb89 100644
--- a/lib/node_modules/@stdlib/iter/do-until-each/test/test.js
+++ b/lib/node_modules/@stdlib/iter/do-until-each/test/test.js
@@ -137,9 +137,9 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	do {
 		r = it.next();
 		if ( typeof r.value !== 'undefined' ) {
-			t.strictEqual( typeof r.value, 'number', 'returns a number' );
+			t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 		}
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 		if ( r.done ) {
 			count += 1;
 		}
@@ -182,7 +182,7 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 			t.strictEqual( i, expected[ i ][ 1 ], 'provides expected value' );
 			t.strictEqual( r.value, expected[ i ][ 0 ], 'returns expected value' );
 		}
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 		i += 1;
 	} while ( r.done === false );
 	t.strictEqual( expected.length, i, 'has expected length' );
@@ -211,11 +211,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDoUntilEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -245,11 +245,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDoUntilEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -295,7 +295,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/do-while-each/test/test.js b/lib/node_modules/@stdlib/iter/do-while-each/test/test.js
index df0cdc62941a..7c0b11a923b5 100644
--- a/lib/node_modules/@stdlib/iter/do-while-each/test/test.js
+++ b/lib/node_modules/@stdlib/iter/do-while-each/test/test.js
@@ -137,9 +137,9 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	do {
 		r = it.next();
 		if ( typeof r.value !== 'undefined' ) {
-			t.strictEqual( typeof r.value, 'number', 'returns a number' );
+			t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 		}
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 		if ( r.done ) {
 			count += 1;
 		}
@@ -183,7 +183,7 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 			t.strictEqual( i, expected[ i ][ 1 ], 'provides expected value' );
 			t.strictEqual( r.value, expected[ i ][ 0 ], 'returns expected value' );
 		}
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 		i += 1;
 	} while ( r.done === false );
 	t.strictEqual( expected.length, i-1, 'has expected length' );
@@ -211,11 +211,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDoWhileEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -245,11 +245,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDoWhileEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -295,7 +295,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/empty/test/test.js b/lib/node_modules/@stdlib/iter/empty/test/test.js
index 1d4335197739..c88fb6ce8b2b 100644
--- a/lib/node_modules/@stdlib/iter/empty/test/test.js
+++ b/lib/node_modules/@stdlib/iter/empty/test/test.js
@@ -116,7 +116,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/fill/test/test.js b/lib/node_modules/@stdlib/iter/fill/test/test.js
index 1ed23a8d5fd0..cbdf7ab7a4f5 100644
--- a/lib/node_modules/@stdlib/iter/fill/test/test.js
+++ b/lib/node_modules/@stdlib/iter/fill/test/test.js
@@ -230,7 +230,7 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 		t.strictEqual( r.done, false, 'returns expected value' );
 	}
 	t.end();
@@ -581,11 +581,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFill( randu(), 3.14 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -606,11 +606,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFill( randu(), 3.14 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -647,7 +647,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -684,7 +684,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -721,7 +721,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/filter-map/test/test.js b/lib/node_modules/@stdlib/iter/filter-map/test/test.js
index 2dc346c321cd..b6b952443142 100644
--- a/lib/node_modules/@stdlib/iter/filter-map/test/test.js
+++ b/lib/node_modules/@stdlib/iter/filter-map/test/test.js
@@ -104,8 +104,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 
@@ -301,11 +301,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFilterMap( randu(), fcn );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -332,11 +332,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFilterMap( randu(), fcn );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -379,7 +379,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/filter/test/test.js b/lib/node_modules/@stdlib/iter/filter/test/test.js
index 76c94f11ad96..947e8a3fd56d 100644
--- a/lib/node_modules/@stdlib/iter/filter/test/test.js
+++ b/lib/node_modules/@stdlib/iter/filter/test/test.js
@@ -104,8 +104,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 
@@ -291,11 +291,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFilter( randu(), predicate );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -320,11 +320,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFilter( randu(), predicate );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -365,7 +365,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/flow/test/test.js b/lib/node_modules/@stdlib/iter/flow/test/test.js
index 58472eea3d4a..dc02e2230832 100644
--- a/lib/node_modules/@stdlib/iter/flow/test/test.js
+++ b/lib/node_modules/@stdlib/iter/flow/test/test.js
@@ -179,8 +179,8 @@ tape( 'the function returns a constructor which returns an iterator protocol-com
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -337,11 +337,11 @@ tape( 'the function returns a constructor which returns an iterator having a `re
 	it = new Iterator( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -368,11 +368,11 @@ tape( 'the function returns a constructor which returns an iterator having a `re
 	it = new Iterator( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -484,14 +484,14 @@ tape( 'if an environment supports `Symbol.iterator`, the function returns a cons
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it2.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/for-each/test/test.js b/lib/node_modules/@stdlib/iter/for-each/test/test.js
index 841219c18c29..a8dc81b7145f 100644
--- a/lib/node_modules/@stdlib/iter/for-each/test/test.js
+++ b/lib/node_modules/@stdlib/iter/for-each/test/test.js
@@ -106,8 +106,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	count = 0;
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( count, 100, 'returns expected value' );
 	t.end();
@@ -139,7 +139,7 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 		r = it.next();
 		t.strictEqual( i, expected[ i ][ 1 ], 'provides expected value' );
 		t.strictEqual( r.value, expected[ i ][ 0 ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, opts.iter, 'has expected length' );
 
@@ -163,11 +163,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterForEach( randu(), assert );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterForEach( randu(), assert );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -239,7 +239,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/head/test/test.js b/lib/node_modules/@stdlib/iter/head/test/test.js
index 8191ab6dc968..3f7971ee6c01 100644
--- a/lib/node_modules/@stdlib/iter/head/test/test.js
+++ b/lib/node_modules/@stdlib/iter/head/test/test.js
@@ -106,7 +106,7 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 		t.strictEqual( r.done, false, 'returns expected value' );
 	}
 	r = it.next();
@@ -203,11 +203,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterHead( randu(), 10 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -228,11 +228,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterHead( randu(), 10 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -269,7 +269,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/incrspace/test/test.js b/lib/node_modules/@stdlib/iter/incrspace/test/test.js
index ed281d0e29c9..3078263d9b43 100644
--- a/lib/node_modules/@stdlib/iter/incrspace/test/test.js
+++ b/lib/node_modules/@stdlib/iter/incrspace/test/test.js
@@ -256,11 +256,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterIncrspace( 0, 100, 2 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -281,11 +281,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterIncrspace( 0, 100, 2 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -314,7 +314,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/intersection-by-hash/test/test.js b/lib/node_modules/@stdlib/iter/intersection-by-hash/test/test.js
index 56f399ea9ac1..87a885bd9b59 100644
--- a/lib/node_modules/@stdlib/iter/intersection-by-hash/test/test.js
+++ b/lib/node_modules/@stdlib/iter/intersection-by-hash/test/test.js
@@ -686,11 +686,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterIntersectionByHash( rand1, rand2, hashFcn );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -723,11 +723,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterIntersectionByHash( rand1, rand2, hashFcn );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -774,7 +774,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/intersection/test/test.js b/lib/node_modules/@stdlib/iter/intersection/test/test.js
index 0d98071dc532..5c570353b683 100644
--- a/lib/node_modules/@stdlib/iter/intersection/test/test.js
+++ b/lib/node_modules/@stdlib/iter/intersection/test/test.js
@@ -364,11 +364,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterIntersection( rand1, rand2 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -397,11 +397,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterIntersection( rand1, rand2 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -444,7 +444,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/linspace/test/test.js b/lib/node_modules/@stdlib/iter/linspace/test/test.js
index 04283aef2b61..3405e1119ceb 100644
--- a/lib/node_modules/@stdlib/iter/linspace/test/test.js
+++ b/lib/node_modules/@stdlib/iter/linspace/test/test.js
@@ -314,11 +314,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLinspace( 0, 99, 100 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -339,11 +339,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLinspace( 0, 99, 100 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -372,7 +372,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/logspace/test/test.js b/lib/node_modules/@stdlib/iter/logspace/test/test.js
index b04cf104a13c..07011ba9fdcf 100644
--- a/lib/node_modules/@stdlib/iter/logspace/test/test.js
+++ b/lib/node_modules/@stdlib/iter/logspace/test/test.js
@@ -573,11 +573,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLogspace( 0, 3, 4 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -598,11 +598,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLogspace( 0, 3, 4 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -631,7 +631,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/map/test/test.js b/lib/node_modules/@stdlib/iter/map/test/test.js
index 97f958fb5efb..9478495046c0 100644
--- a/lib/node_modules/@stdlib/iter/map/test/test.js
+++ b/lib/node_modules/@stdlib/iter/map/test/test.js
@@ -103,8 +103,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 
@@ -132,7 +132,7 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 	for ( i = 0; i < opts.iter; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, opts.iter, 'has expected length' );
 
@@ -163,8 +163,8 @@ tape( 'the function supports specifying the callback execution context', functio
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( ctx.count, 100, 'returns expected value' );
 	t.end();
@@ -182,11 +182,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMap( randu(), scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -211,11 +211,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMap( randu(), scale );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -256,7 +256,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/mapn/test/test.js b/lib/node_modules/@stdlib/iter/mapn/test/test.js
index 7e3d0f04d235..9f22152a48c6 100644
--- a/lib/node_modules/@stdlib/iter/mapn/test/test.js
+++ b/lib/node_modules/@stdlib/iter/mapn/test/test.js
@@ -809,11 +809,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMapN( randu(), randu(), transform );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -838,11 +838,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMapN( randu(), randu(), transform );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -888,7 +888,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/pop/test/test.js b/lib/node_modules/@stdlib/iter/pop/test/test.js
index fb5b0e62901a..98013525f1fc 100644
--- a/lib/node_modules/@stdlib/iter/pop/test/test.js
+++ b/lib/node_modules/@stdlib/iter/pop/test/test.js
@@ -384,11 +384,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPop( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -409,11 +409,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPop( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -450,7 +450,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/push/test/test.js b/lib/node_modules/@stdlib/iter/push/test/test.js
index 363cba987fb5..941f2569c46a 100644
--- a/lib/node_modules/@stdlib/iter/push/test/test.js
+++ b/lib/node_modules/@stdlib/iter/push/test/test.js
@@ -316,11 +316,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPush( randu(), 1, 2, 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -341,11 +341,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPush( randu(), 1, 2, 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -382,7 +382,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/reject/test/test.js b/lib/node_modules/@stdlib/iter/reject/test/test.js
index 6365d0cee8b3..de9cab074244 100644
--- a/lib/node_modules/@stdlib/iter/reject/test/test.js
+++ b/lib/node_modules/@stdlib/iter/reject/test/test.js
@@ -104,8 +104,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 
@@ -291,11 +291,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterReject( randu(), predicate );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -320,11 +320,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterReject( randu(), predicate );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -365,7 +365,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/replicate-by/test/test.js b/lib/node_modules/@stdlib/iter/replicate-by/test/test.js
index 7d7a8c13ef8a..3e639ceb4871 100644
--- a/lib/node_modules/@stdlib/iter/replicate-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/replicate-by/test/test.js
@@ -618,11 +618,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterReplicateBy( randu(), fcn );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -647,11 +647,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterReplicateBy( randu(), fcn );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -692,7 +692,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/replicate/test/test.js b/lib/node_modules/@stdlib/iter/replicate/test/test.js
index 8e507122e6b4..b7d1ca6b5d47 100644
--- a/lib/node_modules/@stdlib/iter/replicate/test/test.js
+++ b/lib/node_modules/@stdlib/iter/replicate/test/test.js
@@ -240,11 +240,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterReplicate( randu(), 2 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -265,11 +265,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterReplicate( randu(), 2 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -306,7 +306,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/shift/test/test.js b/lib/node_modules/@stdlib/iter/shift/test/test.js
index c436fc4ba55a..9a7bc0eb2864 100644
--- a/lib/node_modules/@stdlib/iter/shift/test/test.js
+++ b/lib/node_modules/@stdlib/iter/shift/test/test.js
@@ -384,11 +384,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterShift( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -409,11 +409,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterShift( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -450,7 +450,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/slice/test/test.js b/lib/node_modules/@stdlib/iter/slice/test/test.js
index 7ffdadde541b..f543697de61e 100644
--- a/lib/node_modules/@stdlib/iter/slice/test/test.js
+++ b/lib/node_modules/@stdlib/iter/slice/test/test.js
@@ -221,7 +221,7 @@ tape( 'the function returns an iterator protocol-compliant object (infinite iter
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 		t.strictEqual( r.done, false, 'returns expected value' );
 	}
 	r = it.next();
@@ -506,11 +506,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSlice( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -531,11 +531,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSlice( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -572,7 +572,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -609,7 +609,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -646,7 +646,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/step/test/test.js b/lib/node_modules/@stdlib/iter/step/test/test.js
index fb197f310e24..2d8c2c4385db 100644
--- a/lib/node_modules/@stdlib/iter/step/test/test.js
+++ b/lib/node_modules/@stdlib/iter/step/test/test.js
@@ -254,11 +254,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterStep( 0, 2, 10 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -279,11 +279,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterStep( 0, 2, 10 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -312,7 +312,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/strided-by/test/test.js b/lib/node_modules/@stdlib/iter/strided-by/test/test.js
index 6adc207d5a6e..e646e0e96699 100644
--- a/lib/node_modules/@stdlib/iter/strided-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/strided-by/test/test.js
@@ -396,8 +396,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 
@@ -439,7 +439,7 @@ tape( 'the function returns an iterator protocol-compliant object which steps ac
 	for ( i = 0; i < expected.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ].value, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -485,7 +485,7 @@ tape( 'the function supports specifying an offset', function test( t ) {
 	for ( i = 0; i < expected.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ].value, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -552,7 +552,7 @@ tape( 'the function supports specifying whether to eagerly advance the input ite
 	for ( i = 0; i < expected.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ].value, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -738,11 +738,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterStridedBy( randu(), stride );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -767,11 +767,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterStridedBy( randu(), stride );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -810,7 +810,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -849,7 +849,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -888,7 +888,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -927,7 +927,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/strided/test/test.js b/lib/node_modules/@stdlib/iter/strided/test/test.js
index d43ebf0f68a3..dee40a9f1bbe 100644
--- a/lib/node_modules/@stdlib/iter/strided/test/test.js
+++ b/lib/node_modules/@stdlib/iter/strided/test/test.js
@@ -313,8 +313,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -352,7 +352,7 @@ tape( 'the function returns an iterator protocol-compliant object which steps by
 	for ( i = 0; i < expected.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ].value, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -394,7 +394,7 @@ tape( 'the function supports specifying an offset', function test( t ) {
 	for ( i = 0; i < expected.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ].value, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -453,7 +453,7 @@ tape( 'the function supports specifying whether to eagerly advance the input ite
 	for ( i = 0; i < expected.length; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ].value, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -486,11 +486,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterStrided( randu(), 10 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -511,11 +511,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterStrided( randu(), 10 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -550,7 +550,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -585,7 +585,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -620,7 +620,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -655,7 +655,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/union/test/test.js b/lib/node_modules/@stdlib/iter/union/test/test.js
index 403bd1986e7d..bca68d7ba18a 100644
--- a/lib/node_modules/@stdlib/iter/union/test/test.js
+++ b/lib/node_modules/@stdlib/iter/union/test/test.js
@@ -366,11 +366,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUnion( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -391,11 +391,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUnion( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -432,7 +432,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/unique-by-hash/test/test.js b/lib/node_modules/@stdlib/iter/unique-by-hash/test/test.js
index 7aeaf6094507..faefa2aae2fc 100644
--- a/lib/node_modules/@stdlib/iter/unique-by-hash/test/test.js
+++ b/lib/node_modules/@stdlib/iter/unique-by-hash/test/test.js
@@ -367,11 +367,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUniqueByHash( randu(), hashFcn );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -396,11 +396,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUniqueByHash( randu(), hashFcn );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -441,7 +441,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/unique-by/test/test.js b/lib/node_modules/@stdlib/iter/unique-by/test/test.js
index 311d526aa363..f16f388066f1 100644
--- a/lib/node_modules/@stdlib/iter/unique-by/test/test.js
+++ b/lib/node_modules/@stdlib/iter/unique-by/test/test.js
@@ -367,11 +367,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUniqueBy( randu(), predicate );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -396,11 +396,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUniqueBy( randu(), predicate );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -441,7 +441,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/unique/test/test.js b/lib/node_modules/@stdlib/iter/unique/test/test.js
index 7b12f3714adb..3ab647258c9f 100644
--- a/lib/node_modules/@stdlib/iter/unique/test/test.js
+++ b/lib/node_modules/@stdlib/iter/unique/test/test.js
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUnique( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -219,11 +219,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUnique( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -260,7 +260,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/unitspace/test/test.js b/lib/node_modules/@stdlib/iter/unitspace/test/test.js
index 68f6a50366a7..f2e11d999eab 100644
--- a/lib/node_modules/@stdlib/iter/unitspace/test/test.js
+++ b/lib/node_modules/@stdlib/iter/unitspace/test/test.js
@@ -178,11 +178,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUnitspace( 0, 99 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -203,11 +203,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUnitspace( 0, 99 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -236,7 +236,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/unshift/test/test.js b/lib/node_modules/@stdlib/iter/unshift/test/test.js
index 382039622fbd..a29c625f5292 100644
--- a/lib/node_modules/@stdlib/iter/unshift/test/test.js
+++ b/lib/node_modules/@stdlib/iter/unshift/test/test.js
@@ -316,11 +316,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUnshift( randu(), 1, 2, 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -341,11 +341,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUnshift( randu(), 1, 2, 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -382,7 +382,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/until-each/test/test.js b/lib/node_modules/@stdlib/iter/until-each/test/test.js
index cc5e25283fa8..285b19755e3b 100644
--- a/lib/node_modules/@stdlib/iter/until-each/test/test.js
+++ b/lib/node_modules/@stdlib/iter/until-each/test/test.js
@@ -137,9 +137,9 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	do {
 		r = it.next();
 		if ( typeof r.value !== 'undefined' ) {
-			t.strictEqual( typeof r.value, 'number', 'returns a number' );
+			t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 		}
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 		if ( r.done ) {
 			count += 1;
 		}
@@ -182,7 +182,7 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 			t.strictEqual( i, expected[ i ][ 1 ], 'provides expected value' );
 			t.strictEqual( r.value, expected[ i ][ 0 ], 'returns expected value' );
 		}
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 		i += 1;
 	} while ( r.done === false );
 	t.strictEqual( expected.length, i - 1, 'has expected length' );
@@ -211,11 +211,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterUntilEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -245,11 +245,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterUntilEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -295,7 +295,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/iter/while-each/test/test.js b/lib/node_modules/@stdlib/iter/while-each/test/test.js
index e4959593c0f5..b2caa49b066c 100644
--- a/lib/node_modules/@stdlib/iter/while-each/test/test.js
+++ b/lib/node_modules/@stdlib/iter/while-each/test/test.js
@@ -137,9 +137,9 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	do {
 		r = it.next();
 		if ( typeof r.value !== 'undefined' ) {
-			t.strictEqual( typeof r.value, 'number', 'returns a number' );
+			t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 		}
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 		if ( r.done ) {
 			count += 1;
 		}
@@ -182,7 +182,7 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 			t.strictEqual( i, expected[ i ][ 1 ], 'provides expected value' );
 			t.strictEqual( r.value, expected[ i ][ 0 ], 'returns expected value' );
 		}
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 		i += 1;
 	} while ( r.done === false );
 	t.strictEqual( expected.length, i - 1, 'has expected length' );
@@ -211,11 +211,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterWhileEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -245,11 +245,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterWhileEach( array2iterator( [ 1, 2, 3, 4 ] ), predicate, assert );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -295,7 +295,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/base/special/fast/alpha-max-plus-beta-min/test/test.factory.js b/lib/node_modules/@stdlib/math/base/special/fast/alpha-max-plus-beta-min/test/test.factory.js
index e912274989a6..9fce2b6c14d8 100644
--- a/lib/node_modules/@stdlib/math/base/special/fast/alpha-max-plus-beta-min/test/test.factory.js
+++ b/lib/node_modules/@stdlib/math/base/special/fast/alpha-max-plus-beta-min/test/test.factory.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var approx = factory( 1.0, 0.5 );
-	t.strictEqual( typeof approx, 'function', 'returns a function' );
+	t.strictEqual( typeof approx, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/tools/evalrational/test/test.factory.js b/lib/node_modules/@stdlib/math/base/tools/evalrational/test/test.factory.js
index 6a45694a28c0..b790e1d690f1 100644
--- a/lib/node_modules/@stdlib/math/base/tools/evalrational/test/test.factory.js
+++ b/lib/node_modules/@stdlib/math/base/tools/evalrational/test/test.factory.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var f = factory( [ 1.0, 2.0, 3.0 ], [ 1.0, 2.0, 3.0 ] );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/tools/evalrationalf/test/test.factory.js b/lib/node_modules/@stdlib/math/base/tools/evalrationalf/test/test.factory.js
index b24922471eba..69dcca68544a 100644
--- a/lib/node_modules/@stdlib/math/base/tools/evalrationalf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/math/base/tools/evalrationalf/test/test.factory.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var f = factory( new Float32Array( [ 1.0, 2.0, 3.0 ] ), new Float32Array( [ 1.0, 2.0, 3.0 ] ) );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/tools/fibpoly/test/test.factory.js b/lib/node_modules/@stdlib/math/base/tools/fibpoly/test/test.factory.js
index bca0a7fec0e7..49ffe7ec8456 100644
--- a/lib/node_modules/@stdlib/math/base/tools/fibpoly/test/test.factory.js
+++ b/lib/node_modules/@stdlib/math/base/tools/fibpoly/test/test.factory.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function for evaluating a Fibonacci polynomial', function test( t ) {
 	var polyval = factory( 5 );
-	t.strictEqual( typeof polyval, 'function', 'returns a function' );
+	t.strictEqual( typeof polyval, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.factory.js b/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.factory.js
index 7d66f162ddba..13fdd0a5c7db 100644
--- a/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.factory.js
+++ b/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.factory.js
@@ -61,7 +61,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( 2 ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( 2 ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/tools/lucaspoly/test/test.factory.js b/lib/node_modules/@stdlib/math/base/tools/lucaspoly/test/test.factory.js
index 4ab41ba3cfe1..5215cd810145 100644
--- a/lib/node_modules/@stdlib/math/base/tools/lucaspoly/test/test.factory.js
+++ b/lib/node_modules/@stdlib/math/base/tools/lucaspoly/test/test.factory.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function for evaluating a Lucas polynomial', function test( t ) {
 	var polyval = factory( 5 );
-	t.strictEqual( typeof polyval, 'function', 'returns a function' );
+	t.strictEqual( typeof polyval, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/tools/normhermitepoly/test/test.factory.js b/lib/node_modules/@stdlib/math/base/tools/normhermitepoly/test/test.factory.js
index 4455a6db8cc2..ffffaa570311 100644
--- a/lib/node_modules/@stdlib/math/base/tools/normhermitepoly/test/test.factory.js
+++ b/lib/node_modules/@stdlib/math/base/tools/normhermitepoly/test/test.factory.js
@@ -61,7 +61,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( 2 ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( 2 ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/test/test.factory.js b/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/test/test.factory.js
index 683893ef890e..6502ef5c77d9 100644
--- a/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/test/test.factory.js
@@ -62,7 +62,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.strictEqual( typeof factory( 2 ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( 2 ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/iter/ops/add/test/test.js b/lib/node_modules/@stdlib/math/iter/ops/add/test/test.js
index 853f218e7822..aab0844c6f81 100644
--- a/lib/node_modules/@stdlib/math/iter/ops/add/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/ops/add/test/test.js
@@ -755,11 +755,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAdd( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -780,11 +780,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAdd( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -826,7 +826,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -855,7 +855,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/ops/divide/test/test.js b/lib/node_modules/@stdlib/math/iter/ops/divide/test/test.js
index 5e8c9fc1a73d..7544e788adff 100644
--- a/lib/node_modules/@stdlib/math/iter/ops/divide/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/ops/divide/test/test.js
@@ -825,11 +825,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDivide( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -850,11 +850,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDivide( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -896,7 +896,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -925,7 +925,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/ops/mod/test/test.js b/lib/node_modules/@stdlib/math/iter/ops/mod/test/test.js
index 4a0934ef124d..363771451775 100644
--- a/lib/node_modules/@stdlib/math/iter/ops/mod/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/ops/mod/test/test.js
@@ -825,11 +825,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMod( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -850,11 +850,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMod( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -896,7 +896,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -925,7 +925,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/ops/multiply/test/test.js b/lib/node_modules/@stdlib/math/iter/ops/multiply/test/test.js
index 80cc9866525c..775ccf2d673c 100644
--- a/lib/node_modules/@stdlib/math/iter/ops/multiply/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/ops/multiply/test/test.js
@@ -755,11 +755,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMultiply( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -780,11 +780,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMultiply( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -826,7 +826,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -855,7 +855,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/ops/subtract/test/test.js b/lib/node_modules/@stdlib/math/iter/ops/subtract/test/test.js
index cdd3efd9d88d..b87de9d85703 100644
--- a/lib/node_modules/@stdlib/math/iter/ops/subtract/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/ops/subtract/test/test.js
@@ -825,11 +825,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSubtract( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -850,11 +850,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSubtract( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -896,7 +896,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -925,7 +925,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/composites/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/composites/test/test.js
index fae487de1b9a..6f23530d13f1 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/composites/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/composites/test/test.js
@@ -167,11 +167,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCompositesSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -192,11 +192,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCompositesSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -225,7 +225,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/composites/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/composites/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/composites/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/composites/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/continued-fraction/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/continued-fraction/test/test.js
index 4340d5b61e56..89b1b19f8d64 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/continued-fraction/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/continued-fraction/test/test.js
@@ -1413,11 +1413,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterContinuedFractionSeq( PI );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -1438,11 +1438,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterContinuedFractionSeq( PI );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -1471,7 +1471,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/continued-fraction/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/continued-fraction/test/test.validate.js
index 11c00b4bdf2f..f026ea8a845b 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/continued-fraction/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/continued-fraction/test/test.validate.js
@@ -159,7 +159,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -177,7 +177,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/cubes/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/cubes/test/test.js
index 16f4e44fca3c..d1da4b1c8390 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/cubes/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/cubes/test/test.js
@@ -170,11 +170,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCubesSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -195,11 +195,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCubesSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -228,7 +228,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/cubes/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/cubes/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/cubes/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/cubes/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.js
index 1ede6e8fecec..b5d07e3f2c99 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.js
@@ -181,11 +181,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterEvenIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -206,11 +206,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterEvenIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -239,7 +239,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/factorials/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/factorials/test/test.js
index 35dfa6f2a362..700bcab5bf9a 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/factorials/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/factorials/test/test.js
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFactorialsSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFactorialsSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -227,7 +227,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/factorials/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/factorials/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/factorials/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/factorials/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/fibonacci/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/fibonacci/test/test.js
index 8df7da99e449..2eeceef666b3 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/fibonacci/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/fibonacci/test/test.js
@@ -168,11 +168,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFibonacciSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFibonacciSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -226,7 +226,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/fibonacci/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/fibonacci/test/test.validate.js
index 22c649816b81..dc694fded1be 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/fibonacci/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/fibonacci/test/test.validate.js
@@ -122,7 +122,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -140,7 +140,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/fifth-powers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/fifth-powers/test/test.js
index c396c3770a25..fdd6ea94159b 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/fifth-powers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/fifth-powers/test/test.js
@@ -168,11 +168,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFifthPowersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFifthPowersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -226,7 +226,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/fifth-powers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/fifth-powers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/fifth-powers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/fifth-powers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/fourth-powers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/fourth-powers/test/test.js
index d5c01c16fbdd..3f6d219aff01 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/fourth-powers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/fourth-powers/test/test.js
@@ -168,11 +168,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFourthPowersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFourthPowersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -226,7 +226,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/fourth-powers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/fourth-powers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/fourth-powers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/fourth-powers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.js
index 80704872f16b..00bc82bd7f7a 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.js
@@ -180,11 +180,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -205,11 +205,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -238,7 +238,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/lucas/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/lucas/test/test.js
index 8531829c1677..3fb5b350e351 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/lucas/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/lucas/test/test.js
@@ -168,11 +168,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLucasSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLucasSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -226,7 +226,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/lucas/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/lucas/test/test.validate.js
index 2590abbd2dc6..61e90ec11973 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/lucas/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/lucas/test/test.validate.js
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -142,7 +142,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negafibonacci/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/negafibonacci/test/test.js
index 3dbad38c1864..853e54024935 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negafibonacci/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negafibonacci/test/test.js
@@ -168,11 +168,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNegaFibonacciSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNegaFibonacciSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -226,7 +226,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negafibonacci/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/negafibonacci/test/test.validate.js
index b635a9afc8af..57834a5a728a 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negafibonacci/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negafibonacci/test/test.validate.js
@@ -122,7 +122,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -140,7 +140,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negalucas/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/negalucas/test/test.js
index 2cab5db12ca2..4167ce9011c7 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negalucas/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negalucas/test/test.js
@@ -168,11 +168,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNegaLucasSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNegaLucasSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -226,7 +226,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negalucas/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/negalucas/test/test.validate.js
index 2590abbd2dc6..61e90ec11973 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negalucas/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negalucas/test/test.validate.js
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -142,7 +142,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negative-even-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/negative-even-integers/test/test.js
index c30b303f7006..ae2bfcae8ee4 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negative-even-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negative-even-integers/test/test.js
@@ -168,11 +168,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNegativeEvenIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNegativeEvenIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -226,7 +226,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negative-even-integers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/negative-even-integers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negative-even-integers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negative-even-integers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negative-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/negative-integers/test/test.js
index 4f8521bf0f70..f59a1fd64687 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negative-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negative-integers/test/test.js
@@ -166,11 +166,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNegativeIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -191,11 +191,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNegativeIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -224,7 +224,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negative-integers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/negative-integers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negative-integers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negative-integers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negative-odd-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/negative-odd-integers/test/test.js
index 5acaf1247abb..e670c555f021 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negative-odd-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negative-odd-integers/test/test.js
@@ -168,11 +168,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNegativeOddIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNegativeOddIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -226,7 +226,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/negative-odd-integers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/negative-odd-integers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/negative-odd-integers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/negative-odd-integers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonfibonacci/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/nonfibonacci/test/test.js
index 717e98f8833c..6957059ba253 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonfibonacci/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonfibonacci/test/test.js
@@ -165,11 +165,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNonFibonacciSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -190,11 +190,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNonFibonacciSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -223,7 +223,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonfibonacci/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/nonfibonacci/test/test.validate.js
index 09025e261b16..e93ebbafc22a 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonfibonacci/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonfibonacci/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-even-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-even-integers/test/test.js
index 927d8ba64a44..77ffa3ddcfd9 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-even-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-even-integers/test/test.js
@@ -168,11 +168,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNonNegativeEvenIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNonNegativeEvenIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -226,7 +226,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-even-integers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-even-integers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-even-integers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-even-integers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-integers/test/test.js
index e564e660e063..9ead4f200911 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-integers/test/test.js
@@ -166,11 +166,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNonNegativeIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -191,11 +191,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNonNegativeIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -224,7 +224,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-integers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-integers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-integers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonnegative-integers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-even-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-even-integers/test/test.js
index 7cc47f267764..4b2d968bcd84 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-even-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-even-integers/test/test.js
@@ -168,11 +168,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNonPositiveEvenIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNonPositiveEvenIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -226,7 +226,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-even-integers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-even-integers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-even-integers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-even-integers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-integers/test/test.js
index b4ba782706e8..cdf76a899652 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-integers/test/test.js
@@ -166,11 +166,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNonPositiveIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -191,11 +191,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNonPositiveIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -224,7 +224,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-integers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-integers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-integers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonpositive-integers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonsquares/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/nonsquares/test/test.js
index c717eb08bf32..a1c53e202fc5 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonsquares/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonsquares/test/test.js
@@ -172,11 +172,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterNonSquaresSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -197,11 +197,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterNonSquaresSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -230,7 +230,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/nonsquares/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/nonsquares/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/nonsquares/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/nonsquares/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.js
index 4e9bd633917c..876f62cdea9d 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.js
@@ -180,11 +180,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterOddIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -205,11 +205,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterOddIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -238,7 +238,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/positive-even-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/positive-even-integers/test/test.js
index 8f2cb6d10b8e..a4b66e81b2ff 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/positive-even-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/positive-even-integers/test/test.js
@@ -168,11 +168,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPositiveEvenIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPositiveEvenIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -226,7 +226,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/positive-even-integers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/positive-even-integers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/positive-even-integers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/positive-even-integers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/positive-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/positive-integers/test/test.js
index 86ada2b35d86..66b7aa0ffd66 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/positive-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/positive-integers/test/test.js
@@ -166,11 +166,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPositiveIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -191,11 +191,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPositiveIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -224,7 +224,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/positive-integers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/positive-integers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/positive-integers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/positive-integers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/positive-odd-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/positive-odd-integers/test/test.js
index 2340b3a40bf1..ef1eb3acdca6 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/positive-odd-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/positive-odd-integers/test/test.js
@@ -168,11 +168,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPositiveOddIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPositiveOddIntegersSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -226,7 +226,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/positive-odd-integers/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/positive-odd-integers/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/positive-odd-integers/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/positive-odd-integers/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/primes/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/primes/test/test.js
index abb6fb600723..14decc9993f8 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/primes/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/primes/test/test.js
@@ -167,11 +167,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPrimesSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -192,11 +192,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPrimesSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -225,7 +225,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/primes/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/primes/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/primes/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/primes/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/squared-triangular/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/squared-triangular/test/test.js
index 34ff52f4762a..d9cdc67ddd1d 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/squared-triangular/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/squared-triangular/test/test.js
@@ -174,11 +174,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSquaredTriangularSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -199,11 +199,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSquaredTriangularSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -232,7 +232,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/squared-triangular/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/squared-triangular/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/squared-triangular/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/squared-triangular/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/squares/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/squares/test/test.js
index 0614f03a0935..ad4d0730a57b 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/squares/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/squares/test/test.js
@@ -170,11 +170,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSquaresSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -195,11 +195,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSquaresSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -228,7 +228,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/squares/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/squares/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/squares/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/squares/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/triangular/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/triangular/test/test.js
index 0b843bd127ff..01ea5d138202 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/triangular/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/triangular/test/test.js
@@ -168,11 +168,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTriangularSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -193,11 +193,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTriangularSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -226,7 +226,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/triangular/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/triangular/test/test.validate.js
index 1eed9b44ee96..b15b9e62ecda 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/triangular/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/triangular/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/test/test.js
index bf1280390aa6..74fb23df9154 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/test/test.js
@@ -172,11 +172,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTribonacciSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -197,11 +197,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTribonacciSeq();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -230,7 +230,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/test/test.validate.js
index 0f8d0c3a139b..35f9e09bb6bd 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/test/test.validate.js
@@ -122,7 +122,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -140,7 +140,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/tools/map/test/test.js b/lib/node_modules/@stdlib/math/iter/tools/map/test/test.js
index de91d0ebc27c..2b392a572017 100644
--- a/lib/node_modules/@stdlib/math/iter/tools/map/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/tools/map/test/test.js
@@ -132,8 +132,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which invokes
 	for ( i = 0; i < opts.iter; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, opts.iter, 'has expected length' );
 
@@ -189,7 +189,7 @@ tape( 'the function supports specifying a return value for when an input iterato
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, null, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 
@@ -209,11 +209,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMap( randu(), sin );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -234,11 +234,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMap( randu(), sin );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -275,7 +275,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/tools/map/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/tools/map/test/test.validate.js
index 5ad496a2c33d..dfa8d1ea8bdb 100644
--- a/lib/node_modules/@stdlib/math/iter/tools/map/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/tools/map/test/test.validate.js
@@ -96,7 +96,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/tools/map2/test/test.js b/lib/node_modules/@stdlib/math/iter/tools/map2/test/test.js
index bc310d236d6a..1ea48bbe8f7f 100644
--- a/lib/node_modules/@stdlib/math/iter/tools/map2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/tools/map2/test/test.js
@@ -502,7 +502,7 @@ tape( 'the function supports specifying a return value for when an input iterato
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, null, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 
@@ -522,11 +522,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMap2( randu(), randu(), copysign );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -547,11 +547,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMap2( randu(), randu(), copysign );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -593,7 +593,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -622,7 +622,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/tools/map2/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/tools/map2/test/test.validate.js
index 5ad496a2c33d..dfa8d1ea8bdb 100644
--- a/lib/node_modules/@stdlib/math/iter/tools/map2/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/tools/map2/test/test.validate.js
@@ -96,7 +96,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/tools/map3/test/test.js b/lib/node_modules/@stdlib/math/iter/tools/map3/test/test.js
index 81309c11ee5a..734e1cb6af4c 100644
--- a/lib/node_modules/@stdlib/math/iter/tools/map3/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/tools/map3/test/test.js
@@ -557,7 +557,7 @@ tape( 'the function supports specifying a return value for when an input iterato
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, null, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 
@@ -577,11 +577,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterMap3( randu(), randu(), randu(), clamp );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -602,11 +602,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterMap3( randu(), randu(), randu(), clamp );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -652,7 +652,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -681,7 +681,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterators a
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/math/iter/tools/map3/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/tools/map3/test/test.validate.js
index 5ad496a2c33d..dfa8d1ea8bdb 100644
--- a/lib/node_modules/@stdlib/math/iter/tools/map3/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/tools/map3/test/test.validate.js
@@ -96,7 +96,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/utils/continued-fraction/test/test.validate.js b/lib/node_modules/@stdlib/math/iter/utils/continued-fraction/test/test.validate.js
index 0ddf44b5a168..0da5d5339a93 100644
--- a/lib/node_modules/@stdlib/math/iter/utils/continued-fraction/test/test.validate.js
+++ b/lib/node_modules/@stdlib/math/iter/utils/continued-fraction/test/test.validate.js
@@ -129,7 +129,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -147,7 +147,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/tools/unary/test/test.validate_table.js b/lib/node_modules/@stdlib/math/tools/unary/test/test.validate_table.js
index abb8a8c3b033..f3237177fc4a 100644
--- a/lib/node_modules/@stdlib/math/tools/unary/test/test.validate_table.js
+++ b/lib/node_modules/@stdlib/math/tools/unary/test/test.validate_table.js
@@ -196,7 +196,7 @@ tape( 'the function returns `null` if provided a valid table object', function t
 	};
 
 	err = validate( out, table );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( out, table, 'sets fields' );
 
 	out = output();
@@ -208,7 +208,7 @@ tape( 'the function returns `null` if provided a valid table object', function t
 	};
 
 	err = validate( out, table );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( out, table, 'sets fields' );
 
 	t.end();
@@ -230,7 +230,7 @@ tape( 'the function will ignore unrecognized table fields', function test( t ) {
 	};
 
 	err = validate( out, table );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( out, output(), 'ignores unrecognized fields' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/ml/incr/binary-classification/test/test.validate.js b/lib/node_modules/@stdlib/ml/incr/binary-classification/test/test.validate.js
index 2b165d2a25e7..f5c3487ab8c2 100644
--- a/lib/node_modules/@stdlib/ml/incr/binary-classification/test/test.validate.js
+++ b/lib/node_modules/@stdlib/ml/incr/binary-classification/test/test.validate.js
@@ -275,7 +275,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	err = validate( opts1, opts2 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts1, opts2, 'sets option values' );
 
 	t.end();
@@ -293,7 +293,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 	err = validate( opts1, opts2 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts1, options(), 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ml/incr/kmeans/test/test.js b/lib/node_modules/@stdlib/ml/incr/kmeans/test/test.js
index 3540a25940e8..b763526bef91 100644
--- a/lib/node_modules/@stdlib/ml/incr/kmeans/test/test.js
+++ b/lib/node_modules/@stdlib/ml/incr/kmeans/test/test.js
@@ -333,13 +333,13 @@ tape( 'the function throws an error if provided centroid initialization data buf
 
 tape( 'the function returns a function', function test( t ) {
 	var acc = incrkmeans( 2, 2 );
-	t.strictEqual( typeof acc, 'function', 'returns a function' );
+	t.strictEqual( typeof acc, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a function (options)', function test( t ) {
 	var acc = incrkmeans( 2, 2, {} );
-	t.strictEqual( typeof acc, 'function', 'returns a function' );
+	t.strictEqual( typeof acc, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -356,7 +356,7 @@ tape( 'the function returns a function (centroids)', function test( t ) {
 	centroids = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
 	acc = incrkmeans( centroids );
-	t.strictEqual( typeof acc, 'function', 'returns a function' );
+	t.strictEqual( typeof acc, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -373,7 +373,7 @@ tape( 'the function returns a function (centroids, options)', function test( t )
 	centroids = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
 	acc = incrkmeans( centroids, {} );
-	t.strictEqual( typeof acc, 'function', 'returns a function' );
+	t.strictEqual( typeof acc, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -467,7 +467,7 @@ tape( 'the function returns a function which throws if not provided a vector hav
 
 tape( 'attached to the returned function is a `predict` method for predicting data point cluster assignment', function test( t ) {
 	var acc = incrkmeans( 2, 2 );
-	t.strictEqual( typeof acc.predict, 'function', 'returns a function' );
+	t.strictEqual( typeof acc.predict, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/ml/incr/kmeans/test/test.validate.js b/lib/node_modules/@stdlib/ml/incr/kmeans/test/test.validate.js
index 4c965c098f63..98d085dd57b5 100644
--- a/lib/node_modules/@stdlib/ml/incr/kmeans/test/test.validate.js
+++ b/lib/node_modules/@stdlib/ml/incr/kmeans/test/test.validate.js
@@ -324,7 +324,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -342,7 +342,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.eta_factory.js b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.eta_factory.js
index 4467aec3af0b..d7ab2a01bbc0 100644
--- a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.eta_factory.js
+++ b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.eta_factory.js
@@ -43,7 +43,7 @@ tape( 'the function throws an error if supplied an unknown `learningRate`', func
 
 tape( 'the function returns a function', function test( t ) {
 	var getEta = factory( 'basic', 0.02, 0.0 );
-	t.strictEqual( typeof getEta, 'function', 'returns a function' );
+	t.strictEqual( typeof getEta, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.main.js b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.main.js
index d6131ff494ea..b5d053a52fba 100644
--- a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.main.js
+++ b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.main.js
@@ -77,7 +77,7 @@ tape( 'the `loss` option of the function specifies the used loss function', func
 		accumulator = incrSGDRegression({
 			'loss': values[ i ]
 		});
-		t.strictEqual( isFunction( accumulator ), true, 'returns a function' );
+		t.strictEqual( isFunction( accumulator ), true, 'returns expected value' );
 	}
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.validate.js b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.validate.js
index 3be5b28955c4..33b0a798209b 100644
--- a/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.validate.js
+++ b/lib/node_modules/@stdlib/ml/incr/sgd-regression/test/test.validate.js
@@ -221,7 +221,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -239,7 +239,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/ctor/test/test.validate.js b/lib/node_modules/@stdlib/ndarray/ctor/test/test.validate.js
index 3954beb1d574..4f775a342187 100644
--- a/lib/node_modules/@stdlib/ndarray/ctor/test/test.validate.js
+++ b/lib/node_modules/@stdlib/ndarray/ctor/test/test.validate.js
@@ -178,7 +178,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -196,7 +196,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/ndarray/ind2sub/test/test.validate.js b/lib/node_modules/@stdlib/ndarray/ind2sub/test/test.validate.js
index 9659809b4031..a7313a15cdd5 100644
--- a/lib/node_modules/@stdlib/ndarray/ind2sub/test/test.validate.js
+++ b/lib/node_modules/@stdlib/ndarray/ind2sub/test/test.validate.js
@@ -135,7 +135,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -153,7 +153,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/ndarray/iter/column-entries/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/column-entries/test/test.js
index ed4dca58f561..8b27f3b811eb 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/column-entries/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/column-entries/test/test.js
@@ -601,7 +601,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/iter/columns/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/columns/test/test.js
index 07e748ccaf1f..802cba5cd910 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/columns/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/columns/test/test.js
@@ -583,7 +583,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/iter/entries/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/entries/test/test.js
index 4cd25c9ca97b..ff3a86378755 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/entries/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/entries/test/test.js
@@ -1109,7 +1109,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/iter/indices/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/indices/test/test.js
index 14874deb95ce..5fa0e1babf20 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/indices/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/indices/test/test.js
@@ -756,7 +756,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/iter/interleave-subarrays/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/interleave-subarrays/test/test.js
index bd639971d4b2..4a5bcafab521 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/interleave-subarrays/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/interleave-subarrays/test/test.js
@@ -474,7 +474,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/iter/matrices/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/matrices/test/test.js
index 5f8d0ba2231b..25612919368d 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/matrices/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/matrices/test/test.js
@@ -500,7 +500,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/iter/matrix-entries/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/matrix-entries/test/test.js
index 01d069cbcebd..4db3380cc340 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/matrix-entries/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/matrix-entries/test/test.js
@@ -516,7 +516,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/iter/row-entries/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/row-entries/test/test.js
index 7c7f0b0f7891..12b99da6e6c3 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/row-entries/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/row-entries/test/test.js
@@ -605,7 +605,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/iter/rows/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/rows/test/test.js
index 1ca0b9d0fb95..bf24af4aeb72 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/rows/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/rows/test/test.js
@@ -587,7 +587,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/iter/select-dimension/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/select-dimension/test/test.js
index 586cf13b81c8..6f68d83de583 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/select-dimension/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/select-dimension/test/test.js
@@ -1068,7 +1068,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/iter/stacks/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/stacks/test/test.js
index 74df514bf9e4..3867131aed3b 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/stacks/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/stacks/test/test.js
@@ -1054,7 +1054,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/iter/subarrays/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/subarrays/test/test.js
index d35be81119d6..71376f5890ad 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/subarrays/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/subarrays/test/test.js
@@ -560,7 +560,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/iter/to-array-each/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/to-array-each/test/test.js
index 63f382d4a3f5..247767d88382 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/to-array-each/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/to-array-each/test/test.js
@@ -321,7 +321,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/iter/values/test/test.js b/lib/node_modules/@stdlib/ndarray/iter/values/test/test.js
index 300bc99a3223..16cb73edce0b 100644
--- a/lib/node_modules/@stdlib/ndarray/iter/values/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/iter/values/test/test.js
@@ -1088,7 +1088,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/mostly-safe-casts/test/test.js b/lib/node_modules/@stdlib/ndarray/mostly-safe-casts/test/test.js
index 8b29d71df5fb..d6aa117ea4e5 100644
--- a/lib/node_modules/@stdlib/ndarray/mostly-safe-casts/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/mostly-safe-casts/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if not provided a data type, the function returns a table', function test( t ) {
 	var out = mostlySafeCasts();
-	t.strictEqual( typeof out, 'object', 'returns an object' );
+	t.strictEqual( typeof out, 'object', 'returns expected value' );
 	t.strictEqual( out[ 'float32' ][ 'float64' ], 1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/next-dtype/test/test.js b/lib/node_modules/@stdlib/ndarray/next-dtype/test/test.js
index 63b31345b621..f7dd78cdac35 100644
--- a/lib/node_modules/@stdlib/ndarray/next-dtype/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/next-dtype/test/test.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if not provided a data type, the function returns a table', function test( t ) {
 	var out = nextDataType();
-	t.strictEqual( typeof out, 'object', 'returns an object' );
+	t.strictEqual( typeof out, 'object', 'returns expected value' );
 	t.strictEqual( out[ 'float32' ], 'float64', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/promotion-rules/test/test.js b/lib/node_modules/@stdlib/ndarray/promotion-rules/test/test.js
index 7982e535374f..1775b930dadc 100644
--- a/lib/node_modules/@stdlib/ndarray/promotion-rules/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/promotion-rules/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if not provided data types, the function returns a table', function test( t ) {
 	var out = promotionRules();
-	t.strictEqual( isObject( out ), true, 'returns an object' );
+	t.strictEqual( isObject( out ), true, 'returns expected value' );
 	t.strictEqual( out[ 'float32' ][ 'uint32' ], 'float64', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/safe-casts/test/test.js b/lib/node_modules/@stdlib/ndarray/safe-casts/test/test.js
index 4d2236866c95..0882be434312 100644
--- a/lib/node_modules/@stdlib/ndarray/safe-casts/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/safe-casts/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if not provided a data type, the function returns a table', function test( t ) {
 	var out = safeCasts();
-	t.strictEqual( typeof out, 'object', 'returns an object' );
+	t.strictEqual( typeof out, 'object', 'returns expected value' );
 	t.strictEqual( out[ 'float32' ][ 'float64' ], 1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/same-kind-casts/test/test.js b/lib/node_modules/@stdlib/ndarray/same-kind-casts/test/test.js
index 0cb36bd41da0..e8adc8575d37 100644
--- a/lib/node_modules/@stdlib/ndarray/same-kind-casts/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/same-kind-casts/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if not provided a data type, the function returns a table', function test( t ) {
 	var out = sameKindCasts();
-	t.strictEqual( typeof out, 'object', 'returns an object' );
+	t.strictEqual( typeof out, 'object', 'returns expected value' );
 	t.strictEqual( out[ 'float32' ][ 'float64' ], 1, 'returns expected value' );
 	t.strictEqual( out[ 'float32' ][ 'int8' ], 0, 'returns expected value' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/ndarray/sub2ind/test/test.validate.js b/lib/node_modules/@stdlib/ndarray/sub2ind/test/test.validate.js
index a501cdf260b0..d828bb2ed834 100644
--- a/lib/node_modules/@stdlib/ndarray/sub2ind/test/test.validate.js
+++ b/lib/node_modules/@stdlib/ndarray/sub2ind/test/test.validate.js
@@ -143,7 +143,7 @@ tape( 'the function returns `null` if all options are valid (mode string)', func
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'sets options' );
 
 	t.end();
@@ -161,7 +161,7 @@ tape( 'the function returns `null` if all options are valid (mode array)', funct
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -179,7 +179,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/net/disposable-http-server/test/test.validate.js b/lib/node_modules/@stdlib/net/disposable-http-server/test/test.validate.js
index 7722353c73bb..0fd616a2c53a 100644
--- a/lib/node_modules/@stdlib/net/disposable-http-server/test/test.validate.js
+++ b/lib/node_modules/@stdlib/net/disposable-http-server/test/test.validate.js
@@ -151,7 +151,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -172,7 +172,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/net/http-server/test/test.js b/lib/node_modules/@stdlib/net/http-server/test/test.js
index c4579bc480c1..34e115097c1a 100644
--- a/lib/node_modules/@stdlib/net/http-server/test/test.js
+++ b/lib/node_modules/@stdlib/net/http-server/test/test.js
@@ -79,7 +79,7 @@ tape( 'the function will throw an error if provided a request listener which is
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.strictEqual( typeof httpServer(), 'function', 'returns a function' );
+	t.strictEqual( typeof httpServer(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/net/http-server/test/test.validate.js b/lib/node_modules/@stdlib/net/http-server/test/test.validate.js
index 772d7bdcce87..7fe4ea43c76d 100644
--- a/lib/node_modules/@stdlib/net/http-server/test/test.validate.js
+++ b/lib/node_modules/@stdlib/net/http-server/test/test.validate.js
@@ -173,7 +173,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -191,7 +191,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/net/simple-http-server/test/test.validate.js b/lib/node_modules/@stdlib/net/simple-http-server/test/test.validate.js
index 96002fb34a00..484d6b61c1a7 100644
--- a/lib/node_modules/@stdlib/net/simple-http-server/test/test.validate.js
+++ b/lib/node_modules/@stdlib/net/simple-http-server/test/test.validate.js
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -145,7 +145,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/nlp/lda/test/test.validate.js b/lib/node_modules/@stdlib/nlp/lda/test/test.validate.js
index 147cfa005fa4..0c2b92baad2c 100644
--- a/lib/node_modules/@stdlib/nlp/lda/test/test.validate.js
+++ b/lib/node_modules/@stdlib/nlp/lda/test/test.validate.js
@@ -128,7 +128,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -149,7 +149,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/nlp/ordinalize/test/test.validate.js b/lib/node_modules/@stdlib/nlp/ordinalize/test/test.validate.js
index cf4aa6af95ed..a6874b1c7eae 100644
--- a/lib/node_modules/@stdlib/nlp/ordinalize/test/test.validate.js
+++ b/lib/node_modules/@stdlib/nlp/ordinalize/test/test.validate.js
@@ -153,7 +153,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/ctor/test/test.js b/lib/node_modules/@stdlib/number/ctor/test/test.js
index 4c63610e800b..e9edf3bad712 100644
--- a/lib/node_modules/@stdlib/number/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/number/ctor/test/test.js
@@ -54,7 +54,7 @@ tape( 'the constructor length is equal to `1`', function test( t ) {
 tape( 'the constructor returns an object', function test( t ) {
 	var v = new Ctor( 10.0 );
 	t.strictEqual( isNumber.isPrimitive( v ), false, 'does not return a primitive' );
-	t.strictEqual( isNumber.isObject( v ), true, 'returns an object' );
+	t.strictEqual( isNumber.isObject( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/to-json/test/test.js b/lib/node_modules/@stdlib/number/float64/to-json/test/test.js
index c21672262be4..18c659a2eed1 100644
--- a/lib/node_modules/@stdlib/number/float64/to-json/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/to-json/test/test.js
@@ -70,7 +70,7 @@ tape( 'the function returns a JSON object', function test( t ) {
 
 	json = toJSON( NaN );
 
-	t.strictEqual( isPlainObject( json ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( json ), true, 'returns expected value' );
 
 	expected = {
 		'type': 'float64',
@@ -87,7 +87,7 @@ tape( 'the function returns a JSON object', function test( t ) {
 
 	json = toJSON( PINF );
 
-	t.strictEqual( isPlainObject( json ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( json ), true, 'returns expected value' );
 
 	expected = {
 		'type': 'float64',
@@ -104,7 +104,7 @@ tape( 'the function returns a JSON object', function test( t ) {
 
 	json = toJSON( NINF );
 
-	t.strictEqual( isPlainObject( json ), true, 'returns an object' );
+	t.strictEqual( isPlainObject( json ), true, 'returns expected value' );
 
 	expected = {
 		'type': 'float64',
@@ -121,7 +121,7 @@ tape( 'the function returns a number', function test( t ) {
 
 	json = toJSON( 3.14 );
 
-	t.strictEqual( typeof json, 'number', 'returns a number' );
+	t.strictEqual( typeof json, 'number', 'returns expected value' );
 
 	expected = 3.14;
 	t.strictEqual( json, expected, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/os/configdir/test/test.js b/lib/node_modules/@stdlib/os/configdir/test/test.js
index e9261239b83a..4a0de7069e83 100644
--- a/lib/node_modules/@stdlib/os/configdir/test/test.js
+++ b/lib/node_modules/@stdlib/os/configdir/test/test.js
@@ -230,7 +230,7 @@ tape( 'the function returns `null` if unable to locate a home directory on non-W
 
 	configdir = proxyquire( mpath, opts );
 
-	t.strictEqual( configdir(), null, 'returns null' );
+	t.strictEqual( configdir(), null, 'returns expected value' );
 
 	t.end();
 
@@ -333,7 +333,7 @@ tape( 'the function returns `null` if unable to locate an application data direc
 
 	configdir = proxyquire( mpath, opts );
 
-	t.strictEqual( configdir(), null, 'returns null' );
+	t.strictEqual( configdir(), null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/os/homedir/test/test.homedir.js b/lib/node_modules/@stdlib/os/homedir/test/test.homedir.js
index 0dbf5c932891..c7b22f612a6d 100644
--- a/lib/node_modules/@stdlib/os/homedir/test/test.homedir.js
+++ b/lib/node_modules/@stdlib/os/homedir/test/test.homedir.js
@@ -230,7 +230,7 @@ tape( 'the function returns `null` if unable to locate a home directory in a Mac
 	opts[ '@stdlib/os/platform' ] = 'darwin';
 	homedir = proxyquire( mpath, opts );
 
-	t.strictEqual( homedir(), null, 'returns null' );
+	t.strictEqual( homedir(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -245,7 +245,7 @@ tape( 'the function returns `null` if unable to locate a home directory in a Lin
 	opts[ '@stdlib/os/platform' ] = 'linux';
 	homedir = proxyquire( mpath, opts );
 
-	t.strictEqual( homedir(), null, 'returns null' );
+	t.strictEqual( homedir(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -330,6 +330,6 @@ tape( 'the function returns `null` if unable to locate a home directory on Windo
 	opts[ '@stdlib/assert/is-windows' ] = true;
 	homedir = proxyquire( mpath, opts );
 
-	t.strictEqual( homedir(), null, 'returns null' );
+	t.strictEqual( homedir(), null, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/getegid/test/test.js b/lib/node_modules/@stdlib/process/getegid/test/test.js
index 64e69a8b39b7..a8f833e76ead 100644
--- a/lib/node_modules/@stdlib/process/getegid/test/test.js
+++ b/lib/node_modules/@stdlib/process/getegid/test/test.js
@@ -59,10 +59,10 @@ tape( 'if an environment does not support `process.getegid`, the main export alw
 		'@stdlib/assert/is-function': isFunction
 	});
 	t.strictEqual( typeof getegid, 'function', 'main export is a function' );
-	t.strictEqual( getegid(), null, 'returns null' );
-	t.strictEqual( getegid(), null, 'returns null' );
-	t.strictEqual( getegid(), null, 'returns null' );
-	t.strictEqual( getegid(), null, 'returns null' );
+	t.strictEqual( getegid(), null, 'returns expected value' );
+	t.strictEqual( getegid(), null, 'returns expected value' );
+	t.strictEqual( getegid(), null, 'returns expected value' );
+	t.strictEqual( getegid(), null, 'returns expected value' );
 	t.end();
 
 	function isFunction() {
diff --git a/lib/node_modules/@stdlib/process/getegid/test/test.polyfill.js b/lib/node_modules/@stdlib/process/getegid/test/test.polyfill.js
index a7a41dc2d8b1..32512e3b6533 100644
--- a/lib/node_modules/@stdlib/process/getegid/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/process/getegid/test/test.polyfill.js
@@ -33,9 +33,9 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function always returns `null`', function test( t ) {
-	t.strictEqual( getegid(), null, 'returns null' );
-	t.strictEqual( getegid(), null, 'returns null' );
-	t.strictEqual( getegid(), null, 'returns null' );
-	t.strictEqual( getegid(), null, 'returns null' );
+	t.strictEqual( getegid(), null, 'returns expected value' );
+	t.strictEqual( getegid(), null, 'returns expected value' );
+	t.strictEqual( getegid(), null, 'returns expected value' );
+	t.strictEqual( getegid(), null, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/geteuid/test/test.js b/lib/node_modules/@stdlib/process/geteuid/test/test.js
index 93e5677385a5..66f7e83639d2 100644
--- a/lib/node_modules/@stdlib/process/geteuid/test/test.js
+++ b/lib/node_modules/@stdlib/process/geteuid/test/test.js
@@ -59,10 +59,10 @@ tape( 'if an environment does not support `process.geteuid`, the main export alw
 		'@stdlib/assert/is-function': isFunction
 	});
 	t.strictEqual( typeof geteuid, 'function', 'main export is a function' );
-	t.strictEqual( geteuid(), null, 'returns null' );
-	t.strictEqual( geteuid(), null, 'returns null' );
-	t.strictEqual( geteuid(), null, 'returns null' );
-	t.strictEqual( geteuid(), null, 'returns null' );
+	t.strictEqual( geteuid(), null, 'returns expected value' );
+	t.strictEqual( geteuid(), null, 'returns expected value' );
+	t.strictEqual( geteuid(), null, 'returns expected value' );
+	t.strictEqual( geteuid(), null, 'returns expected value' );
 	t.end();
 
 	function isFunction() {
diff --git a/lib/node_modules/@stdlib/process/geteuid/test/test.polyfill.js b/lib/node_modules/@stdlib/process/geteuid/test/test.polyfill.js
index 5e8039b3d128..1880eaa65a4e 100644
--- a/lib/node_modules/@stdlib/process/geteuid/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/process/geteuid/test/test.polyfill.js
@@ -33,9 +33,9 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function always returns `null`', function test( t ) {
-	t.strictEqual( geteuid(), null, 'returns null' );
-	t.strictEqual( geteuid(), null, 'returns null' );
-	t.strictEqual( geteuid(), null, 'returns null' );
-	t.strictEqual( geteuid(), null, 'returns null' );
+	t.strictEqual( geteuid(), null, 'returns expected value' );
+	t.strictEqual( geteuid(), null, 'returns expected value' );
+	t.strictEqual( geteuid(), null, 'returns expected value' );
+	t.strictEqual( geteuid(), null, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/getgid/test/test.js b/lib/node_modules/@stdlib/process/getgid/test/test.js
index 41bdc0b46e31..0f5be3e6cddb 100644
--- a/lib/node_modules/@stdlib/process/getgid/test/test.js
+++ b/lib/node_modules/@stdlib/process/getgid/test/test.js
@@ -59,10 +59,10 @@ tape( 'if an environment does not support `process.getgid`, the main export alwa
 		'@stdlib/assert/is-function': isFunction
 	});
 	t.strictEqual( typeof getgid, 'function', 'main export is a function' );
-	t.strictEqual( getgid(), null, 'returns null' );
-	t.strictEqual( getgid(), null, 'returns null' );
-	t.strictEqual( getgid(), null, 'returns null' );
-	t.strictEqual( getgid(), null, 'returns null' );
+	t.strictEqual( getgid(), null, 'returns expected value' );
+	t.strictEqual( getgid(), null, 'returns expected value' );
+	t.strictEqual( getgid(), null, 'returns expected value' );
+	t.strictEqual( getgid(), null, 'returns expected value' );
 	t.end();
 
 	function isFunction() {
diff --git a/lib/node_modules/@stdlib/process/getgid/test/test.polyfill.js b/lib/node_modules/@stdlib/process/getgid/test/test.polyfill.js
index ef51f593b8ff..3c295f16fb21 100644
--- a/lib/node_modules/@stdlib/process/getgid/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/process/getgid/test/test.polyfill.js
@@ -33,9 +33,9 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function always returns `null`', function test( t ) {
-	t.strictEqual( getgid(), null, 'returns null' );
-	t.strictEqual( getgid(), null, 'returns null' );
-	t.strictEqual( getgid(), null, 'returns null' );
-	t.strictEqual( getgid(), null, 'returns null' );
+	t.strictEqual( getgid(), null, 'returns expected value' );
+	t.strictEqual( getgid(), null, 'returns expected value' );
+	t.strictEqual( getgid(), null, 'returns expected value' );
+	t.strictEqual( getgid(), null, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/getuid/test/test.js b/lib/node_modules/@stdlib/process/getuid/test/test.js
index c766ae4535a7..6f77a2aafdd8 100644
--- a/lib/node_modules/@stdlib/process/getuid/test/test.js
+++ b/lib/node_modules/@stdlib/process/getuid/test/test.js
@@ -59,10 +59,10 @@ tape( 'if an environment does not support `process.getuid`, the main export alwa
 		'@stdlib/assert/is-function': isFunction
 	});
 	t.strictEqual( typeof getuid, 'function', 'main export is a function' );
-	t.strictEqual( getuid(), null, 'returns null' );
-	t.strictEqual( getuid(), null, 'returns null' );
-	t.strictEqual( getuid(), null, 'returns null' );
-	t.strictEqual( getuid(), null, 'returns null' );
+	t.strictEqual( getuid(), null, 'returns expected value' );
+	t.strictEqual( getuid(), null, 'returns expected value' );
+	t.strictEqual( getuid(), null, 'returns expected value' );
+	t.strictEqual( getuid(), null, 'returns expected value' );
 	t.end();
 
 	function isFunction() {
diff --git a/lib/node_modules/@stdlib/process/getuid/test/test.polyfill.js b/lib/node_modules/@stdlib/process/getuid/test/test.polyfill.js
index bd409ff19de4..9b3b1cec084e 100644
--- a/lib/node_modules/@stdlib/process/getuid/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/process/getuid/test/test.polyfill.js
@@ -33,9 +33,9 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function always returns `null`', function test( t ) {
-	t.strictEqual( getuid(), null, 'returns null' );
-	t.strictEqual( getuid(), null, 'returns null' );
-	t.strictEqual( getuid(), null, 'returns null' );
-	t.strictEqual( getuid(), null, 'returns null' );
+	t.strictEqual( getuid(), null, 'returns expected value' );
+	t.strictEqual( getuid(), null, 'returns expected value' );
+	t.strictEqual( getuid(), null, 'returns expected value' );
+	t.strictEqual( getuid(), null, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/minstd-shuffle/test/test.validate.js b/lib/node_modules/@stdlib/random/array/minstd-shuffle/test/test.validate.js
index fe2a14c5f200..6c99908c6e25 100644
--- a/lib/node_modules/@stdlib/random/array/minstd-shuffle/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/array/minstd-shuffle/test/test.validate.js
@@ -231,7 +231,7 @@ tape( 'the function returns null if all options are valid (mode=1)', function te
 	opts = {};
 	err = validate( opts, options, 1 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -248,7 +248,7 @@ tape( 'the function returns null if all options are valid (mode=2)', function te
 	opts = {};
 	err = validate( opts, options, 2 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -266,7 +266,7 @@ tape( 'the function returns null if all options are valid (mode=0)', function te
 	opts = {};
 	err = validate( opts, options, 0 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -284,7 +284,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=0)', function
 	opts = {};
 	err = validate( opts, options, 0 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
@@ -301,7 +301,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=1)', function
 	opts = {};
 	err = validate( opts, options, 1 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
@@ -318,7 +318,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=2)', function
 	opts = {};
 	err = validate( opts, options, 2 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/minstd/test/test.validate.js b/lib/node_modules/@stdlib/random/array/minstd/test/test.validate.js
index fe2a14c5f200..6c99908c6e25 100644
--- a/lib/node_modules/@stdlib/random/array/minstd/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/array/minstd/test/test.validate.js
@@ -231,7 +231,7 @@ tape( 'the function returns null if all options are valid (mode=1)', function te
 	opts = {};
 	err = validate( opts, options, 1 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -248,7 +248,7 @@ tape( 'the function returns null if all options are valid (mode=2)', function te
 	opts = {};
 	err = validate( opts, options, 2 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -266,7 +266,7 @@ tape( 'the function returns null if all options are valid (mode=0)', function te
 	opts = {};
 	err = validate( opts, options, 0 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -284,7 +284,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=0)', function
 	opts = {};
 	err = validate( opts, options, 0 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
@@ -301,7 +301,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=1)', function
 	opts = {};
 	err = validate( opts, options, 1 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
@@ -318,7 +318,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=2)', function
 	opts = {};
 	err = validate( opts, options, 2 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/mt19937/test/test.validate.js b/lib/node_modules/@stdlib/random/array/mt19937/test/test.validate.js
index fe2a14c5f200..6c99908c6e25 100644
--- a/lib/node_modules/@stdlib/random/array/mt19937/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/array/mt19937/test/test.validate.js
@@ -231,7 +231,7 @@ tape( 'the function returns null if all options are valid (mode=1)', function te
 	opts = {};
 	err = validate( opts, options, 1 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -248,7 +248,7 @@ tape( 'the function returns null if all options are valid (mode=2)', function te
 	opts = {};
 	err = validate( opts, options, 2 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -266,7 +266,7 @@ tape( 'the function returns null if all options are valid (mode=0)', function te
 	opts = {};
 	err = validate( opts, options, 0 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -284,7 +284,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=0)', function
 	opts = {};
 	err = validate( opts, options, 0 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
@@ -301,7 +301,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=1)', function
 	opts = {};
 	err = validate( opts, options, 1 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
@@ -318,7 +318,7 @@ tape( 'the function ignores unrecognized/unsupported options (mode=2)', function
 	opts = {};
 	err = validate( opts, options, 2 );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/array/randu/test/test.validate.js b/lib/node_modules/@stdlib/random/array/randu/test/test.validate.js
index 6897b9348963..35a4f71a14f5 100644
--- a/lib/node_modules/@stdlib/random/array/randu/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/array/randu/test/test.validate.js
@@ -94,7 +94,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -112,7 +112,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/arcsine/test/test.js b/lib/node_modules/@stdlib/random/iter/arcsine/test/test.js
index d0068adabb33..101acf895322 100644
--- a/lib/node_modules/@stdlib/random/iter/arcsine/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/arcsine/test/test.js
@@ -359,8 +359,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -535,11 +535,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -560,11 +560,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -593,7 +593,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -630,7 +630,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/bernoulli/test/test.js b/lib/node_modules/@stdlib/random/iter/bernoulli/test/test.js
index 6aa6e19b3d29..dae4d5401183 100644
--- a/lib/node_modules/@stdlib/random/iter/bernoulli/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/bernoulli/test/test.js
@@ -311,8 +311,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -487,11 +487,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -512,11 +512,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -545,7 +545,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/beta/test/test.js b/lib/node_modules/@stdlib/random/iter/beta/test/test.js
index af3c0aa387e7..5b7e56c88e66 100644
--- a/lib/node_modules/@stdlib/random/iter/beta/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/beta/test/test.js
@@ -341,8 +341,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -517,11 +517,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -542,11 +542,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -575,7 +575,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/betaprime/test/test.js b/lib/node_modules/@stdlib/random/iter/betaprime/test/test.js
index df97ac14c55f..43735ce492c0 100644
--- a/lib/node_modules/@stdlib/random/iter/betaprime/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/betaprime/test/test.js
@@ -341,8 +341,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -517,11 +517,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -542,11 +542,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -575,7 +575,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/binomial/test/test.js b/lib/node_modules/@stdlib/random/iter/binomial/test/test.js
index b05774254234..1ac57c4a8c4d 100644
--- a/lib/node_modules/@stdlib/random/iter/binomial/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/binomial/test/test.js
@@ -343,8 +343,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -519,11 +519,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 20, 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -544,11 +544,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 20, 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -577,7 +577,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -614,7 +614,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/box-muller/test/test.js b/lib/node_modules/@stdlib/random/iter/box-muller/test/test.js
index 8c5fb331f273..445f0edf306f 100644
--- a/lib/node_modules/@stdlib/random/iter/box-muller/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/box-muller/test/test.js
@@ -281,8 +281,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -457,11 +457,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -482,11 +482,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -515,7 +515,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -552,7 +552,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/cauchy/test/test.js b/lib/node_modules/@stdlib/random/iter/cauchy/test/test.js
index 0b146e917a79..89c28da30f9f 100644
--- a/lib/node_modules/@stdlib/random/iter/cauchy/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/cauchy/test/test.js
@@ -339,8 +339,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -515,11 +515,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -540,11 +540,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -573,7 +573,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/chi/test/test.js b/lib/node_modules/@stdlib/random/iter/chi/test/test.js
index da4aee0c201a..f9020a90fb70 100644
--- a/lib/node_modules/@stdlib/random/iter/chi/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/chi/test/test.js
@@ -311,8 +311,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -487,11 +487,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -512,11 +512,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -545,7 +545,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/chisquare/test/test.js b/lib/node_modules/@stdlib/random/iter/chisquare/test/test.js
index 36b7a5daf03c..c9a9be444f74 100644
--- a/lib/node_modules/@stdlib/random/iter/chisquare/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/chisquare/test/test.js
@@ -311,8 +311,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -487,11 +487,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -512,11 +512,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -545,7 +545,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/cosine/test/test.js b/lib/node_modules/@stdlib/random/iter/cosine/test/test.js
index 5628aa87993d..3ed3da58f800 100644
--- a/lib/node_modules/@stdlib/random/iter/cosine/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/cosine/test/test.js
@@ -339,8 +339,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -515,11 +515,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -540,11 +540,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -573,7 +573,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/discrete-uniform/test/test.js b/lib/node_modules/@stdlib/random/iter/discrete-uniform/test/test.js
index cbc52bc0ed79..f50bfe7d212e 100644
--- a/lib/node_modules/@stdlib/random/iter/discrete-uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/discrete-uniform/test/test.js
@@ -435,8 +435,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -611,11 +611,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10, 10 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -636,11 +636,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10, 10 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -669,7 +669,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -706,7 +706,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/erlang/test/test.js b/lib/node_modules/@stdlib/random/iter/erlang/test/test.js
index 4f7a8c502748..98069772f9df 100644
--- a/lib/node_modules/@stdlib/random/iter/erlang/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/erlang/test/test.js
@@ -342,8 +342,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -518,11 +518,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -543,11 +543,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -576,7 +576,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -613,7 +613,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/exponential/test/test.js b/lib/node_modules/@stdlib/random/iter/exponential/test/test.js
index fb83cf72ed79..9e765dd527fb 100644
--- a/lib/node_modules/@stdlib/random/iter/exponential/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/exponential/test/test.js
@@ -311,8 +311,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -487,11 +487,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -512,11 +512,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -545,7 +545,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/f/test/test.js b/lib/node_modules/@stdlib/random/iter/f/test/test.js
index e77c4df21170..709ea120eceb 100644
--- a/lib/node_modules/@stdlib/random/iter/f/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/f/test/test.js
@@ -341,8 +341,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -517,11 +517,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -542,11 +542,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -575,7 +575,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/frechet/test/test.js b/lib/node_modules/@stdlib/random/iter/frechet/test/test.js
index 577184c228e8..f46e91d4f01a 100644
--- a/lib/node_modules/@stdlib/random/iter/frechet/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/frechet/test/test.js
@@ -369,8 +369,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -545,11 +545,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0, 0.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -570,11 +570,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0, 0.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -603,7 +603,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -640,7 +640,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/gamma/test/test.js b/lib/node_modules/@stdlib/random/iter/gamma/test/test.js
index 3b3a6f80c181..8ad643d8d7cb 100644
--- a/lib/node_modules/@stdlib/random/iter/gamma/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/gamma/test/test.js
@@ -341,8 +341,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -517,11 +517,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -542,11 +542,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -575,7 +575,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/geometric/test/test.js b/lib/node_modules/@stdlib/random/iter/geometric/test/test.js
index 57a723817e30..6bcfbbf8facb 100644
--- a/lib/node_modules/@stdlib/random/iter/geometric/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/geometric/test/test.js
@@ -311,8 +311,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -487,11 +487,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -512,11 +512,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -545,7 +545,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/gumbel/test/test.js b/lib/node_modules/@stdlib/random/iter/gumbel/test/test.js
index e2638c033222..946b9c8201ee 100644
--- a/lib/node_modules/@stdlib/random/iter/gumbel/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/gumbel/test/test.js
@@ -339,8 +339,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -515,11 +515,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -540,11 +540,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -573,7 +573,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/hypergeometric/test/test.js b/lib/node_modules/@stdlib/random/iter/hypergeometric/test/test.js
index 0d1579c7863c..f58f1bdd5167 100644
--- a/lib/node_modules/@stdlib/random/iter/hypergeometric/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/hypergeometric/test/test.js
@@ -418,8 +418,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -594,11 +594,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 20, 10, 10 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -619,11 +619,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 20, 20, 10 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -652,7 +652,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -689,7 +689,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/improved-ziggurat/test/test.js b/lib/node_modules/@stdlib/random/iter/improved-ziggurat/test/test.js
index e52e714cda42..4fd70c63d70b 100644
--- a/lib/node_modules/@stdlib/random/iter/improved-ziggurat/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/improved-ziggurat/test/test.js
@@ -281,8 +281,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -457,11 +457,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -482,11 +482,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -515,7 +515,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -552,7 +552,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/invgamma/test/test.js b/lib/node_modules/@stdlib/random/iter/invgamma/test/test.js
index 59393dbd9324..be81a36cfd4c 100644
--- a/lib/node_modules/@stdlib/random/iter/invgamma/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/invgamma/test/test.js
@@ -341,8 +341,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -517,11 +517,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -542,11 +542,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -575,7 +575,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/kumaraswamy/test/test.js b/lib/node_modules/@stdlib/random/iter/kumaraswamy/test/test.js
index ff72267a0c59..68a8064beaaf 100644
--- a/lib/node_modules/@stdlib/random/iter/kumaraswamy/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/kumaraswamy/test/test.js
@@ -341,8 +341,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -517,11 +517,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -542,11 +542,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -575,7 +575,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/laplace/test/test.js b/lib/node_modules/@stdlib/random/iter/laplace/test/test.js
index 87a90e6a12df..2810eca9d593 100644
--- a/lib/node_modules/@stdlib/random/iter/laplace/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/laplace/test/test.js
@@ -339,8 +339,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -515,11 +515,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -540,11 +540,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -573,7 +573,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/levy/test/test.js b/lib/node_modules/@stdlib/random/iter/levy/test/test.js
index 42a29282165b..69118077ffe9 100644
--- a/lib/node_modules/@stdlib/random/iter/levy/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/levy/test/test.js
@@ -339,8 +339,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -515,11 +515,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -540,11 +540,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -573,7 +573,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/logistic/test/test.js b/lib/node_modules/@stdlib/random/iter/logistic/test/test.js
index 027353f1f296..11e0220ec1de 100644
--- a/lib/node_modules/@stdlib/random/iter/logistic/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/logistic/test/test.js
@@ -339,8 +339,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -515,11 +515,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -540,11 +540,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -573,7 +573,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/lognormal/test/test.js b/lib/node_modules/@stdlib/random/iter/lognormal/test/test.js
index 6ca4b4330371..1e981f8cfbf0 100644
--- a/lib/node_modules/@stdlib/random/iter/lognormal/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/lognormal/test/test.js
@@ -339,8 +339,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -515,11 +515,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -540,11 +540,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -573,7 +573,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/minstd-shuffle/test/test.js b/lib/node_modules/@stdlib/random/iter/minstd-shuffle/test/test.js
index cb60530b3d10..0a43cf4db52f 100644
--- a/lib/node_modules/@stdlib/random/iter/minstd-shuffle/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/minstd-shuffle/test/test.js
@@ -281,8 +281,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -441,11 +441,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -466,11 +466,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -499,7 +499,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
diff --git a/lib/node_modules/@stdlib/random/iter/minstd/test/test.js b/lib/node_modules/@stdlib/random/iter/minstd/test/test.js
index 153e698cdd8a..3e4d741e150b 100644
--- a/lib/node_modules/@stdlib/random/iter/minstd/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/minstd/test/test.js
@@ -281,8 +281,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -441,11 +441,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -466,11 +466,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -499,7 +499,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
diff --git a/lib/node_modules/@stdlib/random/iter/mt19937/test/test.js b/lib/node_modules/@stdlib/random/iter/mt19937/test/test.js
index 39778f3f3038..5bdec32c8c4b 100644
--- a/lib/node_modules/@stdlib/random/iter/mt19937/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/mt19937/test/test.js
@@ -281,8 +281,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -441,11 +441,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -466,11 +466,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -499,7 +499,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
diff --git a/lib/node_modules/@stdlib/random/iter/negative-binomial/test/test.js b/lib/node_modules/@stdlib/random/iter/negative-binomial/test/test.js
index 4d892fb37734..a03c29b6d116 100644
--- a/lib/node_modules/@stdlib/random/iter/negative-binomial/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/negative-binomial/test/test.js
@@ -342,8 +342,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -518,11 +518,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 20, 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -543,11 +543,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 20, 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -576,7 +576,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -613,7 +613,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/normal/test/test.js b/lib/node_modules/@stdlib/random/iter/normal/test/test.js
index ebc679ed557a..f42e5724d28e 100644
--- a/lib/node_modules/@stdlib/random/iter/normal/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/normal/test/test.js
@@ -339,8 +339,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -515,11 +515,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -540,11 +540,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -573,7 +573,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -610,7 +610,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/pareto-type1/test/test.js b/lib/node_modules/@stdlib/random/iter/pareto-type1/test/test.js
index 546e1dfd7f24..a47d1a72ee5f 100644
--- a/lib/node_modules/@stdlib/random/iter/pareto-type1/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/pareto-type1/test/test.js
@@ -341,8 +341,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -517,11 +517,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -542,11 +542,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -575,7 +575,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/poisson/test/test.js b/lib/node_modules/@stdlib/random/iter/poisson/test/test.js
index 8429cb0a8bfe..6c4b9b70108c 100644
--- a/lib/node_modules/@stdlib/random/iter/poisson/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/poisson/test/test.js
@@ -311,8 +311,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -487,11 +487,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -512,11 +512,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -545,7 +545,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/randi/test/test.js b/lib/node_modules/@stdlib/random/iter/randi/test/test.js
index aebd0dd100f3..7e5cc41dc321 100644
--- a/lib/node_modules/@stdlib/random/iter/randi/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/randi/test/test.js
@@ -230,8 +230,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -384,11 +384,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -409,11 +409,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -442,7 +442,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
diff --git a/lib/node_modules/@stdlib/random/iter/randn/test/test.js b/lib/node_modules/@stdlib/random/iter/randn/test/test.js
index 82dac0f6b64c..f4c5cae4e45b 100644
--- a/lib/node_modules/@stdlib/random/iter/randn/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/randn/test/test.js
@@ -310,8 +310,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -486,11 +486,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -511,11 +511,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -544,7 +544,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -581,7 +581,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/randu/test/test.js b/lib/node_modules/@stdlib/random/iter/randu/test/test.js
index 2974456ea96b..6c4b5c5cb3f0 100644
--- a/lib/node_modules/@stdlib/random/iter/randu/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/randu/test/test.js
@@ -230,8 +230,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -384,11 +384,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -409,11 +409,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -442,7 +442,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
diff --git a/lib/node_modules/@stdlib/random/iter/rayleigh/test/test.js b/lib/node_modules/@stdlib/random/iter/rayleigh/test/test.js
index 9d3a3a142f14..f5082b083101 100644
--- a/lib/node_modules/@stdlib/random/iter/rayleigh/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/rayleigh/test/test.js
@@ -311,8 +311,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -487,11 +487,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -512,11 +512,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -545,7 +545,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/t/test/test.js b/lib/node_modules/@stdlib/random/iter/t/test/test.js
index 102ac7b546b4..bd0c35690312 100644
--- a/lib/node_modules/@stdlib/random/iter/t/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/t/test/test.js
@@ -311,8 +311,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -487,11 +487,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -512,11 +512,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 0.7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -545,7 +545,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -582,7 +582,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/triangular/test/test.js b/lib/node_modules/@stdlib/random/iter/triangular/test/test.js
index 53f0ee1140ce..c9466a6780ef 100644
--- a/lib/node_modules/@stdlib/random/iter/triangular/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/triangular/test/test.js
@@ -388,8 +388,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -564,11 +564,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0, 0.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -589,11 +589,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0, 0.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -622,7 +622,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -659,7 +659,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/uniform/test/test.js b/lib/node_modules/@stdlib/random/iter/uniform/test/test.js
index dbe2b502670b..809d0b2bc033 100644
--- a/lib/node_modules/@stdlib/random/iter/uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/uniform/test/test.js
@@ -359,8 +359,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -535,11 +535,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -560,11 +560,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( -10.0, 10.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -593,7 +593,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -630,7 +630,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/iter/weibull/test/test.js b/lib/node_modules/@stdlib/random/iter/weibull/test/test.js
index 27b2c437ad40..9e3c377bf75b 100644
--- a/lib/node_modules/@stdlib/random/iter/weibull/test/test.js
+++ b/lib/node_modules/@stdlib/random/iter/weibull/test/test.js
@@ -341,8 +341,8 @@ tape( 'the function returns an iterator protocol-compliant object (no seed)', fu
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -517,11 +517,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -542,11 +542,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterator( 1.0, 1.0 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -575,7 +575,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 	t.deepEqual( it2.seed, it1.seed, 'has expected seed' );
@@ -612,7 +612,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = it.next().value;
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/sample/test/test.factory.js b/lib/node_modules/@stdlib/random/sample/test/test.factory.js
index c5286fc6e36e..c59392cfd3cf 100644
--- a/lib/node_modules/@stdlib/random/sample/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/sample/test/test.factory.js
@@ -208,7 +208,7 @@ tape( 'the returned function allows overriding the default mutate strategy', fun
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	actual = sample();
-	t.strictEqual( actual, null, 'returns null' );
+	t.strictEqual( actual, null, 'returns expected value' );
 
 	t.end();
 });
@@ -324,7 +324,7 @@ tape( 'when the population is fixed, the returned function returns `null` after
 	t.deepEqual( actual, expected, 'returned array is a random draw' );
 
 	actual = sample();
-	t.strictEqual( actual, null, 'returns null' );
+	t.strictEqual( actual, null, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/sample/test/test.validate.js b/lib/node_modules/@stdlib/random/sample/test/test.validate.js
index b998948841bc..91aeaa6c176c 100644
--- a/lib/node_modules/@stdlib/random/sample/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/sample/test/test.validate.js
@@ -175,7 +175,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.mutate, opts.mutate, 'sets mutate option' );
 	t.strictEqual( obj.replace, opts.replace, 'sets replace option' );
 	t.strictEqual( obj.size, opts.size, 'sets size option' );
@@ -194,7 +194,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/shuffle/test/test.validate.js b/lib/node_modules/@stdlib/random/shuffle/test/test.validate.js
index c8d154d9571d..e2e625edd8be 100644
--- a/lib/node_modules/@stdlib/random/shuffle/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/shuffle/test/test.validate.js
@@ -93,7 +93,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.copy, opts.copy, 'sets copy option' );
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.factory.js
index 4ea6cbfa0547..8424c1858a6a 100644
--- a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.validate.js
index bb83f7287f79..82b5dcd0c0f8 100644
--- a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.factory.js
index b5e4164429a6..ef1789c51e37 100644
--- a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 0.3 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 0.3, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.validate.js
index 56cbd6b26adc..f9b7fb45de52 100644
--- a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/beta/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/beta/test/test.factory.js
index d11363e72cb4..24c6a277760a 100644
--- a/lib/node_modules/@stdlib/random/streams/beta/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/beta/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/beta/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/beta/test/test.validate.js
index 8ea631fa473b..1920295981ff 100644
--- a/lib/node_modules/@stdlib/random/streams/beta/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/beta/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.factory.js
index d11363e72cb4..24c6a277760a 100644
--- a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.validate.js
index 8ea631fa473b..1920295981ff 100644
--- a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/binomial/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/binomial/test/test.factory.js
index 0c9fed4d603f..25a829c8543e 100644
--- a/lib/node_modules/@stdlib/random/streams/binomial/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/binomial/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 20, 0.3 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 20, 0.3, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/binomial/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/binomial/test/test.validate.js
index d96263f01468..39eccb28dcf4 100644
--- a/lib/node_modules/@stdlib/random/streams/binomial/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/binomial/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.factory.js
index cdefd1890517..5f1480a81f6e 100644
--- a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.factory.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.validate.js
index bb83f7287f79..82b5dcd0c0f8 100644
--- a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.factory.js
index 6f8ee34a5581..5c9ce34602d6 100644
--- a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.validate.js
index 9e65113c7eb6..f5677f71bc89 100644
--- a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/chi/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/chi/test/test.factory.js
index f7abe486db00..be6ca412f81a 100644
--- a/lib/node_modules/@stdlib/random/streams/chi/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/chi/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 3.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 3.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/chi/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/chi/test/test.validate.js
index a6daed8d715c..e6f97abe21ac 100644
--- a/lib/node_modules/@stdlib/random/streams/chi/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/chi/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.factory.js
index f7abe486db00..be6ca412f81a 100644
--- a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 3.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 3.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.validate.js
index 8edb325e7974..cd27f0329e08 100644
--- a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/cosine/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/cosine/test/test.factory.js
index 1f3ef0aea13e..fb6972d82198 100644
--- a/lib/node_modules/@stdlib/random/streams/cosine/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/cosine/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/cosine/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/cosine/test/test.validate.js
index 0592d843660e..a6dcea1e2dcb 100644
--- a/lib/node_modules/@stdlib/random/streams/cosine/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/cosine/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.factory.js
index 90328dc32bce..94b6af9e4d78 100644
--- a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2, 5 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2, 5, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.validate.js
index 155c1dad8b5e..e090b12779e3 100644
--- a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/erlang/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/erlang/test/test.factory.js
index bd56b7edc748..31146809cc39 100644
--- a/lib/node_modules/@stdlib/random/streams/erlang/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/erlang/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/erlang/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/erlang/test/test.validate.js
index 06d6688fb1aa..07aa41c0ec8b 100644
--- a/lib/node_modules/@stdlib/random/streams/erlang/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/erlang/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/exponential/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/exponential/test/test.factory.js
index e0453fff2d3c..a1487342faf7 100644
--- a/lib/node_modules/@stdlib/random/streams/exponential/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/exponential/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 3.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 3.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/exponential/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/exponential/test/test.validate.js
index 3f37d0a09b6a..2526980a697d 100644
--- a/lib/node_modules/@stdlib/random/streams/exponential/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/exponential/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/f/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/f/test/test.factory.js
index c7158693d10f..c2757fab1dae 100644
--- a/lib/node_modules/@stdlib/random/streams/f/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/f/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/f/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/f/test/test.validate.js
index 1ccfc8d09f4a..549b9e5f6cff 100644
--- a/lib/node_modules/@stdlib/random/streams/f/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/f/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/frechet/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/frechet/test/test.factory.js
index b4ddbdfc2666..120508d26d59 100644
--- a/lib/node_modules/@stdlib/random/streams/frechet/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/frechet/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, 3.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, 3.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/frechet/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/frechet/test/test.validate.js
index 36aabcd247d5..3ad0842339a4 100644
--- a/lib/node_modules/@stdlib/random/streams/frechet/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/frechet/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/gamma/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/gamma/test/test.factory.js
index 4105d7ccb153..0d1c8336fc33 100644
--- a/lib/node_modules/@stdlib/random/streams/gamma/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/gamma/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/gamma/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/gamma/test/test.validate.js
index 7134a838b6e0..09373f1faf02 100644
--- a/lib/node_modules/@stdlib/random/streams/gamma/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/gamma/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/geometric/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/geometric/test/test.factory.js
index b5e4164429a6..ef1789c51e37 100644
--- a/lib/node_modules/@stdlib/random/streams/geometric/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/geometric/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 0.3 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 0.3, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/geometric/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/geometric/test/test.validate.js
index 8c6a311db403..dc019d61e59c 100644
--- a/lib/node_modules/@stdlib/random/streams/geometric/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/geometric/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.factory.js
index f20cf72bc7fd..83390ef297a3 100644
--- a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.validate.js
index 80eb94597d0d..c40c8ee366b7 100644
--- a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.factory.js
index 2e8db6b590f8..a18a8537196d 100644
--- a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 20, 10, 7 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 20, 10, 7, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.validate.js
index 5a170fd9636a..d17f6b876f4b 100644
--- a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.factory.js
index cdefd1890517..5f1480a81f6e 100644
--- a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.factory.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.validate.js
index bb83f7287f79..82b5dcd0c0f8 100644
--- a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.factory.js
index 587b2077bfae..5c9cb8737839 100644
--- a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.validate.js
index 766af4795dd5..a69f218fcd83 100644
--- a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.factory.js
index 860ce252181d..2cc2fc823753 100644
--- a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.validate.js
index a0fa38d4e64d..38a2b09c7b75 100644
--- a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/laplace/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/laplace/test/test.factory.js
index 779baca0b3d6..54370487dd0d 100644
--- a/lib/node_modules/@stdlib/random/streams/laplace/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/laplace/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/laplace/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/laplace/test/test.validate.js
index 681ae29065bc..329d65b1b48a 100644
--- a/lib/node_modules/@stdlib/random/streams/laplace/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/laplace/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/levy/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/levy/test/test.factory.js
index e6643169e60b..f0ee96791fe0 100644
--- a/lib/node_modules/@stdlib/random/streams/levy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/levy/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/levy/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/levy/test/test.validate.js
index 8ea631fa473b..1920295981ff 100644
--- a/lib/node_modules/@stdlib/random/streams/levy/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/levy/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/logistic/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/logistic/test/test.factory.js
index a3872c01b590..c5cbcf0eebbb 100644
--- a/lib/node_modules/@stdlib/random/streams/logistic/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/logistic/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/logistic/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/logistic/test/test.validate.js
index 8ea631fa473b..1920295981ff 100644
--- a/lib/node_modules/@stdlib/random/streams/logistic/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/logistic/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.factory.js
index 0eae2a723807..811f66af2f99 100644
--- a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.validate.js
index f2ef14f9bbad..8b37860b098c 100644
--- a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.factory.js
index 0197520259a6..c9a0c1653e2d 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.factory.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.validate.js
index d64aa094d4c3..10fe791d2592 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/minstd/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/minstd/test/test.factory.js
index 0197520259a6..c9a0c1653e2d 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd/test/test.factory.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/minstd/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/minstd/test/test.validate.js
index d64aa094d4c3..10fe791d2592 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.factory.js
index 6fa3ce13d03c..fe25386049a3 100644
--- a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.factory.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.validate.js
index 81da4f1f30da..98b73e7bf494 100644
--- a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.factory.js
index 2685745ccf26..439deb8cece5 100644
--- a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 20.0, 0.3 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 20.0, 0.3, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.validate.js
index 17aa5dfb15bb..cfcaf81e58b5 100644
--- a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/normal/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/normal/test/test.factory.js
index 3cfdf41122c3..09cd99dd4271 100644
--- a/lib/node_modules/@stdlib/random/streams/normal/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/normal/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/normal/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/normal/test/test.validate.js
index 98535cbb5183..f31dd2a41b94 100644
--- a/lib/node_modules/@stdlib/random/streams/normal/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/normal/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.factory.js
index 587b2077bfae..5c9cb8737839 100644
--- a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.validate.js
index b574985fb478..02281e0b45a7 100644
--- a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/poisson/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/poisson/test/test.factory.js
index fa5d6a364b46..7deaf7d0f036 100644
--- a/lib/node_modules/@stdlib/random/streams/poisson/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/poisson/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 3.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 3.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/poisson/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/poisson/test/test.validate.js
index 8d6a0a1c2281..32809387aa3e 100644
--- a/lib/node_modules/@stdlib/random/streams/poisson/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/poisson/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randi/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/randi/test/test.factory.js
index 72d28a875340..f678f20664ac 100644
--- a/lib/node_modules/@stdlib/random/streams/randi/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/randi/test/test.factory.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/randi/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/randi/test/test.validate.js
index 79d53056cbc2..5cac35fd2e4a 100644
--- a/lib/node_modules/@stdlib/random/streams/randi/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/randi/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randn/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/randn/test/test.factory.js
index aa0801c06ec4..7b63b01a4634 100644
--- a/lib/node_modules/@stdlib/random/streams/randn/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/randn/test/test.factory.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/randn/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/randn/test/test.validate.js
index dd0945812eed..130f326b07ef 100644
--- a/lib/node_modules/@stdlib/random/streams/randn/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/randn/test/test.validate.js
@@ -305,7 +305,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -324,7 +324,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -342,7 +342,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randu/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/randu/test/test.factory.js
index 72d28a875340..f678f20664ac 100644
--- a/lib/node_modules/@stdlib/random/streams/randu/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/randu/test/test.factory.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/randu/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/randu/test/test.validate.js
index 79d53056cbc2..5cac35fd2e4a 100644
--- a/lib/node_modules/@stdlib/random/streams/randu/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/randu/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.factory.js
index ece7cf2bcdbc..0d17ca01d0e7 100644
--- a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 3.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 3.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.validate.js
index 6bb614a6373b..c7fecbbd16a4 100644
--- a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/t/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/t/test/test.factory.js
index 80699b709ccd..f832f5fb501f 100644
--- a/lib/node_modules/@stdlib/random/streams/t/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/t/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 3.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 3.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/t/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/t/test/test.validate.js
index 0d7eed589934..3dfdafed649d 100644
--- a/lib/node_modules/@stdlib/random/streams/t/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/t/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/triangular/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/triangular/test/test.factory.js
index bfe23e2ffcd2..d5167b44eb1e 100644
--- a/lib/node_modules/@stdlib/random/streams/triangular/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/triangular/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, 4.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, 4.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/triangular/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/triangular/test/test.validate.js
index 2cde8d0057a3..2dcc69fb6c52 100644
--- a/lib/node_modules/@stdlib/random/streams/triangular/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/triangular/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/uniform/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/uniform/test/test.factory.js
index 4ea6cbfa0547..8424c1858a6a 100644
--- a/lib/node_modules/@stdlib/random/streams/uniform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/uniform/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/uniform/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/uniform/test/test.validate.js
index 8ea631fa473b..1920295981ff 100644
--- a/lib/node_modules/@stdlib/random/streams/uniform/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/uniform/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/weibull/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/weibull/test/test.factory.js
index 4a4b761d949b..c02e8787e3a0 100644
--- a/lib/node_modules/@stdlib/random/streams/weibull/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/weibull/test/test.factory.js
@@ -37,25 +37,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 2.0, 5.0 );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 2.0, 5.0, {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/weibull/test/test.validate.js b/lib/node_modules/@stdlib/random/streams/weibull/test/test.validate.js
index 8ea631fa473b..1920295981ff 100644
--- a/lib/node_modules/@stdlib/random/streams/weibull/test/test.validate.js
+++ b/lib/node_modules/@stdlib/random/streams/weibull/test/test.validate.js
@@ -288,7 +288,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -306,7 +306,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -324,7 +324,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/regexp/decimal-number/test/test.validate.js b/lib/node_modules/@stdlib/regexp/decimal-number/test/test.validate.js
index d1dc24103aa9..981a224f1992 100644
--- a/lib/node_modules/@stdlib/regexp/decimal-number/test/test.validate.js
+++ b/lib/node_modules/@stdlib/regexp/decimal-number/test/test.validate.js
@@ -123,7 +123,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -141,7 +141,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/regexp/eol/test/test.validate.js b/lib/node_modules/@stdlib/regexp/eol/test/test.validate.js
index a36048586224..5a70b4257c58 100644
--- a/lib/node_modules/@stdlib/regexp/eol/test/test.validate.js
+++ b/lib/node_modules/@stdlib/regexp/eol/test/test.validate.js
@@ -123,7 +123,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -141,7 +141,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/regexp/whitespace/test/test.validate.js b/lib/node_modules/@stdlib/regexp/whitespace/test/test.validate.js
index 6de047831ed8..47283f905b0e 100644
--- a/lib/node_modules/@stdlib/regexp/whitespace/test/test.validate.js
+++ b/lib/node_modules/@stdlib/regexp/whitespace/test/test.validate.js
@@ -123,7 +123,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -141,7 +141,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/repl/server/test/test.example.js b/lib/node_modules/@stdlib/repl/server/test/test.example.js
index 62ed10be14de..06aa7aaeda4e 100644
--- a/lib/node_modules/@stdlib/repl/server/test/test.example.js
+++ b/lib/node_modules/@stdlib/repl/server/test/test.example.js
@@ -71,7 +71,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.strictEqual( typeof example( repl() ), 'function', 'returns a function' );
+	t.strictEqual( typeof example( repl() ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/repl/server/test/test.validate.js b/lib/node_modules/@stdlib/repl/server/test/test.validate.js
index 9507113cd81d..c12c0902bf49 100644
--- a/lib/node_modules/@stdlib/repl/server/test/test.validate.js
+++ b/lib/node_modules/@stdlib/repl/server/test/test.validate.js
@@ -65,7 +65,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	options = {};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -83,7 +83,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/simulate/iter/awgn/test/test.js b/lib/node_modules/@stdlib/simulate/iter/awgn/test/test.js
index 9a2178351e5d..a5360b45a6d6 100644
--- a/lib/node_modules/@stdlib/simulate/iter/awgn/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/awgn/test/test.js
@@ -309,9 +309,9 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 	}
 	v = it.next();
 	t.strictEqual( v.value, void 0, 'returns expected value' );
@@ -332,9 +332,9 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 	}
 	v = it.next();
 	t.strictEqual( v.value, void 0, 'returns expected value' );
@@ -372,8 +372,8 @@ tape( 'the function supports returning a seeded iterator protocol-compliant obje
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -414,8 +414,8 @@ tape( 'the function supports returning a seeded iterator protocol-compliant obje
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -442,9 +442,9 @@ tape( 'the function supports providing a pseudorandom number generator for gener
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 	}
 	v = it.next();
 	t.strictEqual( v.value, void 0, 'returns expected value' );
@@ -483,8 +483,8 @@ tape( 'the function supports providing a seeded pseudorandom number generator fo
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -770,11 +770,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterawgn( randu(), 0.2 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -795,11 +795,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterawgn( randu(), 0.2 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -838,7 +838,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/awln/test/test.js b/lib/node_modules/@stdlib/simulate/iter/awln/test/test.js
index 77b0e8b5326b..2964c7d9aa8e 100644
--- a/lib/node_modules/@stdlib/simulate/iter/awln/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/awln/test/test.js
@@ -310,9 +310,9 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 	}
 	v = it.next();
 	t.strictEqual( v.value, void 0, 'returns expected value' );
@@ -333,9 +333,9 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 	}
 	v = it.next();
 	t.strictEqual( v.value, void 0, 'returns expected value' );
@@ -373,8 +373,8 @@ tape( 'the function supports returning a seeded iterator protocol-compliant obje
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -415,8 +415,8 @@ tape( 'the function supports returning a seeded iterator protocol-compliant obje
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -443,9 +443,9 @@ tape( 'the function supports providing a pseudorandom number generator for gener
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 	}
 	v = it.next();
 	t.strictEqual( v.value, void 0, 'returns expected value' );
@@ -489,8 +489,8 @@ tape( 'the function supports providing a seeded pseudorandom number generator fo
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -776,11 +776,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterawun( randu(), 0.2 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -801,11 +801,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterawun( randu(), 0.2 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -844,7 +844,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/awun/test/test.js b/lib/node_modules/@stdlib/simulate/iter/awun/test/test.js
index abcd7c9bd483..de3c3cc10451 100644
--- a/lib/node_modules/@stdlib/simulate/iter/awun/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/awun/test/test.js
@@ -310,9 +310,9 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 	}
 	v = it.next();
 	t.strictEqual( v.value, void 0, 'returns expected value' );
@@ -333,9 +333,9 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 	}
 	v = it.next();
 	t.strictEqual( v.value, void 0, 'returns expected value' );
@@ -373,8 +373,8 @@ tape( 'the function supports returning a seeded iterator protocol-compliant obje
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -415,8 +415,8 @@ tape( 'the function supports returning a seeded iterator protocol-compliant obje
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -443,9 +443,9 @@ tape( 'the function supports providing a pseudorandom number generator for gener
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
 		t.notEqual( v.value, values[ i ], 'does not return original value' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 	}
 	v = it.next();
 	t.strictEqual( v.value, void 0, 'returns expected value' );
@@ -487,8 +487,8 @@ tape( 'the function supports providing a seeded pseudorandom number generator fo
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -774,11 +774,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterawun( randu(), 0.2 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -799,11 +799,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterawun( randu(), 0.2 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -842,7 +842,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/bartlett-hann-pulse/test/test.js b/lib/node_modules/@stdlib/simulate/iter/bartlett-hann-pulse/test/test.js
index c4a106dd12af..2f8187f6c7cf 100644
--- a/lib/node_modules/@stdlib/simulate/iter/bartlett-hann-pulse/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/bartlett-hann-pulse/test/test.js
@@ -655,11 +655,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBartlettHannPulse();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -680,11 +680,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBartlettHannPulse();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -713,7 +713,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/bartlett-hann-pulse/test/test.validate.js b/lib/node_modules/@stdlib/simulate/iter/bartlett-hann-pulse/test/test.validate.js
index 2df3b1339846..30c9ba3c2fd2 100644
--- a/lib/node_modules/@stdlib/simulate/iter/bartlett-hann-pulse/test/test.validate.js
+++ b/lib/node_modules/@stdlib/simulate/iter/bartlett-hann-pulse/test/test.validate.js
@@ -222,7 +222,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -240,7 +240,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/simulate/iter/bartlett-pulse/test/test.js b/lib/node_modules/@stdlib/simulate/iter/bartlett-pulse/test/test.js
index b32755bd9081..e0b30a9efe6d 100644
--- a/lib/node_modules/@stdlib/simulate/iter/bartlett-pulse/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/bartlett-pulse/test/test.js
@@ -653,11 +653,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBartlettPulse();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -678,11 +678,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBartlettPulse();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -711,7 +711,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/bartlett-pulse/test/test.validate.js b/lib/node_modules/@stdlib/simulate/iter/bartlett-pulse/test/test.validate.js
index 2df3b1339846..30c9ba3c2fd2 100644
--- a/lib/node_modules/@stdlib/simulate/iter/bartlett-pulse/test/test.validate.js
+++ b/lib/node_modules/@stdlib/simulate/iter/bartlett-pulse/test/test.validate.js
@@ -222,7 +222,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -240,7 +240,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/simulate/iter/cosine-wave/test/test.js b/lib/node_modules/@stdlib/simulate/iter/cosine-wave/test/test.js
index 73494713522c..be5ccb5cd171 100644
--- a/lib/node_modules/@stdlib/simulate/iter/cosine-wave/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/cosine-wave/test/test.js
@@ -711,11 +711,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCosineWave();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -736,11 +736,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCosineWave();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -769,7 +769,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/cosine-wave/test/test.validate.js b/lib/node_modules/@stdlib/simulate/iter/cosine-wave/test/test.validate.js
index 9f6c5473bf5f..3794d40f2077 100644
--- a/lib/node_modules/@stdlib/simulate/iter/cosine-wave/test/test.validate.js
+++ b/lib/node_modules/@stdlib/simulate/iter/cosine-wave/test/test.validate.js
@@ -189,7 +189,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -207,7 +207,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/simulate/iter/dirac-comb/test/test.js b/lib/node_modules/@stdlib/simulate/iter/dirac-comb/test/test.js
index 46e280784b49..67f13e181e82 100644
--- a/lib/node_modules/@stdlib/simulate/iter/dirac-comb/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/dirac-comb/test/test.js
@@ -571,11 +571,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDiracComb();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -596,11 +596,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDiracComb();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -629,7 +629,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/dirac-comb/test/test.validate.js b/lib/node_modules/@stdlib/simulate/iter/dirac-comb/test/test.validate.js
index 64d966326f19..620fcf519bda 100644
--- a/lib/node_modules/@stdlib/simulate/iter/dirac-comb/test/test.validate.js
+++ b/lib/node_modules/@stdlib/simulate/iter/dirac-comb/test/test.validate.js
@@ -159,7 +159,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -177,7 +177,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/simulate/iter/flat-top-pulse/test/test.js b/lib/node_modules/@stdlib/simulate/iter/flat-top-pulse/test/test.js
index 2f3b2b928029..de2d90976b50 100644
--- a/lib/node_modules/@stdlib/simulate/iter/flat-top-pulse/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/flat-top-pulse/test/test.js
@@ -655,11 +655,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFlatTopPulse();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -680,11 +680,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFlatTopPulse();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -713,7 +713,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/flat-top-pulse/test/test.validate.js b/lib/node_modules/@stdlib/simulate/iter/flat-top-pulse/test/test.validate.js
index 2df3b1339846..30c9ba3c2fd2 100644
--- a/lib/node_modules/@stdlib/simulate/iter/flat-top-pulse/test/test.validate.js
+++ b/lib/node_modules/@stdlib/simulate/iter/flat-top-pulse/test/test.validate.js
@@ -222,7 +222,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -240,7 +240,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/simulate/iter/hann-pulse/test/test.js b/lib/node_modules/@stdlib/simulate/iter/hann-pulse/test/test.js
index 9b40afc8a88b..7fe18890da43 100644
--- a/lib/node_modules/@stdlib/simulate/iter/hann-pulse/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/hann-pulse/test/test.js
@@ -649,11 +649,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterHannPulse();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -674,11 +674,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterHannPulse();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -707,7 +707,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/hann-pulse/test/test.validate.js b/lib/node_modules/@stdlib/simulate/iter/hann-pulse/test/test.validate.js
index 2df3b1339846..30c9ba3c2fd2 100644
--- a/lib/node_modules/@stdlib/simulate/iter/hann-pulse/test/test.validate.js
+++ b/lib/node_modules/@stdlib/simulate/iter/hann-pulse/test/test.validate.js
@@ -222,7 +222,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -240,7 +240,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/simulate/iter/lanczos-pulse/test/test.js b/lib/node_modules/@stdlib/simulate/iter/lanczos-pulse/test/test.js
index f304ebb38e24..7fc27798c4ac 100644
--- a/lib/node_modules/@stdlib/simulate/iter/lanczos-pulse/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/lanczos-pulse/test/test.js
@@ -654,11 +654,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLanczosPulse();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -679,11 +679,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLanczosPulse();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -712,7 +712,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/lanczos-pulse/test/test.validate.js b/lib/node_modules/@stdlib/simulate/iter/lanczos-pulse/test/test.validate.js
index 2df3b1339846..30c9ba3c2fd2 100644
--- a/lib/node_modules/@stdlib/simulate/iter/lanczos-pulse/test/test.validate.js
+++ b/lib/node_modules/@stdlib/simulate/iter/lanczos-pulse/test/test.validate.js
@@ -222,7 +222,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -240,7 +240,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/simulate/iter/periodic-sinc/test/test.js b/lib/node_modules/@stdlib/simulate/iter/periodic-sinc/test/test.js
index 8590efea3225..2a459082265b 100644
--- a/lib/node_modules/@stdlib/simulate/iter/periodic-sinc/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/periodic-sinc/test/test.js
@@ -958,11 +958,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPeriodicSinc( 7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -983,11 +983,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPeriodicSinc( 7 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -1016,7 +1016,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/periodic-sinc/test/test.validate.js b/lib/node_modules/@stdlib/simulate/iter/periodic-sinc/test/test.validate.js
index 9f6c5473bf5f..3794d40f2077 100644
--- a/lib/node_modules/@stdlib/simulate/iter/periodic-sinc/test/test.validate.js
+++ b/lib/node_modules/@stdlib/simulate/iter/periodic-sinc/test/test.validate.js
@@ -189,7 +189,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -207,7 +207,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/simulate/iter/pulse/test/test.js b/lib/node_modules/@stdlib/simulate/iter/pulse/test/test.js
index c051e7db4610..6394dd21dc4b 100644
--- a/lib/node_modules/@stdlib/simulate/iter/pulse/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/pulse/test/test.js
@@ -760,11 +760,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPulse();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -785,11 +785,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPulse();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -818,7 +818,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/pulse/test/test.validate.js b/lib/node_modules/@stdlib/simulate/iter/pulse/test/test.validate.js
index 56ee4e4fda02..35fecf2caf59 100644
--- a/lib/node_modules/@stdlib/simulate/iter/pulse/test/test.validate.js
+++ b/lib/node_modules/@stdlib/simulate/iter/pulse/test/test.validate.js
@@ -249,7 +249,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -267,7 +267,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/simulate/iter/sawtooth-wave/test/test.js b/lib/node_modules/@stdlib/simulate/iter/sawtooth-wave/test/test.js
index 71ed3f374f67..1096dba8cb9c 100644
--- a/lib/node_modules/@stdlib/simulate/iter/sawtooth-wave/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/sawtooth-wave/test/test.js
@@ -720,11 +720,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSawtoothWave();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -745,11 +745,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSawtoothWave();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -778,7 +778,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/sawtooth-wave/test/test.validate.js b/lib/node_modules/@stdlib/simulate/iter/sawtooth-wave/test/test.validate.js
index 9f6c5473bf5f..3794d40f2077 100644
--- a/lib/node_modules/@stdlib/simulate/iter/sawtooth-wave/test/test.validate.js
+++ b/lib/node_modules/@stdlib/simulate/iter/sawtooth-wave/test/test.validate.js
@@ -189,7 +189,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -207,7 +207,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/simulate/iter/sine-wave/test/test.js b/lib/node_modules/@stdlib/simulate/iter/sine-wave/test/test.js
index 20b783e40081..678971c47232 100644
--- a/lib/node_modules/@stdlib/simulate/iter/sine-wave/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/sine-wave/test/test.js
@@ -711,11 +711,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSineWave();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -736,11 +736,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSineWave();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -769,7 +769,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/sine-wave/test/test.validate.js b/lib/node_modules/@stdlib/simulate/iter/sine-wave/test/test.validate.js
index 9f6c5473bf5f..3794d40f2077 100644
--- a/lib/node_modules/@stdlib/simulate/iter/sine-wave/test/test.validate.js
+++ b/lib/node_modules/@stdlib/simulate/iter/sine-wave/test/test.validate.js
@@ -189,7 +189,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -207,7 +207,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/simulate/iter/square-wave/test/test.js b/lib/node_modules/@stdlib/simulate/iter/square-wave/test/test.js
index 8de3ef81509c..96c756e36aa2 100644
--- a/lib/node_modules/@stdlib/simulate/iter/square-wave/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/square-wave/test/test.js
@@ -653,11 +653,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSquareWave();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -678,11 +678,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSquareWave();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -711,7 +711,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/square-wave/test/test.validate.js b/lib/node_modules/@stdlib/simulate/iter/square-wave/test/test.validate.js
index b24ad3026408..54c4d09a0192 100644
--- a/lib/node_modules/@stdlib/simulate/iter/square-wave/test/test.validate.js
+++ b/lib/node_modules/@stdlib/simulate/iter/square-wave/test/test.validate.js
@@ -218,7 +218,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -236,7 +236,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/simulate/iter/triangle-wave/test/test.js b/lib/node_modules/@stdlib/simulate/iter/triangle-wave/test/test.js
index e6b5a9773d47..462c364b61c6 100644
--- a/lib/node_modules/@stdlib/simulate/iter/triangle-wave/test/test.js
+++ b/lib/node_modules/@stdlib/simulate/iter/triangle-wave/test/test.js
@@ -719,11 +719,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTriangleWave();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -744,11 +744,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTriangleWave();
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -777,7 +777,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/simulate/iter/triangle-wave/test/test.validate.js b/lib/node_modules/@stdlib/simulate/iter/triangle-wave/test/test.validate.js
index 9f6c5473bf5f..3794d40f2077 100644
--- a/lib/node_modules/@stdlib/simulate/iter/triangle-wave/test/test.validate.js
+++ b/lib/node_modules/@stdlib/simulate/iter/triangle-wave/test/test.validate.js
@@ -189,7 +189,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -207,7 +207,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/anova1/test/test.validate.js b/lib/node_modules/@stdlib/stats/anova1/test/test.validate.js
index 149b8e79109d..1e1a0c5e6097 100644
--- a/lib/node_modules/@stdlib/stats/anova1/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/anova1/test/test.validate.js
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -118,7 +118,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/bartlett-test/test/test.validate.js b/lib/node_modules/@stdlib/stats/bartlett-test/test/test.validate.js
index fe14730a1a64..cf2f735570f0 100644
--- a/lib/node_modules/@stdlib/stats/bartlett-test/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/bartlett-test/test/test.validate.js
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -145,7 +145,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.factory.js
index bc2ac4671ac8..c6745171eb58 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.factory.js
index e71b30a9d75c..c289c52ae961 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.factory.js
index c9e469f5833d..5909c14bda97 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.factory.js
index dcc3e007a7c4..2a25eb2e508b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.factory.js
index 317bdf42ab72..eea82f236e93 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.factory.js
index 7a5012cd9acb..8537e44e8446 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.factory.js
index 74eddb39d37b..bb624320107d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.5 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.factory.js
index aee3a199cb45..9fc43dc70666 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 0.5 );
-	t.strictEqual( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.factory.js
index 6b04ad449078..310e431b841a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.factory.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.factory.js
index 423abd669f4b..92a277abf8bd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.factory.js
index 1ffd365dc243..a6f04e2013d8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/logcdf/test/test.factory.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.factory.js
index c58378158a78..67bfba14116b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/logpdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 1.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.factory.js
index 831497a64b7b..953ed8f356c2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.factory.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.factory.js
index d6c8f0159a36..d10d3cbe1e2c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.factory.js
index f4ab31b04288..67692c858654 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.factory.js
index 5aea1721e7b9..35689cc7692f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.factory.js
index b5b23d5d9b8d..1b77359f696c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.factory.js
index 1905999382c8..dfdd21d01249 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 1.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.factory.js
index bef9663d88d9..8d8461cb1edf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.factory.js
index 5fd1b2250436..5cbaf9c70db1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.factory.js
index f0de435f9626..f9e920be3eef 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/cdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.factory.js
index da8eb599e364..2268ac0cf959 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/logpmf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 20, 0.5 );
-	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.factory.js
index 34b7b260c5f4..cbef059dd300 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.factory.js
index e2c7db36a4f9..d69ecf65acce 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 20, 0.5 );
-	t.strictEqual( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.factory.js
index f1f3af8ebd63..03db4189fcda 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.factory.js
index 02e3520245d1..74fb3bd86055 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.factory.js
index 1f067868c0ae..b62f30743e22 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/pdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.factory.js
index 5c17d8b60b75..e73e8001abdc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/quantile/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.factory.js
index ae88da43f6dd..b1327ce0675b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.factory.js
index 422111f3fae0..fdf187811e00 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.factory.js
index b702a3d2c04c..75a99feb9f62 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.factory.js
index 5cd06f123d48..87a331805e3d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.factory.js
index aa35d8774503..2a8374c744a5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.factory.js
index 9b4a79b2d762..8afd21ed9101 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.factory.js
index 04ae13e06c3e..c6e3b1af97d1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.factory.js
index a5e4fab68114..3ba3188fbc0c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.factory.js
index 590471a15cbf..771dfcb501d0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/quantile/test/test.factory.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.factory.js
index 59c04a21d0ac..6231de748b9a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.factory.js
index 678cf77c37fe..0c291c15264c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/logpdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.factory.js
index 9c996cf207cb..9c6d8f19ba49 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/mgf/test/test.factory.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.factory.js
index 9515601e018b..86e3bb36002b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/pdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.factory.js
index 590471a15cbf..771dfcb501d0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/quantile/test/test.factory.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.factory.js
index c1dfd6080877..6d9371eb5963 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.factory.js
index b46cb94e4c99..eb1902ef9ae9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.factory.js
index 9eb07299a9e8..2620c0694e1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.factory.js
index c2d549a1d36b..40fd3c3d0ed8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/test/test.factory.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.factory.js
index 9950382827b4..002d5759b617 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.factory.js
index d36b984bdc32..86651fc6c8be 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.factory.js
index 2ec790549299..ecd1293b6fc7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.factory.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.factory.js
index 0e272162bf14..f73d32d01042 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.factory.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.factory.js
index 5d1603782e71..34412a563a23 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.factory.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.factory.js
index ef5cec7f33ad..58e233664343 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.factory.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 1.0 );
-	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.factory.js
index 0bb2314bbf51..afffccacfad5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.factory.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.factory.js
index 8084203757ae..1d4422dc44dd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.factory.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.factory.js
index bab65c20d3c9..4e4690606e0e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.factory.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 1.0 );
-	t.strictEqual( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.factory.js
index 085467d13359..e74331855274 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.factory.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.factory.js
index ab716e24f492..ba6b1d257a44 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0, 1 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.factory.js
index 826dd0c2bb12..684934cdf76d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0, 1 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.factory.js
index 73f768836a92..fadbd13e5dbc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 0, 1 );
-	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.factory.js
index b9833156afc4..d5f243886040 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.factory.js
index 7ab50b2b2561..4a773c80d7cf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.factory.js
index 435d4d9eb400..a4a17c8b8e77 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0, 1 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.factory.js
index 177fdf594fa2..45afaed7ac5d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.factory.js
index d52b463fc595..2219479ad9b8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.factory.js
index 4e01cb893e44..4eae97c7a0a4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.factory.js
index f807980159d8..7b857a2953a5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.factory.js
index 7295b4a9fadc..6cfc166b5714 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.factory.js
index cb7da37a1b76..91f536c33802 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.factory.js
index 0e378ae2a660..9cb875c3f71b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.factory.js
index 27d7badf525c..68e1b2a60e25 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.factory.js
index 1699c7cc5187..2f39f1de3c67 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.factory.js
index b4465105c236..cd24c4ef09bc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.factory.js
index 15fb382b43e0..b44fd3126b90 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.factory.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.factory.js
index de225f39cd85..0c796959d197 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.factory.js
index e74ba90e62ee..9cda45efb265 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.factory.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.factory.js
index 70d38eaf41cc..6f820dee946e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.factory.js
index a1dd61531273..9068e3b1aa17 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0, 1.0, 1.0, 0.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.factory.js
index 7872aa736e5e..532dc3f81fbe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 1.0, 1.0, 1.0, 0.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.factory.js
index 99df70505d53..325cb5856664 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 1.0, 1.0, 1.0, 0.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.factory.js
index 87bf4aaadf4a..444e8dd43396 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 1.0, 1.0, 1.0, 0.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.factory.js
index 127f03c7b21a..425104fb0bfb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 1.0, 1.0, 1.0, 0.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -119,9 +119,9 @@ tape( 'if provided a nonpositive `s`, the created function always returns `NaN`'
 tape( 'the created function returns `NaN` if provided a number outside `[0,1]`', function test( t ) {
 	var quantile = factory( 1.0, 1.0, 0.0 );
 	var y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.factory.js
index 141a9da142c3..e03b4c6bbc0e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.factory.js
index 5a140270645c..a5efb6f9c47b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.factory.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.factory.js
index 506649711f59..2787c714575c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.factory.js
index 7aba3afa4ba4..d0005ba7d6e6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.factory.js
index 388f2c7efd8f..efe17e9c984f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.factory.js
index 14d80a0e8bd9..2e98ac4fb888 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.factory.js
index 7a5012cd9acb..8537e44e8446 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.factory.js
index 9558bde2eb30..e562b39674f5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.5 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.factory.js
index 686213e5944b..e01e4c1bf28d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 0.5 );
-	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.factory.js
index e4208abdbfaf..031a169df58b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.5 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.factory.js
index aee3a199cb45..9fc43dc70666 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 0.5 );
-	t.strictEqual( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.factory.js
index 2491b0f54f33..e137afa4e493 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.factory.js
index d5aab25a5bc4..50d0979c0919 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.factory.js
index af1381f9674c..1971ad9ce9ed 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.factory.js
index da5f176a2acc..0cb59f5f5bf7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.factory.js
index 444395b9ee9a..a2f56e0cf441 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.factory.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -138,7 +138,7 @@ tape( 'the created function evaluates the mgf', function test( t ) {
 	for ( i = 0; i < 100; i++ ) {
 		x = randu() * (1/beta);
 		y = mgf( x );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.factory.js
index 39f0113cd77b..2208cb1b8fcc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.factory.js
index 844b07ce6cd4..208937c97885 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.factory.js
index 8ec04df4b370..0119e4e5edb7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 20, 20, 10 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.factory.js
index eae97b16ef54..23344fd7b569 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/logpmf/test/test.factory.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 20, 20, 10 );
-	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.factory.js
index 99590bcc39c7..ac80c0737969 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/pmf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 20, 20, 10 );
-	t.strictEqual( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.factory.js
index 6616ec6a50ad..2a5535d963b6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.factory.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 4, 4, 2 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.factory.js
index a920478261ce..9e289c166e10 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.factory.js
index ed39e3495ec5..165e659f50f9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.factory.js
index 42898bde1aa7..35f919bf27fa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.factory.js
index 02ba12e5541b..3253e9caf32e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.factory.js
index 83fb824e52a3..9cabe854a4a0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.factory.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -201,7 +201,7 @@ tape( 'the returned function evaluates the cdf of a Kumaraswamy\'s double bounde
 	for ( i = 0; i < 100; i++ ) {
 		x = randu();
 		y = cdf( x, a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.factory.js
index 41565d56cf7d..93c1358ee9e1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.factory.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -201,7 +201,7 @@ tape( 'the returned function evaluates the logcdf of a Kumaraswamy\'s double bou
 	for ( i = 0; i < 100; i++ ) {
 		x = randu();
 		y = logcdf( x, a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.factory.js
index b023e6dd7d47..d07b5f7bdf53 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.factory.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.factory.js
index b88ae463d5d2..0bcd361d3e96 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.factory.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -201,7 +201,7 @@ tape( 'the returned function evaluates the pdf of a Kumaraswamy\'s double bounde
 	for ( i = 0; i < 100; i++ ) {
 		x = randu();
 		y = pdf( x, a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.factory.js
index 5eb5ffb8e608..e5357b549967 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.factory.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -158,7 +158,7 @@ tape( 'the returned function evaluates the quantile function of a Kumaraswamy\'s
 	for ( i = 0; i < 100; i++ ) {
 		p = randu();
 		y = quantile( p, a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.factory.js
index 2c9ba882dc64..0c11508b1416 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.factory.js
index ceccc7e0b6f6..bbeabb98c1d7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.factory.js
index 1f47e8cc4a9a..ce6560c33585 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.factory.js
index a175636c04a5..59211bb54908 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.factory.js
index 564cdb38050e..5f54340cfafb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.factory.js
index a805fa1da050..30e7ff468661 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.factory.js
index 860fab596992..2b846654c6cc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.factory.js
index 84e3e01f1d29..bf4146dcb038 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.factory.js
index 8eee05bb1d45..1182a7a0b8da 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.factory.js
index 5a6a202c8066..5904d1dc4d93 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.factory.js
index beac6e18a43e..8a5f932a488b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.factory.js
index b470cc15d12c..1be46a3b91f6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.factory.js
index 793bfc6920e6..273e96b0dbfa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.factory.js
index f51a183932e9..ab5bccb74930 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.factory.js
index 379a17d26f8e..cc3944a44dd3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.factory.js
index c738454bac49..4ba57a09c396 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.factory.js
index 664e77ead56d..f1af640fbd7b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.factory.js
index 58034af09871..80fc1753a0a3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.factory.js
index 58d6edc6f7e3..c9b0a242c862 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.factory.js
index 9b4d4d4cdc87..eaaf51a13ac7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.factory.js
index 75feb041aefc..1ac5b84749cc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.factory.js
index 61fc19c4bd4e..2e0ff0fbd2e8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.factory.js
index 195a52b2ad80..8bfdde6babf0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.factory.js
index 2f7d11d425b4..22e894ccbbbe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 20, 0.5 );
-	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.factory.js
index cc40f75d28e3..ff9a87d68254 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.factory.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -150,7 +150,7 @@ tape( 'the created function evaluates the mgf', function test( t ) {
 	for ( i = 0; i < 100; i++ ) {
 		x = ln( p ) - randu();
 		y = mgf( x );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.factory.js
index 41176c0529ff..1bee984180a1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 20, 0.5 );
-	t.strictEqual( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.factory.js
index 4bf6e4059e01..df6bcbc9f524 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 20.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.factory.js
index 464c087cac1c..e8c24a364af9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.factory.js
index 58d6edc6f7e3..c9b0a242c862 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.factory.js
index 5e365d23c288..e242b85323a5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.factory.js
index 0c1d4f0e1f04..d022af5f9170 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.factory.js
index 7359da581c1b..4f7c89df81b2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.factory.js
index ef51b6251811..a112506acd82 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.factory.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.factory.js
index b146c3516019..befe5296281a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.factory.js
index 02d5cb836eee..103f6aa1e1e7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.factory.js
index 479bd1a3ccfb..eeab03623d46 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.factory.js
index 536d909adc18..ea375fef6705 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.factory.js
index 9aa1c535c6fd..5622b5a9c6a5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 1.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.factory.js
index 815f7f933f3c..9b468c202491 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.factory.js
index 5d0f4a6929b8..d75cb2f99970 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/logcdf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.5 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.factory.js
index acd0e81f120d..0a740fbc2b5b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 0.5 );
-	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.factory.js
index 022cb24b1b3d..1339b21cc7af 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/mgf/test/test.factory.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.5 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.factory.js
index 61ee4ba83bf6..255fd48aa4ad 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/pmf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 0.5 );
-	t.strictEqual( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.factory.js
index 5970210985ec..44427a1e4fc6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/quantile/test/test.factory.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.factory.js
index 7403dac745e6..316a154db1bc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.factory.js
index 9d42a44a5f58..76dbec3e6192 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpmf = factory( 0.5 );
-	t.strictEqual( typeof logpmf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.factory.js
index 07eb209bb66b..a3d9160c2de7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.factory.js
index 5ae219cffbaf..87b6565d31fa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pmf = factory( 0.5 );
-	t.strictEqual( typeof pmf, 'function', 'returns a function' );
+	t.strictEqual( typeof pmf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.factory.js
index 62229bde2604..8e41d03be064 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.factory.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.factory.js
index 7b1d318e654d..ceff6b646142 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.factory.js
index ade770b89247..c0713030a3b1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.factory.js
index 4371ee9c7572..07a6cbb0277c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.factory.js
index abc68a8cae91..9b5fbbd32677 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.factory.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 2.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -87,7 +87,7 @@ tape( 'the created function evaluates the mgf', function test( t ) {
 	for ( i = 0; i < 100; i++ ) {
 		x = randu();
 		y = mgf( x );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.factory.js
index 5eae03a27332..6ee443197da4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.factory.js
index b3132862e666..817f289e4108 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.factory.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.factory.js
index a413976c9655..1d92f6558bf0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.factory.js
index 181e6adbfb69..c52e1bee9b1e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 3.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.factory.js
index 52ad8dada989..ba218baf3747 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.factory.js
index 0fc2e148c619..53b17dd71073 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.factory.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 2.0, 2.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.factory.js
index ffcd3f50150b..c2fc70b29a66 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.factory.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 2.0, 2.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.factory.js
index a26c3edc45c2..efe3bbdee9dc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.factory.js
index 069f255808ae..106df4154f20 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.factory.js
@@ -48,7 +48,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.factory.js
index 67c05769aa2e..9c6538a614ba 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.factory.js
index 781e1d3c2645..3758ace40e08 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.factory.js
index d424bd3ff391..3fed6d0d5797 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.factory.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.factory.js
index e22ed4c14099..1d81fa5a1075 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0, 0.5 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.factory.js
index cd95c5701670..43dfb36cb0d9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.factory.js
index 93d6ebcecb6d..89ab855b91dd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.factory.js
index 8a395901a43b..6821d7277378 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.factory.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.factory.js
index bd90577eb4e0..a0014f160a0d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.factory.js
index a4dff7459e1e..b88dd01b86a6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.factory.js
index 8017b7d7c4f6..61338c1ab5cd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.factory.js
index af689f42e6c1..8e14a89b12ea 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.factory.js
index c9e469f5833d..5909c14bda97 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.factory.js
index 5346f14fee5c..14ce7bf627df 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.factory.js
index dcc3e007a7c4..2a25eb2e508b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.factory.js
index 317bdf42ab72..eea82f236e93 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.factory.js
index 7794cb571dbe..3c43150c63c9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var cdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof cdf, 'function', 'returns a function' );
+	t.strictEqual( typeof cdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.factory.js
index 4228896496d7..07ae6d1a6aec 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logcdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logcdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logcdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.factory.js
index 726176b2675a..e72682e697c6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.factory.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var logpdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof logpdf, 'function', 'returns a function' );
+	t.strictEqual( typeof logpdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.factory.js
index 0e59ce10d62d..dbcc55334efe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.factory.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var mgf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof mgf, 'function', 'returns a function' );
+	t.strictEqual( typeof mgf, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -153,7 +153,7 @@ tape( 'the created function evaluates the mgf', function test( t ) {
 	for ( i = 0; i < 100; i++ ) {
 		x = randu();
 		y = mgf( x );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.factory.js
index ac79a0fc38e3..1dd7eac2d795 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var pdf = factory( 0.0, 1.0 );
-	t.strictEqual( typeof pdf, 'function', 'returns a function' );
+	t.strictEqual( typeof pdf, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.factory.js
index bb14a4dfc9d9..25f349c60947 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.factory.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function', function test( t ) {
 	var quantile = factory( 0.0, 1.0 );
-	t.strictEqual( typeof quantile, 'function', 'returns a function' );
+	t.strictEqual( typeof quantile, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/binomial-test/test/test.validate.js b/lib/node_modules/@stdlib/stats/binomial-test/test/test.validate.js
index f41824c6e498..3e08627cda87 100644
--- a/lib/node_modules/@stdlib/stats/binomial-test/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/binomial-test/test/test.validate.js
@@ -151,7 +151,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -172,7 +172,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/chi2gof/test/test.validate.js b/lib/node_modules/@stdlib/stats/chi2gof/test/test.validate.js
index 75adb7315963..d8278d7171bc 100644
--- a/lib/node_modules/@stdlib/stats/chi2gof/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/chi2gof/test/test.validate.js
@@ -183,7 +183,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -204,7 +204,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/chi2test/test/test.validate.js b/lib/node_modules/@stdlib/stats/chi2test/test/test.validate.js
index 675d5339c930..c0503354489e 100644
--- a/lib/node_modules/@stdlib/stats/chi2test/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/chi2test/test/test.validate.js
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -145,7 +145,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/fligner-test/test/test.validate.js b/lib/node_modules/@stdlib/stats/fligner-test/test/test.validate.js
index fe14730a1a64..cf2f735570f0 100644
--- a/lib/node_modules/@stdlib/stats/fligner-test/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/fligner-test/test/test.validate.js
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -145,7 +145,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/apcorr/test/test.js b/lib/node_modules/@stdlib/stats/incr/apcorr/test/test.js
index f884f65b3109..e569e0e6aa3c 100644
--- a/lib/node_modules/@stdlib/stats/incr/apcorr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/apcorr/test/test.js
@@ -88,12 +88,12 @@ tape( 'the function throws an error if provided a non-numeric value for the seco
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrapcorr(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrapcorr(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.strictEqual( typeof incrapcorr( 3.0, -5.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrapcorr( 3.0, -5.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -214,7 +214,7 @@ tape( 'the sample absolute correlation coefficient is `null` until at least 1 da
 	acc = incrapcorr();
 
 	v = acc();
-	t.strictEqual( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns expected value' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
@@ -232,7 +232,7 @@ tape( 'the sample absolute correlation coefficient is `null` until at least 1 da
 	acc = incrapcorr( 3.0, -5.0 );
 
 	v = acc();
-	t.strictEqual( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns expected value' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
diff --git a/lib/node_modules/@stdlib/stats/incr/count/test/test.js b/lib/node_modules/@stdlib/stats/incr/count/test/test.js
index 8dc8377de0b3..3ef10f2a9898 100644
--- a/lib/node_modules/@stdlib/stats/incr/count/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/count/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrcount(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcount(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/covariance/test/test.js b/lib/node_modules/@stdlib/stats/incr/covariance/test/test.js
index 608654c94258..6a7c56b0caf1 100644
--- a/lib/node_modules/@stdlib/stats/incr/covariance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/covariance/test/test.js
@@ -88,12 +88,12 @@ tape( 'the function throws an error if provided a non-numeric value for the seco
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrcovariance(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcovariance(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.strictEqual( typeof incrcovariance( 3.0, -5.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcovariance( 3.0, -5.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -214,7 +214,7 @@ tape( 'the sample covariance is `null` until at least 1 datum has been provided
 	acc = incrcovariance();
 
 	v = acc();
-	t.strictEqual( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns expected value' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
@@ -232,7 +232,7 @@ tape( 'the sample covariance is `null` until at least 1 datum has been provided
 	acc = incrcovariance( 3.0, -5.0 );
 
 	v = acc();
-	t.strictEqual( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns expected value' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
diff --git a/lib/node_modules/@stdlib/stats/incr/covmat/test/test.js b/lib/node_modules/@stdlib/stats/incr/covmat/test/test.js
index b2ffc07c166f..ef533c2094de 100644
--- a/lib/node_modules/@stdlib/stats/incr/covmat/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/covmat/test/test.js
@@ -234,7 +234,7 @@ tape( 'the function throws an error if the number of known means does not match
 });
 
 tape( 'the function returns an accumulator function (order)', function test( t ) {
-	t.strictEqual( typeof incrcovmat( 2 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcovmat( 2 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -249,7 +249,7 @@ tape( 'the function returns an accumulator function (covariance matrix)', functi
 	strides = [ 2, 1 ];
 	cov = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.strictEqual( typeof incrcovmat( cov ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcovmat( cov ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -264,7 +264,7 @@ tape( 'the function returns an accumulator function (order; known means)', funct
 	strides = [ 1 ];
 	means = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.strictEqual( typeof incrcovmat( 2, means ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcovmat( 2, means ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -285,7 +285,7 @@ tape( 'the function returns an accumulator function (covariance matrix; known me
 	strides = [ 1 ];
 	means = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.strictEqual( typeof incrcovmat( cov, means ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcovmat( cov, means ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/cv/test/test.js b/lib/node_modules/@stdlib/stats/incr/cv/test/test.js
index 03ba0988a1bc..6d7d534166cf 100644
--- a/lib/node_modules/@stdlib/stats/incr/cv/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/cv/test/test.js
@@ -36,12 +36,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrcv(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcv(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.strictEqual( typeof incrcv( 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrcv( 3.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -164,7 +164,7 @@ tape( 'the accumulated value is `null` until at least 1 datum has been provided
 	acc = incrcv();
 
 	cv = acc();
-	t.strictEqual( cv, null, 'returns null' );
+	t.strictEqual( cv, null, 'returns expected value' );
 
 	cv = acc( 3.0 );
 	t.notEqual( cv, null, 'does not return null' );
@@ -182,7 +182,7 @@ tape( 'the accumulated value is `null` until at least 1 datum has been provided
 	acc = incrcv( 3.0 );
 
 	cv = acc();
-	t.strictEqual( cv, null, 'returns null' );
+	t.strictEqual( cv, null, 'returns expected value' );
 
 	cv = acc( 3.0 );
 	t.notEqual( cv, null, 'does not return null' );
diff --git a/lib/node_modules/@stdlib/stats/incr/ewmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/ewmean/test/test.js
index b578e2a0e84c..b5363725bdb2 100644
--- a/lib/node_modules/@stdlib/stats/incr/ewmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/ewmean/test/test.js
@@ -86,7 +86,7 @@ tape( 'the function throws an error if provided a nonnegative number which does
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof increwmean( 0.5 ), 'function', 'returns a function' );
+	t.strictEqual( typeof increwmean( 0.5 ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/ewstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/ewstdev/test/test.js
index 570f98c0e1f7..84440f6906a1 100644
--- a/lib/node_modules/@stdlib/stats/incr/ewstdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/ewstdev/test/test.js
@@ -88,7 +88,7 @@ tape( 'the function throws an error if provided a nonnegative number which does
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof increwstdev( 0.5 ), 'function', 'returns a function' );
+	t.strictEqual( typeof increwstdev( 0.5 ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/ewvariance/test/test.js b/lib/node_modules/@stdlib/stats/incr/ewvariance/test/test.js
index af7c264638eb..4a29840a0acd 100644
--- a/lib/node_modules/@stdlib/stats/incr/ewvariance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/ewvariance/test/test.js
@@ -87,7 +87,7 @@ tape( 'the function throws an error if provided a nonnegative number which does
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof increwvariance( 0.5 ), 'function', 'returns a function' );
+	t.strictEqual( typeof increwvariance( 0.5 ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/gmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/gmean/test/test.js
index bb7629d542f2..c42784903bd2 100644
--- a/lib/node_modules/@stdlib/stats/incr/gmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/gmean/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrgmean(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrgmean(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/grubbs/test/test.js b/lib/node_modules/@stdlib/stats/incr/grubbs/test/test.js
index 94fcfa8468b4..76d5145ce4ad 100644
--- a/lib/node_modules/@stdlib/stats/incr/grubbs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/grubbs/test/test.js
@@ -103,12 +103,12 @@ tape( 'the function throws an error if provided an invalid option', function tes
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrgrubbs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrgrubbs(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (options)', function test( t ) {
-	t.strictEqual( typeof incrgrubbs( {} ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrgrubbs( {} ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/hmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/hmean/test/test.js
index 5b124c1f5655..d4737945320d 100644
--- a/lib/node_modules/@stdlib/stats/incr/hmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/hmean/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrhmean(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrhmean(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/incr/kurtosis/test/test.js
index 96b7435326c8..10b7b2053d16 100644
--- a/lib/node_modules/@stdlib/stats/incr/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/kurtosis/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrkurtosis(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrkurtosis(), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -66,7 +66,7 @@ tape( 'the accumulator function incrementally computes a corrected sample excess
 	for ( i = 0; i < data.length; i++ ) {
 		actual = acc( data[ i ] );
 		if ( expected[i] === null ) {
-			t.strictEqual( actual, null, 'returns null' );
+			t.strictEqual( actual, null, 'returns expected value' );
 		} else {
 			delta = abs( actual - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
@@ -99,16 +99,16 @@ tape( 'the corrected sample excess kurtosis is `null` until at least 4 datums ha
 	acc = incrkurtosis();
 
 	out = acc();
-	t.strictEqual( out, null, 'returns null' );
+	t.strictEqual( out, null, 'returns expected value' );
 
 	out = acc( 2.0 );
-	t.strictEqual( out, null, 'returns null' );
+	t.strictEqual( out, null, 'returns expected value' );
 
 	out = acc( 8.0 );
-	t.strictEqual( out, null, 'returns null' );
+	t.strictEqual( out, null, 'returns expected value' );
 
 	out = acc( -4.0 );
-	t.strictEqual( out, null, 'returns null' );
+	t.strictEqual( out, null, 'returns expected value' );
 
 	out = acc( 3.0 );
 	t.notEqual( out, null, 'does not return null' );
diff --git a/lib/node_modules/@stdlib/stats/incr/maape/test/test.js b/lib/node_modules/@stdlib/stats/incr/maape/test/test.js
index 6bdcf47286ef..9ebba8572200 100644
--- a/lib/node_modules/@stdlib/stats/incr/maape/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/maape/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmaape(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmaape(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mae/test/test.js b/lib/node_modules/@stdlib/stats/incr/mae/test/test.js
index 16657f9dd859..abbf2d3a32eb 100644
--- a/lib/node_modules/@stdlib/stats/incr/mae/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mae/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmae(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmae(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mapcorr/test/test.js b/lib/node_modules/@stdlib/stats/incr/mapcorr/test/test.js
index f92f213d983c..9e082a2db32e 100644
--- a/lib/node_modules/@stdlib/stats/incr/mapcorr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mapcorr/test/test.js
@@ -317,12 +317,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmapcorr( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmapcorr( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.strictEqual( typeof incrmapcorr( 3, 3.0, 3.14 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmapcorr( 3, 3.0, 3.14 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -517,13 +517,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmapcorr( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known means)', function test( t ) {
 	var acc = incrmapcorr( 3, 3.0, 3.14 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mape/test/test.js b/lib/node_modules/@stdlib/stats/incr/mape/test/test.js
index a6a5b3002329..8dd864bc5f14 100644
--- a/lib/node_modules/@stdlib/stats/incr/mape/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mape/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmape(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmape(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/max/test/test.js b/lib/node_modules/@stdlib/stats/incr/max/test/test.js
index 35fbc38acff3..a1f0c4f0147d 100644
--- a/lib/node_modules/@stdlib/stats/incr/max/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/max/test/test.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmax(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmax(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'if not provided any values, the initial returned maximum value is `null`', function test( t ) {
 	var acc = incrmax();
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/maxabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/maxabs/test/test.js
index 66a1ebff31e3..bb9e904e32cf 100644
--- a/lib/node_modules/@stdlib/stats/incr/maxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/maxabs/test/test.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmaxabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmaxabs(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'if not provided any values, the initial returned maximum absolute value is `null`', function test( t ) {
 	var acc = incrmaxabs();
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mcovariance/test/test.js b/lib/node_modules/@stdlib/stats/incr/mcovariance/test/test.js
index 8f4688a5d9a9..4c9e94d726a1 100644
--- a/lib/node_modules/@stdlib/stats/incr/mcovariance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mcovariance/test/test.js
@@ -251,12 +251,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmcovariance( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmcovariance( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.strictEqual( typeof incrmcovariance( 3, 3.0, 3.14 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmcovariance( 3, 3.0, 3.14 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -451,13 +451,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmcovariance( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known means)', function test( t ) {
 	var acc = incrmcovariance( 3, 3.0, 3.14 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mcv/test/test.js b/lib/node_modules/@stdlib/stats/incr/mcv/test/test.js
index 85088cd744ab..8d12f12eed63 100644
--- a/lib/node_modules/@stdlib/stats/incr/mcv/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mcv/test/test.js
@@ -126,12 +126,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmcv( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmcv( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.strictEqual( typeof incrmcv( 3, 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmcv( 3, 3.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -250,13 +250,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmcv( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known mean)', function test( t ) {
 	var acc = incrmcv( 3, 3.0 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mda/test/test.js b/lib/node_modules/@stdlib/stats/incr/mda/test/test.js
index 264347586191..c7137d35bd52 100644
--- a/lib/node_modules/@stdlib/stats/incr/mda/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mda/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmda(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmda(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/me/test/test.js b/lib/node_modules/@stdlib/stats/incr/me/test/test.js
index 3e03a3da2e56..7cec6ec6fb0c 100644
--- a/lib/node_modules/@stdlib/stats/incr/me/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/me/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrme(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrme(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mean/test/test.js b/lib/node_modules/@stdlib/stats/incr/mean/test/test.js
index 774d5d5a68e5..d3dcd26b7f68 100644
--- a/lib/node_modules/@stdlib/stats/incr/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mean/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmean(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmean(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/meanabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/meanabs/test/test.js
index 4b9aa0f7bc61..9a83724ec7d2 100644
--- a/lib/node_modules/@stdlib/stats/incr/meanabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/meanabs/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmeanabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmeanabs(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/meanabs2/test/test.js b/lib/node_modules/@stdlib/stats/incr/meanabs2/test/test.js
index 70470c79e2a1..530ac2d8233e 100644
--- a/lib/node_modules/@stdlib/stats/incr/meanabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/meanabs2/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmeanabs2(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmeanabs2(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/meanstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/meanstdev/test/test.js
index 26f2d2cc4874..bd383f93168b 100644
--- a/lib/node_modules/@stdlib/stats/incr/meanstdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/meanstdev/test/test.js
@@ -63,12 +63,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmeanstdev(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmeanstdev(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.strictEqual( typeof incrmeanstdev( [ 0.0, 0.0 ] ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmeanstdev( [ 0.0, 0.0 ] ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -150,9 +150,9 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmeanstdev();
-	t.strictEqual( acc(), null, 'returns null' );
-	t.strictEqual( acc(), null, 'returns null' );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -163,7 +163,7 @@ tape( 'the sample standard deviation is `0` until at least 2 datums have been pr
 	acc = incrmeanstdev();
 
 	ms = acc();
-	t.strictEqual( ms, null, 'returns null' );
+	t.strictEqual( ms, null, 'returns expected value' );
 
 	ms = acc( 3.0 );
 	t.strictEqual( ms[ 1 ], 0.0, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/stats/incr/meanvar/test/test.js b/lib/node_modules/@stdlib/stats/incr/meanvar/test/test.js
index a3c9b59f740c..4a7f52d6819e 100644
--- a/lib/node_modules/@stdlib/stats/incr/meanvar/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/meanvar/test/test.js
@@ -62,12 +62,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmeanvar(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmeanvar(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.strictEqual( typeof incrmeanvar( [ 0.0, 0.0 ] ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmeanvar( [ 0.0, 0.0 ] ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -149,9 +149,9 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmeanvar();
-	t.strictEqual( acc(), null, 'returns null' );
-	t.strictEqual( acc(), null, 'returns null' );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -162,7 +162,7 @@ tape( 'the sample variance is `0` until at least 2 datums have been provided', f
 	acc = incrmeanvar();
 
 	mv = acc();
-	t.strictEqual( mv, null, 'returns null' );
+	t.strictEqual( mv, null, 'returns expected value' );
 
 	mv = acc( 3.0 );
 	t.strictEqual( mv[ 1 ], 0.0, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/stats/incr/mgmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/mgmean/test/test.js
index b4c9eb22edcc..bed308f83354 100644
--- a/lib/node_modules/@stdlib/stats/incr/mgmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mgmean/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmgmean( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmgmean( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -135,7 +135,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmgmean( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.js b/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.js
index dc91dfd6d32d..5d0b0b3d22ec 100644
--- a/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.js
@@ -203,12 +203,12 @@ tape( 'the function throws an error if provided an invalid option', function tes
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmgrubbs( 20 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmgrubbs( 20 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (options)', function test( t ) {
-	t.strictEqual( typeof incrmgrubbs( 20, {} ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmgrubbs( 20, {} ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.meanstdev.js b/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.meanstdev.js
index 6156ce4836fd..c75987b8398c 100644
--- a/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.meanstdev.js
+++ b/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.meanstdev.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmeanstdev( [ 0.0, 0.0 ], 3, [ 0.0, 0.0, 0.0 ] ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanstdev( [ 0.0, 0.0 ], 3, [ 0.0, 0.0, 0.0 ] ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.minmax.js b/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.minmax.js
index 9f3be5197acf..37e546c6ce79 100644
--- a/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.minmax.js
+++ b/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.minmax.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmminmax( [ 0.0, 0.0 ], 3, [ 0.0, 0.0, 0.0 ] ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmminmax( [ 0.0, 0.0 ], 3, [ 0.0, 0.0, 0.0 ] ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mhmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/mhmean/test/test.js
index cf84bf440266..338377e7ad5d 100644
--- a/lib/node_modules/@stdlib/stats/incr/mhmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mhmean/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmhmean( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmhmean( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -135,7 +135,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmhmean( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/midrange/test/test.js b/lib/node_modules/@stdlib/stats/incr/midrange/test/test.js
index d6584327f899..1731990b736c 100644
--- a/lib/node_modules/@stdlib/stats/incr/midrange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/midrange/test/test.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmidrange(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmidrange(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'if not provided any values, the initial returned mid-range is `null`', function test( t ) {
 	var acc = incrmidrange();
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/min/test/test.js b/lib/node_modules/@stdlib/stats/incr/min/test/test.js
index da5e2502a192..5207b4690510 100644
--- a/lib/node_modules/@stdlib/stats/incr/min/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/min/test/test.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmin(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmin(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'if not provided any values, the initial returned minimum value is `null`', function test( t ) {
 	var acc = incrmin();
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/minabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/minabs/test/test.js
index a4e992b23de7..d0ea2cb8f40d 100644
--- a/lib/node_modules/@stdlib/stats/incr/minabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/minabs/test/test.js
@@ -37,13 +37,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrminabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrminabs(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'if not provided any values, the initial returned minimum absolute value is `null`', function test( t ) {
 	var acc = incrminabs();
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/minmax/test/test.js b/lib/node_modules/@stdlib/stats/incr/minmax/test/test.js
index d0f71992adf0..9a512bfadc3e 100644
--- a/lib/node_modules/@stdlib/stats/incr/minmax/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/minmax/test/test.js
@@ -64,12 +64,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrminmax(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrminmax(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.strictEqual( typeof incrminmax( [ 0.0, 0.0 ] ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrminmax( [ 0.0, 0.0 ] ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -167,7 +167,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrminmax();
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/minmaxabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/minmaxabs/test/test.js
index 033bbc3c3bff..fecf2fcbc9b2 100644
--- a/lib/node_modules/@stdlib/stats/incr/minmaxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/minmaxabs/test/test.js
@@ -63,12 +63,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrminmaxabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrminmaxabs(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.strictEqual( typeof incrminmaxabs( [ 0.0, 0.0 ] ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrminmaxabs( [ 0.0, 0.0 ] ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -194,7 +194,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrminmaxabs();
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmaape/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmaape/test/test.js
index cf0702f40f9e..adc062b416df 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmaape/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmaape/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmaape( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmaape( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -135,7 +135,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmaape( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmae/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmae/test/test.js
index 0903e87f8d2c..15a152940e3e 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmae/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmae/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmae( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmae( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -118,7 +118,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmae( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmape/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmape/test/test.js
index 407d176a5d17..5abbf7833ffe 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmape/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmape/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmape( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmape( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -134,7 +134,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmape( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmax/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmax/test/test.js
index 78fba8df5e06..10a2361d88b2 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmax/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmax/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmax( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmax( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -110,7 +110,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmax( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmaxabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmaxabs/test/test.js
index c919385c3112..0e02aac12927 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmaxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmaxabs/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmaxabs( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmaxabs( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -110,7 +110,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmaxabs( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmda/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmda/test/test.js
index 6d42fa8c8305..5d033097c4a6 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmda/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmda/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmda( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmda( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -138,7 +138,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmda( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mme/test/test.js b/lib/node_modules/@stdlib/stats/incr/mme/test/test.js
index 76b7cbf3e7f4..b764ea86608a 100644
--- a/lib/node_modules/@stdlib/stats/incr/mme/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mme/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmme( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmme( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -126,7 +126,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmme( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmean/test/test.js
index 7e389bc41c8c..2e3f7d707df0 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmean/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmean( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmean( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -107,7 +107,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmean( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmeanabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmeanabs/test/test.js
index 6bf4fd96c621..1bcad58a9ef0 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmeanabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmeanabs/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmeanabs( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanabs( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -107,7 +107,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmeanabs( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmeanabs2/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmeanabs2/test/test.js
index 6cb5b7e6fc2e..fa750cfa7f86 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmeanabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmeanabs2/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmeanabs2( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanabs2( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -115,7 +115,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmeanabs2( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmeanstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmeanstdev/test/test.js
index f9e6dae2b26b..a760f026e4bc 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmeanstdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmeanstdev/test/test.js
@@ -158,12 +158,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmeanstdev( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanstdev( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.strictEqual( typeof incrmmeanstdev( [ 0.0, 0.0 ], 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanstdev( [ 0.0, 0.0 ], 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -258,7 +258,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmeanstdev( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmeanvar/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmeanvar/test/test.js
index 7d33a2c10e7b..2ca3b23e0f8b 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmeanvar/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmeanvar/test/test.js
@@ -157,12 +157,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmeanvar( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanvar( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.strictEqual( typeof incrmmeanvar( [ 0.0, 0.0 ], 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmeanvar( [ 0.0, 0.0 ], 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -257,7 +257,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmeanvar( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmidrange/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmidrange/test/test.js
index cd14223f1a6e..7674a659a487 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmidrange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmidrange/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmidrange( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmidrange( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -123,7 +123,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmidrange( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmin/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmin/test/test.js
index 8a4d28824083..d97564700c34 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmin/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmin/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmin( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmin( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -110,7 +110,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmin( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mminabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/mminabs/test/test.js
index 2ba6a20d4ee2..ad6ab6ba196f 100644
--- a/lib/node_modules/@stdlib/stats/incr/mminabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mminabs/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmminabs( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmminabs( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -110,7 +110,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmminabs( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mminmax/test/test.js b/lib/node_modules/@stdlib/stats/incr/mminmax/test/test.js
index 549770bd9eb0..fd2bcd168bf3 100644
--- a/lib/node_modules/@stdlib/stats/incr/mminmax/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mminmax/test/test.js
@@ -125,12 +125,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmminmax( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmminmax( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.strictEqual( typeof incrmminmax( [ 0.0, 0.0 ], 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmminmax( [ 0.0, 0.0 ], 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -228,7 +228,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmminmax( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mminmaxabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/mminmaxabs/test/test.js
index a80a70f99b95..a9f58577fe4d 100644
--- a/lib/node_modules/@stdlib/stats/incr/mminmaxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mminmaxabs/test/test.js
@@ -125,12 +125,12 @@ tape( 'the function throws an error if not provided an array-like object for an
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmminmaxabs( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmminmaxabs( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (output)', function test( t ) {
-	t.strictEqual( typeof incrmminmaxabs( [ 0.0, 0.0 ], 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmminmaxabs( [ 0.0, 0.0 ], 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -256,7 +256,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmminmaxabs( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmpe/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmpe/test/test.js
index 4051334c39a7..cfaaf12419b8 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmpe/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmpe/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmpe( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmpe( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -134,7 +134,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmpe( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mmse/test/test.js b/lib/node_modules/@stdlib/stats/incr/mmse/test/test.js
index 5136d2b975f3..2c8fdc6d84c7 100644
--- a/lib/node_modules/@stdlib/stats/incr/mmse/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mmse/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmmse( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmmse( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -126,7 +126,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmmse( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mpcorr/test/test.js b/lib/node_modules/@stdlib/stats/incr/mpcorr/test/test.js
index 0393edc579dd..3db8bd9b8913 100644
--- a/lib/node_modules/@stdlib/stats/incr/mpcorr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mpcorr/test/test.js
@@ -317,12 +317,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmpcorr( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpcorr( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.strictEqual( typeof incrmpcorr( 3, 3.0, 3.14 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpcorr( 3, 3.0, 3.14 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -517,13 +517,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmpcorr( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known means)', function test( t ) {
 	var acc = incrmpcorr( 3, 3.0, 3.14 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mpcorr2/test/test.js b/lib/node_modules/@stdlib/stats/incr/mpcorr2/test/test.js
index d10ba26e1538..fb163d154924 100644
--- a/lib/node_modules/@stdlib/stats/incr/mpcorr2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mpcorr2/test/test.js
@@ -319,12 +319,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmpcorr2( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpcorr2( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.strictEqual( typeof incrmpcorr2( 3, 3.0, 3.14 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpcorr2( 3, 3.0, 3.14 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -519,13 +519,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmpcorr2( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known means)', function test( t ) {
 	var acc = incrmpcorr2( 3, 3.0, 3.14 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mpcorrdist/test/test.js b/lib/node_modules/@stdlib/stats/incr/mpcorrdist/test/test.js
index e5cd45b21cde..853e3f6aae42 100644
--- a/lib/node_modules/@stdlib/stats/incr/mpcorrdist/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mpcorrdist/test/test.js
@@ -325,12 +325,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmpcorrdist( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpcorrdist( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.strictEqual( typeof incrmpcorrdist( 3, 3.0, 3.14 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpcorrdist( 3, 3.0, 3.14 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -536,13 +536,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmpcorrdist( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known means)', function test( t ) {
 	var acc = incrmpcorrdist( 3, 3.0, 3.14 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mpe/test/test.js b/lib/node_modules/@stdlib/stats/incr/mpe/test/test.js
index b2a7a92a6dca..83b4b0032f4f 100644
--- a/lib/node_modules/@stdlib/stats/incr/mpe/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mpe/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmpe(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmpe(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mprod/test/test.js b/lib/node_modules/@stdlib/stats/incr/mprod/test/test.js
index 925a0fa24247..97fcf60698cc 100644
--- a/lib/node_modules/@stdlib/stats/incr/mprod/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mprod/test/test.js
@@ -74,7 +74,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmprod( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmprod( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -117,7 +117,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmprod( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mrange/test/test.js b/lib/node_modules/@stdlib/stats/incr/mrange/test/test.js
index 1f82d38e2f52..0dc8b65ef07d 100644
--- a/lib/node_modules/@stdlib/stats/incr/mrange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mrange/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmrange( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmrange( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -123,7 +123,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmrange( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mrmse/test/test.js b/lib/node_modules/@stdlib/stats/incr/mrmse/test/test.js
index b6e06e74c628..5445385660a0 100644
--- a/lib/node_modules/@stdlib/stats/incr/mrmse/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mrmse/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmrmse( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmrmse( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -134,7 +134,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmrmse( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mrss/test/test.js b/lib/node_modules/@stdlib/stats/incr/mrss/test/test.js
index 088e476bfb8c..e4a6d28646e4 100644
--- a/lib/node_modules/@stdlib/stats/incr/mrss/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mrss/test/test.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmrss( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmrss( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -126,7 +126,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmrss( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mse/test/test.js b/lib/node_modules/@stdlib/stats/incr/mse/test/test.js
index 8774e53a2e50..469f1d0b1c91 100644
--- a/lib/node_modules/@stdlib/stats/incr/mse/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mse/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmse(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmse(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/mstdev/test/test.js
index 19f84d55fe7b..ab38efd567c0 100644
--- a/lib/node_modules/@stdlib/stats/incr/mstdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mstdev/test/test.js
@@ -125,12 +125,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmstdev( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmstdev( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.strictEqual( typeof incrmstdev( 3, 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmstdev( 3, 3.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -250,13 +250,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmstdev( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known mean)', function test( t ) {
 	var acc = incrmstdev( 3, 3.0 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/msum/test/test.js b/lib/node_modules/@stdlib/stats/incr/msum/test/test.js
index 7e1bc4713e24..8f02af7410aa 100644
--- a/lib/node_modules/@stdlib/stats/incr/msum/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/msum/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmsum( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmsum( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -107,7 +107,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmsum( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/msumabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/msumabs/test/test.js
index 2f68df63e33b..702b1ba45962 100644
--- a/lib/node_modules/@stdlib/stats/incr/msumabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/msumabs/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmsumabs( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmsumabs( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -107,7 +107,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmsumabs( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/msumabs2/test/test.js b/lib/node_modules/@stdlib/stats/incr/msumabs2/test/test.js
index cbbb3f7c5209..41cf94332a8d 100644
--- a/lib/node_modules/@stdlib/stats/incr/msumabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/msumabs2/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmsumabs2( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmsumabs2( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -107,7 +107,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmsumabs2( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/msummary/test/test.js b/lib/node_modules/@stdlib/stats/incr/msummary/test/test.js
index 0902d926cc67..79cf2de6edae 100644
--- a/lib/node_modules/@stdlib/stats/incr/msummary/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/msummary/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmsummary( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmsummary( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/msumprod/test/test.js b/lib/node_modules/@stdlib/stats/incr/msumprod/test/test.js
index 8a40da1ea220..3065c2272aee 100644
--- a/lib/node_modules/@stdlib/stats/incr/msumprod/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/msumprod/test/test.js
@@ -65,7 +65,7 @@ tape( 'the function throws an error if not provided a positive integer', functio
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmsumprod( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmsumprod( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -119,7 +119,7 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmsumprod( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mvariance/test/test.js b/lib/node_modules/@stdlib/stats/incr/mvariance/test/test.js
index bc2a3d67aff7..74227b949d0d 100644
--- a/lib/node_modules/@stdlib/stats/incr/mvariance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mvariance/test/test.js
@@ -125,12 +125,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmvariance( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmvariance( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.strictEqual( typeof incrmvariance( 3, 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmvariance( 3, 3.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -243,13 +243,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmvariance( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known mean)', function test( t ) {
 	var acc = incrmvariance( 3, 3.0 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mvmr/test/test.js b/lib/node_modules/@stdlib/stats/incr/mvmr/test/test.js
index 0043e579f64b..bddc3f4a7b63 100644
--- a/lib/node_modules/@stdlib/stats/incr/mvmr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mvmr/test/test.js
@@ -125,12 +125,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmvmr( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmvmr( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.strictEqual( typeof incrmvmr( 3, 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmvmr( 3, 3.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -249,13 +249,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrmvmr( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known mean)', function test( t ) {
 	var acc = incrmvmr( 3, 3.0 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/nancount/test/test.js b/lib/node_modules/@stdlib/stats/incr/nancount/test/test.js
index 5ca97c4da0e8..08db2184c689 100644
--- a/lib/node_modules/@stdlib/stats/incr/nancount/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nancount/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrnancount(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnancount(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmaxabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanmaxabs/test/test.js
index 1a4034e9e754..f432d559a702 100644
--- a/lib/node_modules/@stdlib/stats/incr/nanmaxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nanmaxabs/test/test.js
@@ -34,13 +34,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrmaxabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrmaxabs(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the initial accumulated value is `null`', function test( t ) {
 	var acc = incrmaxabs();
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmeanabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanmeanabs/test/test.js
index abba9af442b1..47adaba38772 100644
--- a/lib/node_modules/@stdlib/stats/incr/nanmeanabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nanmeanabs/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrnanmeanabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnanmeanabs(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanmstdev/test/test.js
index 9f0fb359ef39..09e15762c4fc 100644
--- a/lib/node_modules/@stdlib/stats/incr/nanmstdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nanmstdev/test/test.js
@@ -124,12 +124,12 @@ tape( 'the function throws an error if not provided a number as the mean value',
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrnanmstdev( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnanmstdev( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.strictEqual( typeof incrnanmstdev( 3, 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnanmstdev( 3, 3.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -249,13 +249,13 @@ tape( 'if not provided an input value, the accumulator function returns the curr
 
 tape( 'if data has yet to be provided, the accumulator function returns `null`', function test( t ) {
 	var acc = incrnanmstdev( 3 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if data has yet to be provided, the accumulator function returns `null` (known mean)', function test( t ) {
 	var acc = incrnanmstdev( 3, 3.0 );
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmsum/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanmsum/test/test.js
index 4f60a40b3d7a..2a6e3554383d 100644
--- a/lib/node_modules/@stdlib/stats/incr/nanmsum/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nanmsum/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrnanmsum( 3 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnanmsum( 3 ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/nanskewness/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanskewness/test/test.js
index 73d0f41128a7..6b7c05c0d06b 100644
--- a/lib/node_modules/@stdlib/stats/incr/nanskewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nanskewness/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrnanskewness(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnanskewness(), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -65,7 +65,7 @@ tape( 'the accumulator function incrementally computes a corrected sample skewne
 	for ( i = 0; i < data.length; i++ ) {
 		actual = acc( data[ i ] );
 		if ( expected[ i ] === null ) {
-			t.strictEqual( actual, expected[i], 'returns null' );
+			t.strictEqual( actual, expected[i], 'returns expected value' );
 		} else {
 			delta = abs( actual - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
diff --git a/lib/node_modules/@stdlib/stats/incr/nansum/test/test.js b/lib/node_modules/@stdlib/stats/incr/nansum/test/test.js
index 8c24ae8ca105..a37a4862000c 100644
--- a/lib/node_modules/@stdlib/stats/incr/nansum/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nansum/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrnansum(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnansum(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/nansumabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/nansumabs/test/test.js
index 44eb1c8060c0..53998b8fc16d 100644
--- a/lib/node_modules/@stdlib/stats/incr/nansumabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nansumabs/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrnansumabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnansumabs(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/nansumabs2/test/test.js b/lib/node_modules/@stdlib/stats/incr/nansumabs2/test/test.js
index 0f800a1e143c..c87d0983a6aa 100644
--- a/lib/node_modules/@stdlib/stats/incr/nansumabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nansumabs2/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrnansumabs2(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrnansumabs2(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/pcorr/test/test.js b/lib/node_modules/@stdlib/stats/incr/pcorr/test/test.js
index c75524d5397e..e967ad519d57 100644
--- a/lib/node_modules/@stdlib/stats/incr/pcorr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/pcorr/test/test.js
@@ -88,12 +88,12 @@ tape( 'the function throws an error if provided a non-numeric value for the seco
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrpcorr(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorr(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.strictEqual( typeof incrpcorr( 3.0, -5.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorr( 3.0, -5.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -214,7 +214,7 @@ tape( 'the sample correlation coefficient is `null` until at least 1 datum has b
 	acc = incrpcorr();
 
 	v = acc();
-	t.strictEqual( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns expected value' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
@@ -232,7 +232,7 @@ tape( 'the sample correlation coefficient is `null` until at least 1 datum has b
 	acc = incrpcorr( 3.0, -5.0 );
 
 	v = acc();
-	t.strictEqual( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns expected value' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
diff --git a/lib/node_modules/@stdlib/stats/incr/pcorr2/test/test.js b/lib/node_modules/@stdlib/stats/incr/pcorr2/test/test.js
index 973c0c809701..694b6f3e4206 100644
--- a/lib/node_modules/@stdlib/stats/incr/pcorr2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/pcorr2/test/test.js
@@ -88,12 +88,12 @@ tape( 'the function throws an error if provided a non-numeric value for the seco
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrpcorr2(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorr2(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.strictEqual( typeof incrpcorr2( 3.0, -5.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorr2( 3.0, -5.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -214,7 +214,7 @@ tape( 'the squared sample correlation coefficient is `null` until at least 1 dat
 	acc = incrpcorr2();
 
 	v = acc();
-	t.strictEqual( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns expected value' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
@@ -232,7 +232,7 @@ tape( 'the squared sample correlation coefficient is `null` until at least 1 dat
 	acc = incrpcorr2( 3.0, -5.0 );
 
 	v = acc();
-	t.strictEqual( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns expected value' );
 
 	v = acc( 2.0, 10.0 );
 	t.notEqual( v, null, 'does not return null' );
diff --git a/lib/node_modules/@stdlib/stats/incr/pcorrdist/test/test.js b/lib/node_modules/@stdlib/stats/incr/pcorrdist/test/test.js
index 62c2fc9b0c0c..5304db137ae2 100644
--- a/lib/node_modules/@stdlib/stats/incr/pcorrdist/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/pcorrdist/test/test.js
@@ -88,12 +88,12 @@ tape( 'the function throws an error if provided a non-numeric value for the seco
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrpcorrdist(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrdist(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known means)', function test( t ) {
-	t.strictEqual( typeof incrpcorrdist( 3.0, -5.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrdist( 3.0, -5.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -214,7 +214,7 @@ tape( 'the sample correlation distance is `null` until at least 1 datum has been
 	acc = incrpcorrdist();
 
 	v = acc();
-	t.strictEqual( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns expected value' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, null, 'does not return null' );
@@ -229,7 +229,7 @@ tape( 'the sample correlation distance is `null` until at least 1 datum has been
 	acc = incrpcorrdist( 3.0, -5.0 );
 
 	v = acc();
-	t.strictEqual( v, null, 'returns null' );
+	t.strictEqual( v, null, 'returns expected value' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, null, 'does not return null' );
diff --git a/lib/node_modules/@stdlib/stats/incr/pcorrdistmat/test/test.js b/lib/node_modules/@stdlib/stats/incr/pcorrdistmat/test/test.js
index d358d8bd5696..86c1b6d845cd 100644
--- a/lib/node_modules/@stdlib/stats/incr/pcorrdistmat/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/pcorrdistmat/test/test.js
@@ -235,7 +235,7 @@ tape( 'the function throws an error if the number of known means does not match
 });
 
 tape( 'the function returns an accumulator function (order)', function test( t ) {
-	t.strictEqual( typeof incrpcorrdistmat( 2 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrdistmat( 2 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -250,7 +250,7 @@ tape( 'the function returns an accumulator function (distance matrix)', function
 	strides = [ 2, 1 ];
 	dist = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.strictEqual( typeof incrpcorrdistmat( dist ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrdistmat( dist ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -265,7 +265,7 @@ tape( 'the function returns an accumulator function (order; known means)', funct
 	strides = [ 1 ];
 	means = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.strictEqual( typeof incrpcorrdistmat( 2, means ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrdistmat( 2, means ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -286,7 +286,7 @@ tape( 'the function returns an accumulator function (distance matrix; known mean
 	strides = [ 1 ];
 	means = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.strictEqual( typeof incrpcorrdistmat( dist, means ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrdistmat( dist, means ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/pcorrmat/test/test.js b/lib/node_modules/@stdlib/stats/incr/pcorrmat/test/test.js
index f70b20686051..00419b2b4768 100644
--- a/lib/node_modules/@stdlib/stats/incr/pcorrmat/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/pcorrmat/test/test.js
@@ -235,7 +235,7 @@ tape( 'the function throws an error if the number of known means does not match
 });
 
 tape( 'the function returns an accumulator function (order)', function test( t ) {
-	t.strictEqual( typeof incrpcorrmat( 2 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrmat( 2 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -250,7 +250,7 @@ tape( 'the function returns an accumulator function (correlation matrix)', funct
 	strides = [ 2, 1 ];
 	corr = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.strictEqual( typeof incrpcorrmat( corr ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrmat( corr ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -265,7 +265,7 @@ tape( 'the function returns an accumulator function (order; known means)', funct
 	strides = [ 1 ];
 	means = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.strictEqual( typeof incrpcorrmat( 2, means ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrmat( 2, means ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -286,7 +286,7 @@ tape( 'the function returns an accumulator function (correlation matrix; known m
 	strides = [ 1 ];
 	means = ndarray( 'float64', buffer, shape, strides, 0, 'row-major' );
 
-	t.strictEqual( typeof incrpcorrmat( corr, means ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrpcorrmat( corr, means ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/prod/test/test.js b/lib/node_modules/@stdlib/stats/incr/prod/test/test.js
index 92b93b8b5acc..121af092b8fb 100644
--- a/lib/node_modules/@stdlib/stats/incr/prod/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/prod/test/test.js
@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/zeros' );
 var PINF = require( '@stdlib/constants/float64/pinf' );
 var NINF = require( '@stdlib/constants/float64/ninf' );
 var EPSILON = require( '@stdlib/constants/float64/eps' );
@@ -44,13 +45,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrprod(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrprod(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the initial accumulator value is `null`', function test( t ) {
 	var acc = incrprod();
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
@@ -67,8 +68,8 @@ tape( 'the accumulator function incrementally computes a product', function test
 	data = [ 2.0, 3.0, 2.0, 4.0, 3.0, 4.0 ];
 	N = data.length;
 
-	expected = new Array( N );
-	actual = new Array( N );
+	expected = zeros( N );
+	actual = zeros( N );
 
 	acc = incrprod();
 
diff --git a/lib/node_modules/@stdlib/stats/incr/range/test/test.js b/lib/node_modules/@stdlib/stats/incr/range/test/test.js
index 988764daebd8..457566c3a8d7 100644
--- a/lib/node_modules/@stdlib/stats/incr/range/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/range/test/test.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrrange(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrrange(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'if not provided any values, the initial returned range is `null`', function test( t ) {
 	var acc = incrrange();
-	t.strictEqual( acc(), null, 'returns null' );
+	t.strictEqual( acc(), null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/rmse/test/test.js b/lib/node_modules/@stdlib/stats/incr/rmse/test/test.js
index 97e622090149..5cc7f5de6cae 100644
--- a/lib/node_modules/@stdlib/stats/incr/rmse/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/rmse/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrrmse(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrrmse(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/rss/test/test.js b/lib/node_modules/@stdlib/stats/incr/rss/test/test.js
index a00473c88c49..3105ff29c3a2 100644
--- a/lib/node_modules/@stdlib/stats/incr/rss/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/rss/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrrss(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrrss(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/skewness/test/test.js b/lib/node_modules/@stdlib/stats/incr/skewness/test/test.js
index 5b9e33318660..0c08e16c31d6 100644
--- a/lib/node_modules/@stdlib/stats/incr/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/skewness/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrskewness(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrskewness(), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -64,7 +64,7 @@ tape( 'the accumulator function incrementally computes a corrected sample skewne
 	for ( i = 0; i < data.length; i++ ) {
 		actual = acc( data[ i ] );
 		if ( expected[ i ] === null ) {
-			t.strictEqual( actual, expected[i], 'returns null' );
+			t.strictEqual( actual, expected[i], 'returns expected value' );
 		} else {
 			delta = abs( actual - expected[ i ] );
 			tol = 1.5 * EPS * abs( expected[ i ] );
@@ -103,13 +103,13 @@ tape( 'the corrected sample skewness is `null` until at least 3 datums have been
 	acc = incrskewness();
 
 	skewness = acc();
-	t.strictEqual( skewness, null, 'returns null' );
+	t.strictEqual( skewness, null, 'returns expected value' );
 
 	skewness = acc( 2.0 );
-	t.strictEqual( skewness, null, 'returns null' );
+	t.strictEqual( skewness, null, 'returns expected value' );
 
 	skewness = acc( 2.0 );
-	t.strictEqual( skewness, null, 'returns null' );
+	t.strictEqual( skewness, null, 'returns expected value' );
 
 	skewness = acc( 3.0 );
 	t.notEqual( skewness, null, 'does not return null' );
diff --git a/lib/node_modules/@stdlib/stats/incr/sum/test/test.js b/lib/node_modules/@stdlib/stats/incr/sum/test/test.js
index be7143676b58..e3be9b8d133a 100644
--- a/lib/node_modules/@stdlib/stats/incr/sum/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/sum/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrsum(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrsum(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/sumabs/test/test.js b/lib/node_modules/@stdlib/stats/incr/sumabs/test/test.js
index 1f0025ee3334..59fecdba20cf 100644
--- a/lib/node_modules/@stdlib/stats/incr/sumabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/sumabs/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrsumabs(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrsumabs(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/sumabs2/test/test.js b/lib/node_modules/@stdlib/stats/incr/sumabs2/test/test.js
index a6917e738ec7..6d43f882841e 100644
--- a/lib/node_modules/@stdlib/stats/incr/sumabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/sumabs2/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrsumabs2(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrsumabs2(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/summary/test/test.js b/lib/node_modules/@stdlib/stats/incr/summary/test/test.js
index 1378957a77df..293813ff2403 100644
--- a/lib/node_modules/@stdlib/stats/incr/summary/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/summary/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrsummary(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrsummary(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/sumprod/test/test.js b/lib/node_modules/@stdlib/stats/incr/sumprod/test/test.js
index 99dc55acc872..3c2bb9cecffb 100644
--- a/lib/node_modules/@stdlib/stats/incr/sumprod/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/sumprod/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrsumprod(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrsumprod(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/variance/test/test.js b/lib/node_modules/@stdlib/stats/incr/variance/test/test.js
index 43931e4b6a46..91a28cf57af8 100644
--- a/lib/node_modules/@stdlib/stats/incr/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/variance/test/test.js
@@ -35,12 +35,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrvariance(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrvariance(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.strictEqual( typeof incrvariance( 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrvariance( 3.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -163,7 +163,7 @@ tape( 'the sample variance is `null` until at least 1 datum has been provided (u
 	acc = incrvariance();
 
 	s2 = acc();
-	t.strictEqual( s2, null, 'returns null' );
+	t.strictEqual( s2, null, 'returns expected value' );
 
 	s2 = acc( 3.0 );
 	t.notEqual( s2, null, 'does not return null' );
@@ -181,7 +181,7 @@ tape( 'the sample variance is `null` until at least 1 datum has been provided (k
 	acc = incrvariance( 3.0 );
 
 	s2 = acc();
-	t.strictEqual( s2, null, 'returns null' );
+	t.strictEqual( s2, null, 'returns expected value' );
 
 	s2 = acc( 3.0 );
 	t.notEqual( s2, null, 'does not return null' );
diff --git a/lib/node_modules/@stdlib/stats/incr/vmr/test/test.js b/lib/node_modules/@stdlib/stats/incr/vmr/test/test.js
index b6c93b645f7f..3c36edcce7d1 100644
--- a/lib/node_modules/@stdlib/stats/incr/vmr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/vmr/test/test.js
@@ -35,12 +35,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrvmr(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrvmr(), 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an accumulator function (known mean)', function test( t ) {
-	t.strictEqual( typeof incrvmr( 3.0 ), 'function', 'returns a function' );
+	t.strictEqual( typeof incrvmr( 3.0 ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -163,7 +163,7 @@ tape( 'the accumulated value is `null` until at least 1 datum has been provided
 	acc = incrvmr();
 
 	D = acc();
-	t.strictEqual( D, null, 'returns null' );
+	t.strictEqual( D, null, 'returns expected value' );
 
 	D = acc( 3.0 );
 	t.notEqual( D, null, 'does not return null' );
@@ -181,7 +181,7 @@ tape( 'the accumulated value is `null` until at least 1 datum has been provided
 	acc = incrvmr( 3.0 );
 
 	D = acc();
-	t.strictEqual( D, null, 'returns null' );
+	t.strictEqual( D, null, 'returns expected value' );
 
 	D = acc( 3.0 );
 	t.notEqual( D, null, 'does not return null' );
diff --git a/lib/node_modules/@stdlib/stats/incr/wmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/wmean/test/test.js
index 718a86b72cbe..de864ee79f0a 100644
--- a/lib/node_modules/@stdlib/stats/incr/wmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/wmean/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an accumulator function', function test( t ) {
-	t.strictEqual( typeof incrwmean(), 'function', 'returns a function' );
+	t.strictEqual( typeof incrwmean(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cugmean/test/test.js b/lib/node_modules/@stdlib/stats/iter/cugmean/test/test.js
index 38b4071043d1..06e00c252406 100644
--- a/lib/node_modules/@stdlib/stats/iter/cugmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cugmean/test/test.js
@@ -88,8 +88,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -148,11 +148,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercugmean( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -173,11 +173,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercugmean( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -214,7 +214,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cuhmean/test/test.js b/lib/node_modules/@stdlib/stats/iter/cuhmean/test/test.js
index 74d92b524c0b..e73ce6549da1 100644
--- a/lib/node_modules/@stdlib/stats/iter/cuhmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cuhmean/test/test.js
@@ -88,8 +88,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -148,11 +148,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercuhmean( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -173,11 +173,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercuhmean( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -214,7 +214,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cumax/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumax/test/test.js
index f8e0a17d871b..f3a24733a3ac 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumax/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumax/test/test.js
@@ -82,8 +82,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -139,11 +139,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumax( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -164,11 +164,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumax( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -205,7 +205,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cumaxabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumaxabs/test/test.js
index 8980af4e2003..cd1c71738aa4 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumaxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumaxabs/test/test.js
@@ -82,8 +82,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -139,11 +139,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumaxabs( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -164,11 +164,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumaxabs( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -205,7 +205,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cumean/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumean/test/test.js
index fd898b89c9b9..9ebf78de82f2 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumean/test/test.js
@@ -82,8 +82,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -139,11 +139,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumean( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -164,11 +164,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumean( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -205,7 +205,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cumeanabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumeanabs/test/test.js
index cf2291052f5c..b1fffae96000 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumeanabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumeanabs/test/test.js
@@ -82,8 +82,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -139,11 +139,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumeanabs( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -164,11 +164,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumeanabs( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -205,7 +205,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cumeanabs2/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumeanabs2/test/test.js
index 086d078aadeb..ac433b48b33c 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumeanabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumeanabs2/test/test.js
@@ -85,8 +85,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 
 		actual = v.value;
 		if ( actual === expected[i] ) {
@@ -148,11 +148,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumeanabs2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -173,11 +173,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumeanabs2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -214,7 +214,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cumidrange/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumidrange/test/test.js
index 194f6c248f26..5ae19d973f81 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumidrange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumidrange/test/test.js
@@ -82,8 +82,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -139,11 +139,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumidrange( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -164,11 +164,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumidrange( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -205,7 +205,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cumin/test/test.js b/lib/node_modules/@stdlib/stats/iter/cumin/test/test.js
index 4f2618015fb5..82072cc37b6b 100644
--- a/lib/node_modules/@stdlib/stats/iter/cumin/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cumin/test/test.js
@@ -82,8 +82,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -139,11 +139,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercumin( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -164,11 +164,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercumin( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -205,7 +205,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cuminabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/cuminabs/test/test.js
index d58e44ef33cc..c3d48336fcb5 100644
--- a/lib/node_modules/@stdlib/stats/iter/cuminabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cuminabs/test/test.js
@@ -82,8 +82,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -139,11 +139,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercuminabs( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -164,11 +164,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercuminabs( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -205,7 +205,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cuprod/test/test.js b/lib/node_modules/@stdlib/stats/iter/cuprod/test/test.js
index 647b5f8bcfb5..adf9ab4f17cc 100644
--- a/lib/node_modules/@stdlib/stats/iter/cuprod/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cuprod/test/test.js
@@ -82,8 +82,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -139,11 +139,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercuprod( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -164,11 +164,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercuprod( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -205,7 +205,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/curange/test/test.js b/lib/node_modules/@stdlib/stats/iter/curange/test/test.js
index 0bb05f518ae0..512ea80c3c05 100644
--- a/lib/node_modules/@stdlib/stats/iter/curange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/curange/test/test.js
@@ -82,8 +82,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -139,11 +139,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercurange( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -164,11 +164,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercurange( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -205,7 +205,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cusum/test/test.js b/lib/node_modules/@stdlib/stats/iter/cusum/test/test.js
index c5a6c806059c..d92c3d6161d3 100644
--- a/lib/node_modules/@stdlib/stats/iter/cusum/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cusum/test/test.js
@@ -82,8 +82,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -139,11 +139,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercusum( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -164,11 +164,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercusum( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -205,7 +205,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cusumabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/cusumabs/test/test.js
index 979b61aa9d39..e90e6e0972c8 100644
--- a/lib/node_modules/@stdlib/stats/iter/cusumabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cusumabs/test/test.js
@@ -82,8 +82,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -139,11 +139,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercusumabs( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -164,11 +164,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercusumabs( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -205,7 +205,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/cusumabs2/test/test.js b/lib/node_modules/@stdlib/stats/iter/cusumabs2/test/test.js
index 770126f05972..3e6c3e66045c 100644
--- a/lib/node_modules/@stdlib/stats/iter/cusumabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/cusumabs2/test/test.js
@@ -82,8 +82,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -139,11 +139,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itercusumabs2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -164,11 +164,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itercusumabs2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -205,7 +205,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/mmax/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmax/test/test.js
index fda39b239872..b25e56903755 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmax/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmax/test/test.js
@@ -112,8 +112,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -196,11 +196,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmax( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -221,11 +221,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmax( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/mmaxabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmaxabs/test/test.js
index 6c90ef30d128..d41d4950e339 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmaxabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmaxabs/test/test.js
@@ -112,8 +112,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -196,11 +196,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmaxabs( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -221,11 +221,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmaxabs( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/mmean/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmean/test/test.js
index 7a2522c9494b..f35d972c0957 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmean/test/test.js
@@ -112,8 +112,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -196,11 +196,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmean( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -221,11 +221,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmean( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/mmeanabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmeanabs/test/test.js
index e1d07702e1ab..1ff9c66dc061 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmeanabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmeanabs/test/test.js
@@ -112,8 +112,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -196,11 +196,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmeanabs( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -221,11 +221,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmeanabs( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/mmeanabs2/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmeanabs2/test/test.js
index fc805aaeaded..5d95b91ed5a0 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmeanabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmeanabs2/test/test.js
@@ -115,8 +115,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 
 		actual = v.value;
 		if ( actual === expected[i] ) {
@@ -205,11 +205,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmeanabs2( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -230,11 +230,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmeanabs2( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -271,7 +271,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/mmidrange/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmidrange/test/test.js
index bdea03bfb198..63bd273f230e 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmidrange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmidrange/test/test.js
@@ -112,8 +112,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -196,11 +196,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmidrange( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -221,11 +221,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmidrange( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/mmin/test/test.js b/lib/node_modules/@stdlib/stats/iter/mmin/test/test.js
index 71b71225e7b6..cde71e2cf268 100644
--- a/lib/node_modules/@stdlib/stats/iter/mmin/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mmin/test/test.js
@@ -112,8 +112,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -196,11 +196,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermmin( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -221,11 +221,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermmin( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/mminabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/mminabs/test/test.js
index d31b1f851f6b..16b923f2b576 100644
--- a/lib/node_modules/@stdlib/stats/iter/mminabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mminabs/test/test.js
@@ -112,8 +112,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -196,11 +196,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermminabs( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -221,11 +221,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermminabs( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/mprod/test/test.js b/lib/node_modules/@stdlib/stats/iter/mprod/test/test.js
index 8c495949a07d..517878926039 100644
--- a/lib/node_modules/@stdlib/stats/iter/mprod/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mprod/test/test.js
@@ -112,8 +112,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -196,11 +196,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermprod( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -221,11 +221,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermprod( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/mrange/test/test.js b/lib/node_modules/@stdlib/stats/iter/mrange/test/test.js
index d63def63f274..45da368545c7 100644
--- a/lib/node_modules/@stdlib/stats/iter/mrange/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/mrange/test/test.js
@@ -112,8 +112,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -196,11 +196,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermrange( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -221,11 +221,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermrange( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/msum/test/test.js b/lib/node_modules/@stdlib/stats/iter/msum/test/test.js
index 3e361b264a21..cc1cc981386a 100644
--- a/lib/node_modules/@stdlib/stats/iter/msum/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/msum/test/test.js
@@ -112,8 +112,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -196,11 +196,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermsum( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -221,11 +221,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermsum( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/msumabs/test/test.js b/lib/node_modules/@stdlib/stats/iter/msumabs/test/test.js
index eeabce8f4eb4..a7aa7d577af4 100644
--- a/lib/node_modules/@stdlib/stats/iter/msumabs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/msumabs/test/test.js
@@ -112,8 +112,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -196,11 +196,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermsumabs( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -221,11 +221,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermsumabs( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/iter/msumabs2/test/test.js b/lib/node_modules/@stdlib/stats/iter/msumabs2/test/test.js
index 683dabce3bb7..462829b4e962 100644
--- a/lib/node_modules/@stdlib/stats/iter/msumabs2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/iter/msumabs2/test/test.js
@@ -112,8 +112,8 @@ tape( 'the function returns an iterator protocol-compliant object which iterativ
 	actual = [];
 	for ( i = 0; i < values.length; i++ ) {
 		v = it.next();
-		t.strictEqual( typeof v.value, 'number', 'returns a number' );
-		t.strictEqual( typeof v.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof v.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof v.done, 'boolean', 'returns expected value' );
 		actual.push( v.value );
 	}
 	t.deepEqual( actual, expected, 'returns expected results' );
@@ -196,11 +196,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = itermsumabs2( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -221,11 +221,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = itermsumabs2( randu(), 3 );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -262,7 +262,7 @@ tape( 'if an environment supports `Symbol.iterator` and the provided iterator is
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/stats/kde2d/test/test.validate.js b/lib/node_modules/@stdlib/stats/kde2d/test/test.validate.js
index 85f6327af076..c5fec6a2cbe2 100644
--- a/lib/node_modules/@stdlib/stats/kde2d/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/kde2d/test/test.validate.js
@@ -372,7 +372,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -395,7 +395,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/kruskal-test/test/test.validate.js b/lib/node_modules/@stdlib/stats/kruskal-test/test/test.validate.js
index fe14730a1a64..cf2f735570f0 100644
--- a/lib/node_modules/@stdlib/stats/kruskal-test/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/kruskal-test/test/test.validate.js
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -145,7 +145,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/kstest/test/test.validate.js b/lib/node_modules/@stdlib/stats/kstest/test/test.validate.js
index 6df21ce1cf0f..f10a3c64c441 100644
--- a/lib/node_modules/@stdlib/stats/kstest/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/kstest/test/test.validate.js
@@ -151,7 +151,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -172,7 +172,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/levene-test/test/test.validate.js b/lib/node_modules/@stdlib/stats/levene-test/test/test.validate.js
index 166b2f7bd9c9..1643d2e6e04e 100644
--- a/lib/node_modules/@stdlib/stats/levene-test/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/levene-test/test/test.validate.js
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -145,7 +145,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/lowess/test/test.validate.js b/lib/node_modules/@stdlib/stats/lowess/test/test.validate.js
index 216d6180257d..96a0a8a53199 100644
--- a/lib/node_modules/@stdlib/stats/lowess/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/lowess/test/test.validate.js
@@ -176,7 +176,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -195,7 +195,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/pcorrtest/test/test.validate.js b/lib/node_modules/@stdlib/stats/pcorrtest/test/test.validate.js
index 99701de0b507..820612fe11d1 100644
--- a/lib/node_modules/@stdlib/stats/pcorrtest/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/pcorrtest/test/test.validate.js
@@ -152,7 +152,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -173,7 +173,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/ranks/test/test.validate.js b/lib/node_modules/@stdlib/stats/ranks/test/test.validate.js
index 8748d5596cc1..56871b1f297e 100644
--- a/lib/node_modules/@stdlib/stats/ranks/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/ranks/test/test.validate.js
@@ -128,7 +128,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -149,7 +149,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/ttest/test/test.validate.js b/lib/node_modules/@stdlib/stats/ttest/test/test.validate.js
index 4ee0603dc1b6..23baaac845d7 100644
--- a/lib/node_modules/@stdlib/stats/ttest/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/ttest/test/test.validate.js
@@ -192,7 +192,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'sets option values' );
 
 	t.end();
@@ -213,7 +213,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/ttest2/test/test.validate.js b/lib/node_modules/@stdlib/stats/ttest2/test/test.validate.js
index 3bd2bd9bc414..e5f45144df86 100644
--- a/lib/node_modules/@stdlib/stats/ttest2/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/ttest2/test/test.validate.js
@@ -178,7 +178,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -199,7 +199,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/vartest/test/test.validate.js b/lib/node_modules/@stdlib/stats/vartest/test/test.validate.js
index d2b75d89f7bc..8618c422dff9 100644
--- a/lib/node_modules/@stdlib/stats/vartest/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/vartest/test/test.validate.js
@@ -153,7 +153,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/wilcoxon/test/test.validate.js b/lib/node_modules/@stdlib/stats/wilcoxon/test/test.validate.js
index 2231b487377a..4dc82a30f005 100644
--- a/lib/node_modules/@stdlib/stats/wilcoxon/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/wilcoxon/test/test.validate.js
@@ -232,7 +232,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -253,7 +253,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/ztest/test/test.validate.js b/lib/node_modules/@stdlib/stats/ztest/test/test.validate.js
index 54242153ad1e..394bd6383809 100644
--- a/lib/node_modules/@stdlib/stats/ztest/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/ztest/test/test.validate.js
@@ -151,7 +151,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -172,7 +172,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/ztest2/test/test.validate.js b/lib/node_modules/@stdlib/stats/ztest2/test/test.validate.js
index 4a8cc38f2b65..96d360eadf7c 100644
--- a/lib/node_modules/@stdlib/stats/ztest2/test/test.validate.js
+++ b/lib/node_modules/@stdlib/stats/ztest2/test/test.validate.js
@@ -170,7 +170,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -191,7 +191,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js
index 677564935419..f5ceb9960b75 100644
--- a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.validate.js
index f03cdb0fa926..e5f35ff7553a 100644
--- a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.validate.js
@@ -196,7 +196,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -214,7 +214,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js
index 88833450b91e..20038ce6d7be 100644
--- a/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/debug/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/debug/test/test.validate.js
index 7222e5fb3250..c7addf9d1c70 100644
--- a/lib/node_modules/@stdlib/streams/node/debug/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/debug/test/test.validate.js
@@ -195,7 +195,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -213,7 +213,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/empty/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/empty/test/test.factory.js
index 8536f90d6f82..cb8984a69190 100644
--- a/lib/node_modules/@stdlib/streams/node/empty/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/empty/test/test.factory.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/empty/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/empty/test/test.validate.js
index 3222587933cd..d6e03286ea89 100644
--- a/lib/node_modules/@stdlib/streams/node/empty/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/empty/test/test.validate.js
@@ -92,7 +92,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -101,7 +101,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -119,7 +119,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-array/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-array/test/test.factory.js
index e514ac6b482b..fea7a34d8983 100644
--- a/lib/node_modules/@stdlib/streams/node/from-array/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-array/test/test.factory.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-array/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/from-array/test/test.validate.js
index a448b29a63f6..f32bca7e00d1 100644
--- a/lib/node_modules/@stdlib/streams/node/from-array/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/from-array/test/test.validate.js
@@ -230,7 +230,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -244,7 +244,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -266,7 +266,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.factory.js
index 8a1aeec03e83..06fb9f0c30c2 100644
--- a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.factory.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.validate.js
index ed624e9b33f7..308ddf359bb1 100644
--- a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.validate.js
@@ -259,7 +259,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -274,7 +274,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -296,7 +296,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.factory.js
index a0d6bcd71e82..ea39b70bcb2f 100644
--- a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.factory.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -44,19 +44,19 @@ tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory({
 		'iter': 10
 	});
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters)', function test( t ) {
 	var createStream = factory( 'beep' );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (parameters + options)', function test( t ) {
 	var createStream = factory( 'beep', {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.validate.js
index 533bab09f107..2111740a9806 100644
--- a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.validate.js
@@ -202,7 +202,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -215,7 +215,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -233,7 +233,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.factory.js
index 0f76a77d7663..e3e0fe7e9082 100644
--- a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.factory.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.validate.js
index 13848f2456aa..11acc0adc54c 100644
--- a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.validate.js
@@ -200,7 +200,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -213,7 +213,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -235,7 +235,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.factory.js
index a0732cabd3fa..82a07ee16350 100644
--- a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.factory.js
@@ -35,13 +35,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.validate.js
index 13848f2456aa..11acc0adc54c 100644
--- a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.validate.js
@@ -200,7 +200,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	options = {
@@ -213,7 +213,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -235,7 +235,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.factory.js
index 4ad70b8bf699..72d0706a19e7 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.factory.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.validate.js
index 5e46deb4baa0..8d0f54cc9819 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.validate.js
@@ -173,7 +173,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -191,7 +191,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/inspect/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/inspect/test/test.factory.js
index a8a0e37ff4be..cc5908111684 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect/test/test.factory.js
@@ -36,13 +36,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/inspect/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/inspect/test/test.validate.js
index 9d30a1ec614f..7229dc962451 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect/test/test.validate.js
@@ -169,7 +169,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -187,7 +187,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/join/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/join/test/test.factory.js
index 27ad416c780a..c7f712a3d09c 100644
--- a/lib/node_modules/@stdlib/streams/node/join/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/join/test/test.factory.js
@@ -64,13 +64,13 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/join/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/join/test/test.validate.js
index b6a389170d0e..628d40ea97a7 100644
--- a/lib/node_modules/@stdlib/streams/node/join/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/join/test/test.validate.js
@@ -220,7 +220,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -238,7 +238,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/split/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/split/test/test.factory.js
index a175162b357b..58dc45856dfb 100644
--- a/lib/node_modules/@stdlib/streams/node/split/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/split/test/test.factory.js
@@ -64,13 +64,13 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/split/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/split/test/test.validate.js
index ef2cea33da58..4e90ed05836b 100644
--- a/lib/node_modules/@stdlib/streams/node/split/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/split/test/test.validate.js
@@ -220,7 +220,7 @@ tape( 'the function returns null if all options are valid', function test( t ) {
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -238,7 +238,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/transform/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/transform/test/test.factory.js
index 0dcb954ef023..bf4616ed0085 100644
--- a/lib/node_modules/@stdlib/streams/node/transform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/transform/test/test.factory.js
@@ -64,13 +64,13 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a factory function', function test( t ) {
 	var createStream = factory();
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a factory function (options)', function test( t ) {
 	var createStream = factory( {} );
-	t.strictEqual( typeof createStream, 'function', 'returns a function' );
+	t.strictEqual( typeof createStream, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/transform/test/test.validate.js b/lib/node_modules/@stdlib/streams/node/transform/test/test.validate.js
index 1dbffa97469c..f8afd26a167d 100644
--- a/lib/node_modules/@stdlib/streams/node/transform/test/test.validate.js
+++ b/lib/node_modules/@stdlib/streams/node/transform/test/test.validate.js
@@ -248,7 +248,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets option values' );
 
 	t.end();
@@ -266,7 +266,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	opts = {};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'does not set any option values' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/acronym/test/test.validate.js b/lib/node_modules/@stdlib/string/acronym/test/test.validate.js
index ac48a5b14339..a1df0d199037 100644
--- a/lib/node_modules/@stdlib/string/acronym/test/test.validate.js
+++ b/lib/node_modules/@stdlib/string/acronym/test/test.validate.js
@@ -93,7 +93,7 @@ tape( 'if all options are valid, the function returns null', function test( t )
 	};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( opts.stopwords, options.stopwords, 'sets the `stopwords` option' );
 
 	t.end();
@@ -105,6 +105,6 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 		'a': null,
 		'b': 5
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/num2words/test/test.validate.js b/lib/node_modules/@stdlib/string/num2words/test/test.validate.js
index 84dca3867db8..76a7e079ed98 100644
--- a/lib/node_modules/@stdlib/string/num2words/test/test.validate.js
+++ b/lib/node_modules/@stdlib/string/num2words/test/test.validate.js
@@ -98,7 +98,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, expected, 'extracts options' );
 
 	t.end();
@@ -119,7 +119,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/string/pad/test/test.validate.js b/lib/node_modules/@stdlib/string/pad/test/test.validate.js
index aed58f2b7219..eb95b40c2cfb 100644
--- a/lib/node_modules/@stdlib/string/pad/test/test.validate.js
+++ b/lib/node_modules/@stdlib/string/pad/test/test.validate.js
@@ -143,7 +143,7 @@ tape( 'if all options are valid, the function returns null', function test( t )
 	};
 	err = validate( opts, options );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( opts.lpad, options.lpad, 'sets the `lpad` option' );
 	t.strictEqual( opts.rpad, options.rpad, 'sets the `rpad` option' );
 	t.strictEqual( opts.centerRight, options.centerRight, 'sets the `centerRight` option' );
@@ -157,6 +157,6 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 		'a': null,
 		'b': 5
 	});
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator-right/test/test.js b/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator-right/test/test.js
index 778bfff1c35f..d1fb3cf9711d 100644
--- a/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator-right/test/test.js
+++ b/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator-right/test/test.js
@@ -256,8 +256,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'string', 'returns a string' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'string', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -287,8 +287,8 @@ tape( 'the function returns an iterator protocol-compliant object (empty string)
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'string', 'returns a string' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'string', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -312,7 +312,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -345,7 +345,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -369,11 +369,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = graphemeClusters2iteratorRight( 'beep' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -394,11 +394,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = graphemeClusters2iteratorRight( 'beep', transform );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -423,11 +423,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = graphemeClusters2iteratorRight( 'beep' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -448,11 +448,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = graphemeClusters2iteratorRight( 'beep', transform );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -488,7 +488,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -516,7 +516,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator/test/test.js b/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator/test/test.js
index 0f7218a5b287..184ecaa6d50b 100644
--- a/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator/test/test.js
+++ b/lib/node_modules/@stdlib/string/to-grapheme-cluster-iterator/test/test.js
@@ -254,8 +254,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'string', 'returns a string' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'string', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -285,8 +285,8 @@ tape( 'the function returns an iterator protocol-compliant object (empty string)
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
 		actual.push( r );
-		t.strictEqual( typeof r.value, 'string', 'returns a string' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'string', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	actual.push( it.next() );
 
@@ -310,7 +310,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -343,7 +343,7 @@ tape( 'the function returns an iterator protocol-compliant object which supports
 	for ( i = 0; i < numGraphemeClusters( values ); i++ ) {
 		r = it.next();
 		t.strictEqual( r.value, expected[ i ], 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.strictEqual( expected.length, values.length, 'has expected length' );
 
@@ -367,11 +367,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = graphemeClusters2iterator( 'beep' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -392,11 +392,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = graphemeClusters2iterator( 'beep', transform );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -421,11 +421,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = graphemeClusters2iterator( 'beep' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -446,11 +446,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = graphemeClusters2iterator( 'beep', transform );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'string', 'returns a string' );
+	t.strictEqual( typeof r.value, 'string', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
@@ -486,7 +486,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
@@ -514,7 +514,7 @@ tape( 'if an environment supports `Symbol.iterator`, the returned iterator is it
 	t.strictEqual( it1[ '__ITERATOR_SYMBOL__' ].length, 0, 'has zero arity' );
 
 	it2 = it1[ '__ITERATOR_SYMBOL__' ]();
-	t.strictEqual( typeof it2, 'object', 'returns an object' );
+	t.strictEqual( typeof it2, 'object', 'returns expected value' );
 	t.strictEqual( typeof it2.next, 'function', 'has method' );
 	t.strictEqual( typeof it2.return, 'function', 'has method' );
 
diff --git a/lib/node_modules/@stdlib/symbol/ctor/test/test.js b/lib/node_modules/@stdlib/symbol/ctor/test/test.js
index c95ace056003..2de38d0cb0cb 100644
--- a/lib/node_modules/@stdlib/symbol/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/symbol/ctor/test/test.js
@@ -25,6 +25,8 @@
 var tape = require( 'tape' );
 var hasSymbolSupport = require( '@stdlib/assert/has-symbol-support' );
 var isSymbol = require( '@stdlib/assert/is-symbol' );
+var Symbol = require( '@stdlib/symbol/ctor' );
+var Object = require( '@stdlib/object/ctor' );
 var Sym = require( './../lib' );
 
 
@@ -68,7 +70,7 @@ tape( 'the function returns symbols which are unique', opts, function test( t )
 tape( 'to generate a symbol object, must wrap in `Object` call', opts, function test( t ) {
 	var s = Object( Sym( 'beep' ) );
 	t.strictEqual( isSymbol.isPrimitive( s ), false, 'does not return a primitive' );
-	t.strictEqual( isSymbol.isObject( s ), true, 'returns an object' );
+	t.strictEqual( isSymbol.isObject( s ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/argument-function/test/test.js b/lib/node_modules/@stdlib/utils/argument-function/test/test.js
index c499b82c3aa6..f0b9bc8127ce 100644
--- a/lib/node_modules/@stdlib/utils/argument-function/test/test.js
+++ b/lib/node_modules/@stdlib/utils/argument-function/test/test.js
@@ -65,7 +65,7 @@ tape( 'the function throws an error if provided an index argument which is not a
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.strictEqual( typeof argumentFunction( 1 ), 'function', 'returns a function' );
+	t.strictEqual( typeof argumentFunction( 1 ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/any-by-right/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/any-by-right/test/test.factory.js
index 50a9d51a64bc..e34a685f0cd0 100644
--- a/lib/node_modules/@stdlib/utils/async/any-by-right/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/any-by-right/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, false );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, false );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -350,7 +350,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -390,7 +390,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -431,7 +431,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -474,7 +474,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function retu
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -517,7 +517,7 @@ tape( 'if a predicate function length is 0, the function returns a function whic
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -552,7 +552,7 @@ tape( 'by default, the returned function processes collection elements concurren
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -591,7 +591,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -631,7 +631,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -671,7 +671,7 @@ tape( 'the function supports returning a function which limits the maximum numbe
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -710,7 +710,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -747,7 +747,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -787,7 +787,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -822,7 +822,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -854,7 +854,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -891,7 +891,7 @@ tape( 'if a predicate function returns a truthy test result, the returned functi
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -931,7 +931,7 @@ tape( 'if a predicate function returns a truthy test result, the returned functi
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -966,7 +966,7 @@ tape( 'if a predicate function returns a truthy test result, the returned functi
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -990,7 +990,7 @@ tape( 'if provided an empty collection, the returned function never invokes a pr
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -1018,7 +1018,7 @@ tape( 'the returned function does not guarantee asynchronous execution', functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/any-by-right/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/any-by-right/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/any-by-right/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/any-by-right/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/any-by/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/any-by/test/test.factory.js
index 61db2f2548c4..d00d820e6836 100644
--- a/lib/node_modules/@stdlib/utils/async/any-by/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/any-by/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, false );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, false );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -350,7 +350,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -387,7 +387,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -425,7 +425,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -465,7 +465,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function retu
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -505,7 +505,7 @@ tape( 'if a predicate function length is 0, the function returns a function whic
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -540,7 +540,7 @@ tape( 'by default, the returned function processes collection elements concurren
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -579,7 +579,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -619,7 +619,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -659,7 +659,7 @@ tape( 'the function supports returning a function which limits the maximum numbe
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -698,7 +698,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -735,7 +735,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -775,7 +775,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -810,7 +810,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -842,7 +842,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -879,7 +879,7 @@ tape( 'if a predicate function returns a truthy test result, the returned functi
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -919,7 +919,7 @@ tape( 'if a predicate function returns a truthy test result, the returned functi
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -954,7 +954,7 @@ tape( 'if a predicate function returns a truthy test result, the returned functi
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -978,7 +978,7 @@ tape( 'if provided an empty collection, the returned function never invokes a pr
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -1006,7 +1006,7 @@ tape( 'the returned function does not guarantee asynchronous execution', functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/any-by/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/any-by/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/any-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/any-by/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/bifurcate-by/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/bifurcate-by/test/test.factory.js
index 8fb7bb6dfe5e..344ac8d61da9 100644
--- a/lib/node_modules/@stdlib/utils/async/bifurcate-by/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/bifurcate-by/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, true );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, true );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/bifurcate-by/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/bifurcate-by/test/test.validate.js
index 65d36ba2270a..7bb531fcf933 100644
--- a/lib/node_modules/@stdlib/utils/async/bifurcate-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/bifurcate-by/test/test.validate.js
@@ -194,7 +194,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -212,7 +212,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/compose/test/test.js b/lib/node_modules/@stdlib/utils/async/compose/test/test.js
index d9a457f16ce5..87f89171658a 100644
--- a/lib/node_modules/@stdlib/utils/async/compose/test/test.js
+++ b/lib/node_modules/@stdlib/utils/async/compose/test/test.js
@@ -90,7 +90,7 @@ tape( 'the function throws an error if not provided a function', function test(
 
 tape( 'the function returns a function', function test( t ) {
 	var fcn = composeAsync( noop, noop );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/count-by/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/count-by/test/test.factory.js
index 323387d8c94a..bbbe412b78bd 100644
--- a/lib/node_modules/@stdlib/utils/async/count-by/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/count-by/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, 'beep' );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, 'beep' );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/count-by/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/count-by/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/count-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/count-by/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/every-by-right/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/every-by-right/test/test.factory.js
index 3c3bf683269d..3f2e1f1617d6 100644
--- a/lib/node_modules/@stdlib/utils/async/every-by-right/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/every-by-right/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, true );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, true );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -350,7 +350,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -390,7 +390,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -431,7 +431,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -474,7 +474,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function retu
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -517,7 +517,7 @@ tape( 'if a predicate function length is 0, the function returns a function whic
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -552,7 +552,7 @@ tape( 'by default, the returned function processes collection elements concurren
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -591,7 +591,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -631,7 +631,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -671,7 +671,7 @@ tape( 'the function supports returning a function which limits the maximum numbe
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -710,7 +710,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -747,7 +747,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -787,7 +787,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -822,7 +822,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -854,7 +854,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -891,7 +891,7 @@ tape( 'if a predicate function returns a falsy test result, the returned functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -931,7 +931,7 @@ tape( 'if a predicate function returns a falsy test result, the returned functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -966,7 +966,7 @@ tape( 'if a predicate function returns a falsy test result, the returned functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -990,7 +990,7 @@ tape( 'if provided an empty collection, the returned function never invokes a pr
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -1018,7 +1018,7 @@ tape( 'the returned function does not guarantee asynchronous execution', functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/every-by-right/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/every-by-right/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/every-by-right/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/every-by-right/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/every-by/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/every-by/test/test.factory.js
index cf0f549867db..4885e434cce6 100644
--- a/lib/node_modules/@stdlib/utils/async/every-by/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/every-by/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, true );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, true );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -350,7 +350,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -387,7 +387,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -425,7 +425,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -465,7 +465,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function retu
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -505,7 +505,7 @@ tape( 'if a predicate function length is 0, the function returns a function whic
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -540,7 +540,7 @@ tape( 'by default, the returned function processes collection elements concurren
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -579,7 +579,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -619,7 +619,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -659,7 +659,7 @@ tape( 'the function supports returning a function which limits the maximum numbe
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -698,7 +698,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -735,7 +735,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -775,7 +775,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -810,7 +810,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -842,7 +842,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -879,7 +879,7 @@ tape( 'if a predicate function returns a falsy test result, the returned functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -919,7 +919,7 @@ tape( 'if a predicate function returns a falsy test result, the returned functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -954,7 +954,7 @@ tape( 'if a predicate function returns a falsy test result, the returned functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -978,7 +978,7 @@ tape( 'if provided an empty collection, the returned function never invokes a pr
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -1006,7 +1006,7 @@ tape( 'the returned function does not guarantee asynchronous execution', functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/every-by/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/every-by/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/every-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/every-by/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/for-each-right/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/for-each-right/test/test.factory.js
index c575dc4675a5..b50e12b4f4c6 100644
--- a/lib/node_modules/@stdlib/utils/async/for-each-right/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/for-each-right/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk();
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk();
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/for-each-right/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/for-each-right/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/for-each-right/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/for-each-right/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/for-each/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/for-each/test/test.factory.js
index 7990e962f855..e5c8718fe754 100644
--- a/lib/node_modules/@stdlib/utils/async/for-each/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/for-each/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk();
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk();
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/for-each/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/for-each/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/for-each/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/for-each/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/function-sequence/test/test.js b/lib/node_modules/@stdlib/utils/async/function-sequence/test/test.js
index 67ea69ac221e..cc29a5515cb4 100644
--- a/lib/node_modules/@stdlib/utils/async/function-sequence/test/test.js
+++ b/lib/node_modules/@stdlib/utils/async/function-sequence/test/test.js
@@ -90,7 +90,7 @@ tape( 'the function throws an error if not provided a function', function test(
 
 tape( 'the function returns a function', function test( t ) {
 	var fcn = funseqAsync( noop, noop );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/group-by/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/group-by/test/test.factory.js
index db1620fed825..d9a6b6992e64 100644
--- a/lib/node_modules/@stdlib/utils/async/group-by/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/group-by/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, 'beep' );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, 'beep' );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/group-by/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/group-by/test/test.validate.js
index 65d36ba2270a..7bb531fcf933 100644
--- a/lib/node_modules/@stdlib/utils/async/group-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/group-by/test/test.validate.js
@@ -194,7 +194,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -212,7 +212,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/inmap-right/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/inmap-right/test/test.factory.js
index 62a08c41e389..9211b3d50b0b 100644
--- a/lib/node_modules/@stdlib/utils/async/inmap-right/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/inmap-right/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, value );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, value );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/inmap-right/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/inmap-right/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/inmap-right/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/inmap-right/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/inmap/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/inmap/test/test.factory.js
index 42eda3dd1812..1908e2258352 100644
--- a/lib/node_modules/@stdlib/utils/async/inmap/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/inmap/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, value );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, value );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/inmap/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/inmap/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/inmap/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/inmap/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/map-function/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/map-function/test/test.factory.js
index 5926d29f31eb..42f90bf47e9d 100644
--- a/lib/node_modules/@stdlib/utils/async/map-function/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/map-function/test/test.factory.js
@@ -153,7 +153,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function fcn( i, next ) {
 		next( null, i );
 	}
-	t.strictEqual( typeof factory( fcn ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( fcn ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -161,7 +161,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function fcn( i, next ) {
 		next( null, i );
 	}
-	t.strictEqual( typeof factory( {}, fcn ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, fcn ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/map-function/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/map-function/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/map-function/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/map-function/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/map-keys/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/map-keys/test/test.factory.js
index ca8212b8ed92..dee2490cb07c 100644
--- a/lib/node_modules/@stdlib/utils/async/map-keys/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/map-keys/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, value );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, value );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/map-keys/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/map-keys/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/map-keys/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/map-keys/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/map-values/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/map-values/test/test.factory.js
index 573ad4c40276..d0c72a9e9c6b 100644
--- a/lib/node_modules/@stdlib/utils/async/map-values/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/map-values/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, value );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, value );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/map-values/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/map-values/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/map-values/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/map-values/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/none-by-right/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/none-by-right/test/test.factory.js
index 55ce85375bda..c716b6954bed 100644
--- a/lib/node_modules/@stdlib/utils/async/none-by-right/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/none-by-right/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, false );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, false );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -350,7 +350,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -390,7 +390,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -431,7 +431,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -474,7 +474,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function retu
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -517,7 +517,7 @@ tape( 'if a predicate function length is 0, the function returns a function whic
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -552,7 +552,7 @@ tape( 'by default, the returned function processes collection elements concurren
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -591,7 +591,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -631,7 +631,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -671,7 +671,7 @@ tape( 'the function supports returning a function which limits the maximum numbe
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -710,7 +710,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -747,7 +747,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -787,7 +787,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -822,7 +822,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -854,7 +854,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -891,7 +891,7 @@ tape( 'if a predicate function returns a truthy test result, the returned functi
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -931,7 +931,7 @@ tape( 'if a predicate function returns a truthy test result, the returned functi
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -966,7 +966,7 @@ tape( 'if a predicate function returns a truthy test result, the returned functi
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -990,7 +990,7 @@ tape( 'if provided an empty collection, the returned function never invokes a pr
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -1018,7 +1018,7 @@ tape( 'the returned function does not guarantee asynchronous execution', functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/none-by-right/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/none-by-right/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/none-by-right/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/none-by-right/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/none-by/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/none-by/test/test.factory.js
index 166b287218b3..0c51f225486e 100644
--- a/lib/node_modules/@stdlib/utils/async/none-by/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/none-by/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, false );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, false );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -350,7 +350,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -387,7 +387,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -425,7 +425,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -465,7 +465,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function retu
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -505,7 +505,7 @@ tape( 'if a predicate function length is 0, the function returns a function whic
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -540,7 +540,7 @@ tape( 'by default, the returned function processes collection elements concurren
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -579,7 +579,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -619,7 +619,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -659,7 +659,7 @@ tape( 'the function supports returning a function which limits the maximum numbe
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -698,7 +698,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -735,7 +735,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -775,7 +775,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -810,7 +810,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -842,7 +842,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -879,7 +879,7 @@ tape( 'if a predicate function returns a truthy test result, the returned functi
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -919,7 +919,7 @@ tape( 'if a predicate function returns a truthy test result, the returned functi
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -954,7 +954,7 @@ tape( 'if a predicate function returns a truthy test result, the returned functi
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -978,7 +978,7 @@ tape( 'if provided an empty collection, the returned function never invokes a pr
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -1006,7 +1006,7 @@ tape( 'the returned function does not guarantee asynchronous execution', functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/none-by/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/none-by/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/none-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/none-by/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/reduce-right/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/reduce-right/test/test.factory.js
index caa508023f40..65a44589aba7 100644
--- a/lib/node_modules/@stdlib/utils/async/reduce-right/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/reduce-right/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( acc, value, clbk ) {
 		clbk( null, acc );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( acc, value, clbk ) {
 		clbk( null, acc );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/reduce-right/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/reduce-right/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/reduce-right/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/reduce-right/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/reduce/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/reduce/test/test.factory.js
index ef9b51274852..ce7043403e89 100644
--- a/lib/node_modules/@stdlib/utils/async/reduce/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/reduce/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( acc, value, clbk ) {
 		clbk( null, acc );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( acc, value, clbk ) {
 		clbk( null, acc );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/reduce/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/reduce/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/reduce/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/reduce/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.factory.js
index 6f79d0233f16..24f5e05d7e2b 100644
--- a/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.factory.js
@@ -88,7 +88,7 @@ tape( 'the function throws an error if not provided a callback argument which is
 
 tape( 'the function returns a function', function test( t ) {
 	var f = factory( [noop], noop );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/some-by-right/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/some-by-right/test/test.factory.js
index 47a3962e558e..c660ad271c5e 100644
--- a/lib/node_modules/@stdlib/utils/async/some-by-right/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/some-by-right/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, false );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, false );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -426,7 +426,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -466,7 +466,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -507,7 +507,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -550,7 +550,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function retu
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -593,7 +593,7 @@ tape( 'if a predicate function length is 0, the function returns a function whic
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -628,7 +628,7 @@ tape( 'by default, the returned function processes collection elements concurren
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -667,7 +667,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -707,7 +707,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -747,7 +747,7 @@ tape( 'the function supports returning a function which limits the maximum numbe
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -786,7 +786,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -823,7 +823,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -863,7 +863,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -898,7 +898,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -930,7 +930,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -967,7 +967,7 @@ tape( 'if a predicate function returns `n` truthy test results, the returned fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -1007,7 +1007,7 @@ tape( 'if a predicate function returns `n` truthy test results, the returned fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -1042,7 +1042,7 @@ tape( 'if a predicate function returns `n` truthy test results, the returned fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -1066,7 +1066,7 @@ tape( 'if provided an empty collection, the returned function never invokes a pr
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -1094,7 +1094,7 @@ tape( 'the returned function does not guarantee asynchronous execution', functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/some-by-right/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/some-by-right/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/some-by-right/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/some-by-right/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/some-by/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/some-by/test/test.factory.js
index e51863ba3f33..9aaf59429b7b 100644
--- a/lib/node_modules/@stdlib/utils/async/some-by/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/some-by/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, false );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, false );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -426,7 +426,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -463,7 +463,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -501,7 +501,7 @@ tape( 'the returned function invokes a predicate function once for each element
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -541,7 +541,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function retu
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -581,7 +581,7 @@ tape( 'if a predicate function length is 0, the function returns a function whic
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -616,7 +616,7 @@ tape( 'by default, the returned function processes collection elements concurren
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -655,7 +655,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -695,7 +695,7 @@ tape( 'the function supports returning a function for processing collection elem
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -735,7 +735,7 @@ tape( 'the function supports returning a function which limits the maximum numbe
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -774,7 +774,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -811,7 +811,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -851,7 +851,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -886,7 +886,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -918,7 +918,7 @@ tape( 'if an error is encountered while processing a collection element, the ret
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -955,7 +955,7 @@ tape( 'if a predicate function returns `n` truthy results, the returned function
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -995,7 +995,7 @@ tape( 'if a predicate function returns `n` truthy results, the returned function
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -1030,7 +1030,7 @@ tape( 'if a predicate function returns `n` truthy results, the returned function
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -1054,7 +1054,7 @@ tape( 'if provided an empty collection, the returned function never invokes a pr
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -1082,7 +1082,7 @@ tape( 'the returned function does not guarantee asynchronous execution', functio
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/some-by/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/some-by/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/some-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/some-by/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/async/tabulate-by/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/tabulate-by/test/test.factory.js
index c42e9c2ccd01..2ef1f25c51ce 100644
--- a/lib/node_modules/@stdlib/utils/async/tabulate-by/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/tabulate-by/test/test.factory.js
@@ -163,7 +163,7 @@ tape( 'the function returns a function (no options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, 'beep' );
 	}
-	t.strictEqual( typeof factory( next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( next ), 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -171,7 +171,7 @@ tape( 'the function returns a function (options)', function test( t ) {
 	function next( value, clbk ) {
 		clbk( null, 'beep' );
 	}
-	t.strictEqual( typeof factory( {}, next ), 'function', 'returns a function' );
+	t.strictEqual( typeof factory( {}, next ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/tabulate-by/test/test.validate.js b/lib/node_modules/@stdlib/utils/async/tabulate-by/test/test.validate.js
index 76608387c781..13794faccf3c 100644
--- a/lib/node_modules/@stdlib/utils/async/tabulate-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/async/tabulate-by/test/test.validate.js
@@ -156,7 +156,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -174,7 +174,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/bifurcate-by/test/test.validate.js b/lib/node_modules/@stdlib/utils/bifurcate-by/test/test.validate.js
index 9a0aadfc9efb..7712e6a8af5a 100644
--- a/lib/node_modules/@stdlib/utils/bifurcate-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/bifurcate-by/test/test.validate.js
@@ -134,7 +134,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -152,7 +152,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/bifurcate-in/test/test.validate.js b/lib/node_modules/@stdlib/utils/bifurcate-in/test/test.validate.js
index fd3df9b9adec..62aaafde6d70 100644
--- a/lib/node_modules/@stdlib/utils/bifurcate-in/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/bifurcate-in/test/test.validate.js
@@ -138,7 +138,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -156,7 +156,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/bifurcate-own/test/test.validate.js b/lib/node_modules/@stdlib/utils/bifurcate-own/test/test.validate.js
index fd3df9b9adec..62aaafde6d70 100644
--- a/lib/node_modules/@stdlib/utils/bifurcate-own/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/bifurcate-own/test/test.validate.js
@@ -138,7 +138,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -156,7 +156,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/bifurcate/test/test.validate.js b/lib/node_modules/@stdlib/utils/bifurcate/test/test.validate.js
index 306cad9acffd..c668b27a6fba 100644
--- a/lib/node_modules/@stdlib/utils/bifurcate/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/bifurcate/test/test.validate.js
@@ -104,7 +104,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -122,7 +122,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/compose/test/test.js b/lib/node_modules/@stdlib/utils/compose/test/test.js
index d8867d3e3e79..daed085c1978 100644
--- a/lib/node_modules/@stdlib/utils/compose/test/test.js
+++ b/lib/node_modules/@stdlib/utils/compose/test/test.js
@@ -90,7 +90,7 @@ tape( 'the function throws an error if not provided a function', function test(
 
 tape( 'the function returns a function', function test( t ) {
 	var fcn = compose( noop, noop );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/constant-function/test/test.js b/lib/node_modules/@stdlib/utils/constant-function/test/test.js
index 4922476df6c8..aebaaaae25d3 100644
--- a/lib/node_modules/@stdlib/utils/constant-function/test/test.js
+++ b/lib/node_modules/@stdlib/utils/constant-function/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.strictEqual( typeof constantFunction(), 'function', 'returns a function' );
+	t.strictEqual( typeof constantFunction(), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/count-by/test/test.validate.js b/lib/node_modules/@stdlib/utils/count-by/test/test.validate.js
index 79ab2712cabf..1ca11b657418 100644
--- a/lib/node_modules/@stdlib/utils/count-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/count-by/test/test.validate.js
@@ -96,7 +96,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/curry-right/test/test.js b/lib/node_modules/@stdlib/utils/curry-right/test/test.js
index 9e7dcd18f269..db6ad891cc26 100644
--- a/lib/node_modules/@stdlib/utils/curry-right/test/test.js
+++ b/lib/node_modules/@stdlib/utils/curry-right/test/test.js
@@ -131,7 +131,7 @@ tape( 'the function throws an error if provided an arity argument which is not a
 
 tape( 'the function returns a function', function test( t ) {
 	var fcn = curryRight( add );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -140,13 +140,13 @@ tape( 'the function curries a function', function test( t ) {
 	var f;
 
 	fcn = curryRight( add );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 
 	f = fcn( 5 );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 4 );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 3 );
 	t.strictEqual( f, 12, 'returns curried function result' );
@@ -210,13 +210,13 @@ tape( 'the function supports specifying a function arity', function test( t ) {
 	}
 
 	fcn = curryRight( add, 3 );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 
 	f = fcn( 5 );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 4 );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 3 );
 	t.strictEqual( f, 12, 'returns curried function result' );
@@ -237,16 +237,16 @@ tape( 'the function supports specifying a function context', function test( t )
 	};
 
 	fcn = curryRight( context.generate, context );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 
 	f = fcn( 'steelblue' );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 'dashed' );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 'px' );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 2 );
 	t.strictEqual( f, 'border: 2px dashed steelblue' );
@@ -267,16 +267,16 @@ tape( 'the function supports specifying a function arity and context', function
 	};
 
 	fcn = curryRight( context.generate, 4, context );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 
 	f = fcn( 'steelblue' );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 'dashed' );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 'px' );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 2 );
 	t.strictEqual( f, 'border: 2px dashed steelblue' );
diff --git a/lib/node_modules/@stdlib/utils/curry/test/test.js b/lib/node_modules/@stdlib/utils/curry/test/test.js
index 573bb4d71f70..f0fb0372ec02 100644
--- a/lib/node_modules/@stdlib/utils/curry/test/test.js
+++ b/lib/node_modules/@stdlib/utils/curry/test/test.js
@@ -137,7 +137,7 @@ tape( 'the function throws an error if provided an arity argument which is not a
 
 tape( 'the function returns a function', function test( t ) {
 	var fcn = curry( add );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -146,13 +146,13 @@ tape( 'the function curries a function', function test( t ) {
 	var f;
 
 	fcn = curry( add );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 
 	f = fcn( 5 );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 4 );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 3 );
 	t.strictEqual( f, 12, 'returns curried function result' );
@@ -216,13 +216,13 @@ tape( 'the function supports specifying a function arity', function test( t ) {
 	}
 
 	fcn = curry( add, 3 );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 
 	f = fcn( 5 );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 4 );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 3 );
 	t.strictEqual( f, 12, 'returns curried function result' );
@@ -243,16 +243,16 @@ tape( 'the function supports specifying a function context', function test( t )
 	};
 
 	fcn = curry( context.generate, context );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 
 	f = fcn( 2 );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 'px' );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 'dashed' );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 'steelblue' );
 	t.strictEqual( f, 'border: 2px dashed steelblue' );
@@ -273,16 +273,16 @@ tape( 'the function supports specifying a function arity and context', function
 	};
 
 	fcn = curry( context.generate, 4, context );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 
 	f = fcn( 2 );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 'px' );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 'dashed' );
-	t.strictEqual( typeof f, 'function', 'returns a function' );
+	t.strictEqual( typeof f, 'function', 'returns expected value' );
 
 	f = f( 'steelblue' );
 	t.strictEqual( f, 'border: 2px dashed steelblue' );
diff --git a/lib/node_modules/@stdlib/utils/deep-get/test/test.factory.js b/lib/node_modules/@stdlib/utils/deep-get/test/test.factory.js
index d64005b11ccd..39708973967e 100644
--- a/lib/node_modules/@stdlib/utils/deep-get/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/deep-get/test/test.factory.js
@@ -117,7 +117,7 @@ tape( 'the function returns a function', function test( t ) {
 	var dget = factory( 'a/b', {
 		'sep': '/'
 	});
-	t.strictEqual( typeof dget, 'function', 'returns a function' );
+	t.strictEqual( typeof dget, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/deep-get/test/test.validate.js b/lib/node_modules/@stdlib/utils/deep-get/test/test.validate.js
index c117aa6d4286..0782e3df0358 100644
--- a/lib/node_modules/@stdlib/utils/deep-get/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/deep-get/test/test.validate.js
@@ -89,7 +89,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'sep': '_'
 	};
 	obj = {};
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.strictEqual( obj.sep, '_', 'sets sep option' );
 
 	opts = {
@@ -97,7 +97,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'boop': false
 	};
 	obj = {};
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/deep-pluck/test/test.validate.js b/lib/node_modules/@stdlib/utils/deep-pluck/test/test.validate.js
index 7ce917ccae6c..9dd6cf74f3ca 100644
--- a/lib/node_modules/@stdlib/utils/deep-pluck/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/deep-pluck/test/test.validate.js
@@ -116,7 +116,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.copy, true, 'sets the copy option' );
 	t.strictEqual( obj.sep, '|', 'sets the sep option' );
 	t.end();
@@ -133,7 +133,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/deep-set/test/test.factory.js b/lib/node_modules/@stdlib/utils/deep-set/test/test.factory.js
index e892d042020a..de6aba4531c2 100644
--- a/lib/node_modules/@stdlib/utils/deep-set/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/deep-set/test/test.factory.js
@@ -119,7 +119,7 @@ tape( 'the function returns a function', function test( t ) {
 		'create': true,
 		'sep': '/'
 	});
-	t.strictEqual( typeof dset, 'function', 'returns a function' );
+	t.strictEqual( typeof dset, 'function', 'returns expected value' );
 	t.end();
 });
 
@@ -144,7 +144,7 @@ tape( 'the returned function returns `false` if provided a non-object or null',
 	});
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( dset( values[ i ], 5 ), false, 'returns false' );
+		t.strictEqual( dset( values[ i ], 5 ), false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -163,13 +163,13 @@ tape( 'the returned function returns a boolean', function test( t ) {
 		'a': 5
 	};
 	bool = dset( obj, 4 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {
 		'b': 5
 	};
 	bool = dset( obj, 4 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	dset = factory( 'a', {
 		'create': true
@@ -179,7 +179,7 @@ tape( 'the returned function returns a boolean', function test( t ) {
 		'b': 5
 	};
 	bool = dset( obj, 4 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -205,7 +205,7 @@ tape( 'the returned function deep sets', function test( t ) {
 		}
 	};
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.deepEqual( obj, expected, 'deep sets object' );
 
 	bool = dset( obj, 40 );
@@ -215,7 +215,7 @@ tape( 'the returned function deep sets', function test( t ) {
 		}
 	};
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.deepEqual( obj, expected, 'deep sets object' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/deep-set/test/test.validate.js b/lib/node_modules/@stdlib/utils/deep-set/test/test.validate.js
index f2127561ac9b..49797b7574f3 100644
--- a/lib/node_modules/@stdlib/utils/deep-set/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/deep-set/test/test.validate.js
@@ -117,7 +117,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'sep': '_'
 	};
 	obj = {};
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.strictEqual( obj.create, true, 'sets create option' );
 	t.strictEqual( obj.sep, '_', 'sets sep option' );
 
@@ -126,7 +126,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 		'boop': false
 	};
 	obj = {};
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/filter-arguments/test/test.js b/lib/node_modules/@stdlib/utils/filter-arguments/test/test.js
index 885d8f9eafc3..e4e99d6c0ea1 100644
--- a/lib/node_modules/@stdlib/utils/filter-arguments/test/test.js
+++ b/lib/node_modules/@stdlib/utils/filter-arguments/test/test.js
@@ -99,7 +99,7 @@ tape( 'the function throws an error if provided a second argument which is not a
 tape( 'the function returns a function', function test( t ) {
 	var bar = filterArguments( foo, predicate );
 
-	t.strictEqual( typeof bar, 'function', 'returns a function' );
+	t.strictEqual( typeof bar, 'function', 'returns expected value' );
 	t.end();
 
 	function foo( a, b ) {
diff --git a/lib/node_modules/@stdlib/utils/flatten-array/test/test.factory.js b/lib/node_modules/@stdlib/utils/flatten-array/test/test.factory.js
index 5f8d59e1e3f3..3003a646df5b 100644
--- a/lib/node_modules/@stdlib/utils/flatten-array/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/flatten-array/test/test.factory.js
@@ -155,10 +155,10 @@ tape( 'the function returns a function', function test( t ) {
 	var flattenArray;
 
 	flattenArray = factory( [ 1, 2, 3 ] );
-	t.strictEqual( typeof flattenArray, 'function', 'returns a function' );
+	t.strictEqual( typeof flattenArray, 'function', 'returns expected value' );
 
 	flattenArray = factory( [ 1, 2, 3 ], {} );
-	t.strictEqual( typeof flattenArray, 'function', 'returns a function' );
+	t.strictEqual( typeof flattenArray, 'function', 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/flatten-array/test/test.validate.js b/lib/node_modules/@stdlib/utils/flatten-array/test/test.validate.js
index 6a6a94e23ff3..746d7b0d0c54 100644
--- a/lib/node_modules/@stdlib/utils/flatten-array/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/flatten-array/test/test.validate.js
@@ -117,7 +117,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.notEqual( obj, opts, 'different references' );
 	t.deepEqual( obj, opts, 'sets options' );
 
@@ -134,7 +134,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	};
 	obj = {};
 
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/flatten-object/test/test.factory.js b/lib/node_modules/@stdlib/utils/flatten-object/test/test.factory.js
index 411b54831937..09f81d649598 100644
--- a/lib/node_modules/@stdlib/utils/flatten-object/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/flatten-object/test/test.factory.js
@@ -90,7 +90,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a function', function test( t ) {
 	var flatten = factory( {} );
-	t.strictEqual( typeof flatten, 'function', 'returns a function' );
+	t.strictEqual( typeof flatten, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/flatten-object/test/test.validate.js b/lib/node_modules/@stdlib/utils/flatten-object/test/test.validate.js
index aee7e72278c7..b9885da76010 100644
--- a/lib/node_modules/@stdlib/utils/flatten-object/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/flatten-object/test/test.validate.js
@@ -169,7 +169,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.notEqual( obj, opts, 'different references' );
 	t.deepEqual( obj, opts, 'sets options' );
 
@@ -186,7 +186,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	};
 	obj = {};
 
-	t.strictEqual( validate( obj, opts ), null, 'returns null' );
+	t.strictEqual( validate( obj, opts ), null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/function-sequence/test/test.js b/lib/node_modules/@stdlib/utils/function-sequence/test/test.js
index 2df106f5e08c..074574c2ff21 100644
--- a/lib/node_modules/@stdlib/utils/function-sequence/test/test.js
+++ b/lib/node_modules/@stdlib/utils/function-sequence/test/test.js
@@ -90,7 +90,7 @@ tape( 'the function throws an error if not provided a function', function test(
 
 tape( 'the function returns a function', function test( t ) {
 	var fcn = funseq( noop, noop );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.js b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.js
index e0fc8d6b0f25..9b2db3814da9 100644
--- a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.js
+++ b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.js
@@ -93,6 +93,6 @@ tape( 'the function returns the prototype of a provided value', function test( t
 
 tape( 'the function returns `null` if provided an object created via `Object.create( null )`', function test( t ) {
 	var proto = getPrototypeOf( Object.create( null ) );
-	t.strictEqual( proto, null, 'returns null' );
+	t.strictEqual( proto, null, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.native.js b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.native.js
index 5f1af3cc6448..b4461099e6cd 100644
--- a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.native.js
+++ b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.native.js
@@ -75,6 +75,6 @@ tape( 'the function returns the prototype of a provided value', function test( t
 
 tape( 'the function returns `null` if provided an object created via `Object.create( null )`', function test( t ) {
 	var proto = getPrototypeOf( Object.create( null ) );
-	t.strictEqual( proto, null, 'returns null' );
+	t.strictEqual( proto, null, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.polyfill.js b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.polyfill.js
index 5ee4447745c9..0b2c63398fb4 100644
--- a/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/utils/get-prototype-of/test/test.polyfill.js
@@ -76,7 +76,7 @@ tape( 'the function returns the prototype of a provided value', function test( t
 
 tape( 'the function returns `null` if provided an object created via `Object.create( null )`', function test( t ) {
 	var proto = getPrototypeOf( Object.create( null ) );
-	t.strictEqual( proto, null, 'returns null' );
+	t.strictEqual( proto, null, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/global/test/test.browser.js b/lib/node_modules/@stdlib/utils/global/test/test.browser.js
index 6ead82cf54cc..a3fe85184233 100644
--- a/lib/node_modules/@stdlib/utils/global/test/test.browser.js
+++ b/lib/node_modules/@stdlib/utils/global/test/test.browser.js
@@ -60,7 +60,7 @@ tape( 'the function throws a type error if provided an argument which is not a b
 });
 
 tape( 'if the `codegen` argument is `true`, the function returns an object', function test( t ) {
-	t.strictEqual( typeof getGlobal( true ), 'object', 'returns an object' );
+	t.strictEqual( typeof getGlobal( true ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/global/test/test.js b/lib/node_modules/@stdlib/utils/global/test/test.js
index 78e2898ddce2..fb3bcee83a50 100644
--- a/lib/node_modules/@stdlib/utils/global/test/test.js
+++ b/lib/node_modules/@stdlib/utils/global/test/test.js
@@ -60,7 +60,7 @@ tape( 'the function throws a type error if provided an argument which is not a b
 });
 
 tape( 'if the `codegen` argument is `true`, the function returns an object', function test( t ) {
-	t.strictEqual( typeof getGlobal( true ), 'object', 'returns an object' );
+	t.strictEqual( typeof getGlobal( true ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/group-by/test/test.validate.js b/lib/node_modules/@stdlib/utils/group-by/test/test.validate.js
index 9a0aadfc9efb..7712e6a8af5a 100644
--- a/lib/node_modules/@stdlib/utils/group-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/group-by/test/test.validate.js
@@ -134,7 +134,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -152,7 +152,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/group-in/test/test.validate.js b/lib/node_modules/@stdlib/utils/group-in/test/test.validate.js
index fd3df9b9adec..62aaafde6d70 100644
--- a/lib/node_modules/@stdlib/utils/group-in/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/group-in/test/test.validate.js
@@ -138,7 +138,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -156,7 +156,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/group-own/test/test.validate.js b/lib/node_modules/@stdlib/utils/group-own/test/test.validate.js
index fd3df9b9adec..62aaafde6d70 100644
--- a/lib/node_modules/@stdlib/utils/group-own/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/group-own/test/test.validate.js
@@ -138,7 +138,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -156,7 +156,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/group/test/test.validate.js b/lib/node_modules/@stdlib/utils/group/test/test.validate.js
index 306cad9acffd..c668b27a6fba 100644
--- a/lib/node_modules/@stdlib/utils/group/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/group/test/test.validate.js
@@ -104,7 +104,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -122,7 +122,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/key-by-right/test/test.js b/lib/node_modules/@stdlib/utils/key-by-right/test/test.js
index 2265a366013b..2e263b46149d 100644
--- a/lib/node_modules/@stdlib/utils/key-by-right/test/test.js
+++ b/lib/node_modules/@stdlib/utils/key-by-right/test/test.js
@@ -122,7 +122,7 @@ tape( 'the function returns an object', function test( t ) {
 
 	out = keyByRight( arr, toKey );
 
-	t.strictEqual( typeof out, 'object', 'returns an object' );
+	t.strictEqual( typeof out, 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/key-by/test/test.js b/lib/node_modules/@stdlib/utils/key-by/test/test.js
index 66f2b009fe62..c3b825ce670f 100644
--- a/lib/node_modules/@stdlib/utils/key-by/test/test.js
+++ b/lib/node_modules/@stdlib/utils/key-by/test/test.js
@@ -122,7 +122,7 @@ tape( 'the function returns an object', function test( t ) {
 
 	out = keyBy( arr, toKey );
 
-	t.strictEqual( typeof out, 'object', 'returns an object' );
+	t.strictEqual( typeof out, 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/library-manifest/test/test.cli.js b/lib/node_modules/@stdlib/utils/library-manifest/test/test.cli.js
index a7ae5cecdd41..21e89acc3db0 100644
--- a/lib/node_modules/@stdlib/utils/library-manifest/test/test.cli.js
+++ b/lib/node_modules/@stdlib/utils/library-manifest/test/test.cli.js
@@ -165,7 +165,7 @@ tape( 'the command-line interface prints a manifest for compiling source files',
 			t.fail( error.message );
 		} else {
 			conf = JSON.parse( stdout.toString() );
-			t.strictEqual( isObject( conf ), true, 'returns an object' );
+			t.strictEqual( isObject( conf ), true, 'returns expected value' );
 			t.strictEqual( objectKeys( conf ).length > 0, true, 'returns a non-empty object' );
 			t.deepEqual( conf, expected, 'returns expected configuration' );
 		}
diff --git a/lib/node_modules/@stdlib/utils/library-manifest/test/test.js b/lib/node_modules/@stdlib/utils/library-manifest/test/test.js
index 74ede9a42b7f..8249d713602d 100644
--- a/lib/node_modules/@stdlib/utils/library-manifest/test/test.js
+++ b/lib/node_modules/@stdlib/utils/library-manifest/test/test.js
@@ -266,7 +266,7 @@ tape( 'the function returns an object if able to resolve a configuration', funct
 	};
 	conf = manifest( fixture, conditions, opts );
 
-	t.strictEqual( isObject( conf ), true, 'returns an object' );
+	t.strictEqual( isObject( conf ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( conf ).length > 0, true, 'returns a non-empty object' );
 	t.deepEqual( conf, expected, 'returns expected configuration' );
 
@@ -285,7 +285,7 @@ tape( 'the function returns an empty object if unable to resolve a configuration
 		'basedir': __dirname
 	};
 	conf = manifest( fixture, conditions, opts );
-	t.strictEqual( isObject( conf ), true, 'returns an object' );
+	t.strictEqual( isObject( conf ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( conf ).length, 0, 'returns an empty object' );
 	t.end();
 });
@@ -318,7 +318,7 @@ tape( 'if provided conditions without matching fields, the function returns a co
 	};
 	conf = manifest( fixture, conditions, opts );
 
-	t.strictEqual( isObject( conf ), true, 'returns an object' );
+	t.strictEqual( isObject( conf ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( conf ).length > 0, true, 'returns a non-empty object' );
 	t.deepEqual( conf, expected, 'returns expected configuration' );
 
@@ -353,7 +353,7 @@ tape( 'the function supports processing manifests which specify additional field
 	};
 	conf = manifest( extraFields, conditions, opts );
 
-	t.strictEqual( isObject( conf ), true, 'returns an object' );
+	t.strictEqual( isObject( conf ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( conf ).length > 0, true, 'returns a non-empty object' );
 	t.deepEqual( conf, expected, 'returns expected configuration' );
 
@@ -397,7 +397,7 @@ tape( 'the function supports resolving dependencies', function test( t ) {
 	};
 	conf = manifest( dependency, conditions, opts );
 
-	t.strictEqual( isObject( conf ), true, 'returns an object' );
+	t.strictEqual( isObject( conf ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( conf ).length > 0, true, 'returns a non-empty object' );
 	t.deepEqual( conf, expected, 'returns expected configuration' );
 
@@ -441,7 +441,7 @@ tape( 'the function supports resolving dependencies and generating relative path
 	};
 	conf = manifest( relativePaths, conditions, opts );
 
-	t.strictEqual( isObject( conf ), true, 'returns an object' );
+	t.strictEqual( isObject( conf ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( conf ).length > 0, true, 'returns a non-empty object' );
 	t.deepEqual( conf, expected, 'returns expected configuration' );
 
@@ -480,7 +480,7 @@ tape( 'the function supports processing manifests which specify additional field
 	};
 	conf = manifest( extraFieldsAndDeps, conditions, opts );
 
-	t.strictEqual( isObject( conf ), true, 'returns an object' );
+	t.strictEqual( isObject( conf ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( conf ).length > 0, true, 'returns a non-empty object' );
 	t.deepEqual( conf, expected, 'returns expected configuration' );
 
@@ -522,7 +522,7 @@ tape( 'the function supports specifying a path convention', function test( t ) {
 	};
 	conf = manifest( fixture, conditions, opts );
 
-	t.strictEqual( isObject( conf ), true, 'returns an object' );
+	t.strictEqual( isObject( conf ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( conf ).length > 0, true, 'returns a non-empty object' );
 	t.deepEqual( conf, expected, 'returns expected configuration' );
 
@@ -565,7 +565,7 @@ tape( 'the function supports specifying a path convention (extra fields)', funct
 	};
 	conf = manifest( extraFields, conditions, opts );
 
-	t.strictEqual( isObject( conf ), true, 'returns an object' );
+	t.strictEqual( isObject( conf ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( conf ).length > 0, true, 'returns a non-empty object' );
 	t.deepEqual( conf, expected, 'returns expected configuration' );
 
diff --git a/lib/node_modules/@stdlib/utils/library-manifest/test/test.validate.js b/lib/node_modules/@stdlib/utils/library-manifest/test/test.validate.js
index 8d8e3a699cca..6edc6f9096d0 100644
--- a/lib/node_modules/@stdlib/utils/library-manifest/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/library-manifest/test/test.validate.js
@@ -124,7 +124,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -142,7 +142,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/map-arguments/test/test.js b/lib/node_modules/@stdlib/utils/map-arguments/test/test.js
index b6ea53c03dbb..ea1bcb5f96c3 100644
--- a/lib/node_modules/@stdlib/utils/map-arguments/test/test.js
+++ b/lib/node_modules/@stdlib/utils/map-arguments/test/test.js
@@ -99,7 +99,7 @@ tape( 'the function throws an error if provided a second argument which is not a
 tape( 'the function returns a function', function test( t ) {
 	var bar = mapArguments( foo, clbk );
 
-	t.strictEqual( typeof bar, 'function', 'returns a function' );
+	t.strictEqual( typeof bar, 'function', 'returns expected value' );
 	t.end();
 
 	function foo( a, b ) {
diff --git a/lib/node_modules/@stdlib/utils/mask-arguments/test/test.js b/lib/node_modules/@stdlib/utils/mask-arguments/test/test.js
index abeb16851c7d..289dc26c3744 100644
--- a/lib/node_modules/@stdlib/utils/mask-arguments/test/test.js
+++ b/lib/node_modules/@stdlib/utils/mask-arguments/test/test.js
@@ -95,7 +95,7 @@ tape( 'the function throws an error if provided a mask argument which is not an
 tape( 'the function returns a function', function test( t ) {
 	var bar = maskArguments( foo, [ 1, 0, 1 ] );
 
-	t.strictEqual( typeof bar, 'function', 'returns a function' );
+	t.strictEqual( typeof bar, 'function', 'returns expected value' );
 	t.end();
 
 	function foo( a, b ) {
diff --git a/lib/node_modules/@stdlib/utils/memoize/test/test.js b/lib/node_modules/@stdlib/utils/memoize/test/test.js
index 519a2937deba..ff17fcffb9d5 100644
--- a/lib/node_modules/@stdlib/utils/memoize/test/test.js
+++ b/lib/node_modules/@stdlib/utils/memoize/test/test.js
@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/zeros' );
 var noop = require( '@stdlib/utils/noop' );
 var hasOwnProp = require( '@stdlib/assert/has-own-property' );
 var isObject = require( '@stdlib/assert/is-plain-object' );
@@ -93,7 +94,7 @@ tape( 'the function throws an error if provided a non-function hash function arg
 
 tape( 'the function returns a function', function test( t ) {
 	var fcn = memoize( noop );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.notEqual( fcn, noop, 'returns a new function' );
 	t.end();
 });
@@ -118,7 +119,7 @@ tape( 'the returned function is memoized', function test( t ) {
 
 	fcn = memoize( rand );
 
-	vals = new Array( 5 );
+	vals = zeros( 5 );
 	for ( i = 0; i < vals.length; i++ ) {
 		vals[ i ] = fcn( i );
 	}
diff --git a/lib/node_modules/@stdlib/utils/merge/test/test.defaults.js b/lib/node_modules/@stdlib/utils/merge/test/test.defaults.js
index 7106da6c0393..1be554574b60 100644
--- a/lib/node_modules/@stdlib/utils/merge/test/test.defaults.js
+++ b/lib/node_modules/@stdlib/utils/merge/test/test.defaults.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof defaults(), 'object', 'returns an object' );
+	t.strictEqual( typeof defaults(), 'object', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/merge/test/test.factory.js b/lib/node_modules/@stdlib/utils/merge/test/test.factory.js
index 19dab898995d..8337e98e1e81 100644
--- a/lib/node_modules/@stdlib/utils/merge/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/merge/test/test.factory.js
@@ -109,7 +109,7 @@ tape( 'the function returns a merge function', function test( t ) {
 	opts = setup();
 	merge = factory( opts );
 
-	t.strictEqual( typeof merge, 'function', 'returns a function' );
+	t.strictEqual( typeof merge, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/merge/test/test.validate.js b/lib/node_modules/@stdlib/utils/merge/test/test.validate.js
index 0915ddc17c49..a07de7e066e7 100644
--- a/lib/node_modules/@stdlib/utils/merge/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/merge/test/test.validate.js
@@ -170,7 +170,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.level, 2, 'sets level option' );
 	t.strictEqual( obj.copy, false, 'sets copy option' );
 	t.strictEqual( obj.extend, false, 'sets extend option' );
@@ -192,7 +192,7 @@ tape( 'the function ignores unsupported/unrecognized options', function test( t
 	obj = {};
 	err = validate( obj, opts );
 
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/nary-function/test/test.js b/lib/node_modules/@stdlib/utils/nary-function/test/test.js
index ca904ff16bc4..a498bb5da50d 100644
--- a/lib/node_modules/@stdlib/utils/nary-function/test/test.js
+++ b/lib/node_modules/@stdlib/utils/nary-function/test/test.js
@@ -106,7 +106,7 @@ tape( 'the function throws an error if provided a second argument which is not a
 
 tape( 'the function returns a function', function test( t ) {
 	var bar = naryFunction( sum, 2 );
-	t.strictEqual( typeof bar, 'function', 'returns a function' );
+	t.strictEqual( typeof bar, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/papply-right/test/test.js b/lib/node_modules/@stdlib/utils/papply-right/test/test.js
index 79c50d63b4ab..1fd1350b9faa 100644
--- a/lib/node_modules/@stdlib/utils/papply-right/test/test.js
+++ b/lib/node_modules/@stdlib/utils/papply-right/test/test.js
@@ -68,7 +68,7 @@ tape( 'the function throws an error if not provided a function', function test(
 
 tape( 'the function returns a function', function test( t ) {
 	var fcn = papplyRight( say, 'Ada Lovelace' );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.notEqual( fcn, say, 'returns a new function' );
 	t.end();
 });
@@ -85,7 +85,7 @@ tape( 'the function partially applies function arguments', function test( t ) {
 
 tape( 'the function does not require function arguments to partially apply', function test( t ) {
 	var fcn = papplyRight( say );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.notEqual( fcn, say, 'returns a new function' );
 	t.strictEqual( fcn( 'Thank you', 'Betty Friedan' ), 'Thank you, Betty Friedan.', 'returns expected value' );
 	t.strictEqual( fcn( 'Hello', 'Hannah Arendt' ), 'Hello, Hannah Arendt.', 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/utils/papply/test/test.js b/lib/node_modules/@stdlib/utils/papply/test/test.js
index fedf3c2d8c9f..6456beffbbc2 100644
--- a/lib/node_modules/@stdlib/utils/papply/test/test.js
+++ b/lib/node_modules/@stdlib/utils/papply/test/test.js
@@ -68,7 +68,7 @@ tape( 'the function throws an error if not provided a function', function test(
 
 tape( 'the function returns a function', function test( t ) {
 	var fcn = papply( add, 2 );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.notEqual( fcn, add, 'returns a new function' );
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function partially applies function arguments', function test( t ) {
 
 tape( 'the function does not require function arguments to partially apply', function test( t ) {
 	var fcn = papply( add );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.notEqual( fcn, add, 'returns a new function' );
 	t.strictEqual( fcn( 2, 3 ), 5, 'returns expected value' );
 	t.strictEqual( fcn( 5, 7 ), 12, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.node.env.js b/lib/node_modules/@stdlib/utils/parallel/test/test.node.env.js
index 17b30421ede3..c8499cc2ce94 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.node.env.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.node.env.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof env( getOpts() ), 'object', 'returns an object' );
+	t.strictEqual( typeof env( getOpts() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.node.options.js b/lib/node_modules/@stdlib/utils/parallel/test/test.node.options.js
index 305031cb41ea..245a9bcc87db 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.node.options.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.node.options.js
@@ -47,7 +47,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns an object', function test( t ) {
-	t.strictEqual( typeof getOpts( options() ), 'object', 'returns an object' );
+	t.strictEqual( typeof getOpts( options() ), 'object', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.validate.js b/lib/node_modules/@stdlib/utils/parallel/test/test.validate.js
index acb4e244580f..8dff78fcffef 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.validate.js
@@ -259,7 +259,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -278,7 +278,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/parse-json/test/test.js b/lib/node_modules/@stdlib/utils/parse-json/test/test.js
index 3bc1b711c59a..14b6bc6cf52b 100644
--- a/lib/node_modules/@stdlib/utils/parse-json/test/test.js
+++ b/lib/node_modules/@stdlib/utils/parse-json/test/test.js
@@ -126,11 +126,11 @@ tape( 'the function returns a JSON value if provided valid JSON', function test(
 
 	expected = null;
 	actual = parseJSON( 'null' );
-	t.strictEqual( actual, expected, 'returns null' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	expected = true;
 	actual = parseJSON( 'true' );
-	t.strictEqual( actual, expected, 'returns true' );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	expected = 3.14;
 	actual = parseJSON( '3.14' );
diff --git a/lib/node_modules/@stdlib/utils/pick-arguments/test/test.js b/lib/node_modules/@stdlib/utils/pick-arguments/test/test.js
index ed44b50d08b1..3ab8c7200222 100644
--- a/lib/node_modules/@stdlib/utils/pick-arguments/test/test.js
+++ b/lib/node_modules/@stdlib/utils/pick-arguments/test/test.js
@@ -97,7 +97,7 @@ tape( 'the function throws an error if provided a second argument which is not a
 tape( 'the function returns a function', function test( t ) {
 	var bar = pickArguments( foo, [ 0, 2 ] );
 
-	t.strictEqual( typeof bar, 'function', 'returns a function' );
+	t.strictEqual( typeof bar, 'function', 'returns expected value' );
 	t.end();
 
 	function foo( a, b ) {
diff --git a/lib/node_modules/@stdlib/utils/pluck/test/test.validate.js b/lib/node_modules/@stdlib/utils/pluck/test/test.validate.js
index 523cd3be5dcc..d4fd4334202b 100644
--- a/lib/node_modules/@stdlib/utils/pluck/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/pluck/test/test.validate.js
@@ -90,7 +90,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.strictEqual( obj.copy, opts.copy, 'sets copy option' );
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function ignores unrecognized options', function test( t ) {
 	};
 	obj = {};
 	err = validate( obj, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( obj, {}, 'does not set any properties' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/reject-arguments/test/test.js b/lib/node_modules/@stdlib/utils/reject-arguments/test/test.js
index b57847539b6b..b91f53a96b6b 100644
--- a/lib/node_modules/@stdlib/utils/reject-arguments/test/test.js
+++ b/lib/node_modules/@stdlib/utils/reject-arguments/test/test.js
@@ -99,7 +99,7 @@ tape( 'the function throws an error if provided a second argument which is not a
 tape( 'the function returns a function', function test( t ) {
 	var bar = rejectArguments( foo, predicate );
 
-	t.strictEqual( typeof bar, 'function', 'returns a function' );
+	t.strictEqual( typeof bar, 'function', 'returns expected value' );
 	t.end();
 
 	function foo( a, b ) {
diff --git a/lib/node_modules/@stdlib/utils/reorder-arguments/test/test.js b/lib/node_modules/@stdlib/utils/reorder-arguments/test/test.js
index 42a25d8af206..19a570bb08a8 100644
--- a/lib/node_modules/@stdlib/utils/reorder-arguments/test/test.js
+++ b/lib/node_modules/@stdlib/utils/reorder-arguments/test/test.js
@@ -102,7 +102,7 @@ tape( 'the function returns a function', function test( t ) {
 
 	bar = reorderArguments( foo, [ 2, 0, 1 ] );
 
-	t.strictEqual( typeof bar, 'function', 'returns a function' );
+	t.strictEqual( typeof bar, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/reverse-arguments/test/test.js b/lib/node_modules/@stdlib/utils/reverse-arguments/test/test.js
index ad32c414c39f..488103cf3c37 100644
--- a/lib/node_modules/@stdlib/utils/reverse-arguments/test/test.js
+++ b/lib/node_modules/@stdlib/utils/reverse-arguments/test/test.js
@@ -68,7 +68,7 @@ tape( 'the function returns a function', function test( t ) {
 
 	bar = reverseArguments( foo );
 
-	t.strictEqual( typeof bar, 'function', 'returns a function' );
+	t.strictEqual( typeof bar, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/tabulate-by/test/test.validate.js b/lib/node_modules/@stdlib/utils/tabulate-by/test/test.validate.js
index 79ab2712cabf..1ca11b657418 100644
--- a/lib/node_modules/@stdlib/utils/tabulate-by/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/tabulate-by/test/test.validate.js
@@ -96,7 +96,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, options, 'sets options' );
 
 	t.end();
@@ -114,7 +114,7 @@ tape( 'the function will ignore unrecognized options', function test( t ) {
 	};
 
 	err = validate( opts, options );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 	t.deepEqual( opts, {}, 'ignores unrecognized options' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/timeit/test/test.validate.js b/lib/node_modules/@stdlib/utils/timeit/test/test.validate.js
index af80ac40e915..3024a684c1b3 100644
--- a/lib/node_modules/@stdlib/utils/timeit/test/test.validate.js
+++ b/lib/node_modules/@stdlib/utils/timeit/test/test.validate.js
@@ -200,7 +200,7 @@ tape( 'the function returns `null` if all options are valid', function test( t )
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, opts, 'sets options' );
 	t.end();
@@ -219,7 +219,7 @@ tape( 'the function ignores unrecognized/unsupported options', function test( t
 	};
 
 	err = validate( options, opts );
-	t.strictEqual( err, null, 'returns null' );
+	t.strictEqual( err, null, 'returns expected value' );
 
 	t.deepEqual( options, {}, 'does not set unrecognized options' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/timeit/test/test.vm_compile.js b/lib/node_modules/@stdlib/utils/timeit/test/test.vm_compile.js
index c909ea9ba1ac..6bdfd87cfe32 100644
--- a/lib/node_modules/@stdlib/utils/timeit/test/test.vm_compile.js
+++ b/lib/node_modules/@stdlib/utils/timeit/test/test.vm_compile.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a function containing compiled source code', function test( t ) {
 	var fcn = compile( 'foo.js', 'var beep;' );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/try-function/test/test.js b/lib/node_modules/@stdlib/utils/try-function/test/test.js
index 16147b040fe0..4f3ce8b5837a 100644
--- a/lib/node_modules/@stdlib/utils/try-function/test/test.js
+++ b/lib/node_modules/@stdlib/utils/try-function/test/test.js
@@ -60,7 +60,7 @@ tape( 'the function will throw an error if not provided a function', function te
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.strictEqual( typeof wrap( noop ), 'function', 'returns a function' );
+	t.strictEqual( typeof wrap( noop ), 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/uncurry-right/test/test.js b/lib/node_modules/@stdlib/utils/uncurry-right/test/test.js
index 99653f8f8949..f678b386fbfe 100644
--- a/lib/node_modules/@stdlib/utils/uncurry-right/test/test.js
+++ b/lib/node_modules/@stdlib/utils/uncurry-right/test/test.js
@@ -102,7 +102,7 @@ tape( 'the function throws an error if provided an arity argument which is not a
 
 tape( 'the function returns a function', function test( t ) {
 	var fcn = uncurryRight( addZ );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/uncurry/test/test.js b/lib/node_modules/@stdlib/utils/uncurry/test/test.js
index 096c550e6873..a583e2f32587 100644
--- a/lib/node_modules/@stdlib/utils/uncurry/test/test.js
+++ b/lib/node_modules/@stdlib/utils/uncurry/test/test.js
@@ -102,7 +102,7 @@ tape( 'the function throws an error if provided an arity argument which is not a
 
 tape( 'the function returns a function', function test( t ) {
 	var fcn = uncurry( addX );
-	t.strictEqual( typeof fcn, 'function', 'returns a function' );
+	t.strictEqual( typeof fcn, 'function', 'returns expected value' );
 	t.end();
 });
 

From 11581aaca8c3cb824cbb92c0c0f80e76890bdb20 Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Thu, 14 Aug 2025 16:02:12 -0500
Subject: [PATCH 15/32] test: use standardized assertion messages and fix lint
 errors

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../github/create-issue/test/test.data.js     |   2 +-
 .../github/create-repo/test/test.data.js      |   2 +-
 .../github/create-token/test/test.data.js     |   2 +-
 .../dispatch-workflow/test/test.data.js       |   2 +-
 .../licenses/insert-header/test/test.js       |  10 +-
 .../licenses/remove-header/test/test.js       |  20 +--
 .../licenses/update-header/test/test.js       |  22 +--
 .../img-svg-equation/test/test.escape_html.js |   2 +-
 .../img-svg-equation/test/test.render.js      |   2 +-
 .../test/test.escape_html.js                  |   2 +-
 .../inline-svg-equation/test/test.render.js   |   2 +-
 .../_tools/package-json/validate/test/test.js |   4 +-
 .../_tools/pkgs/dep-list/test/test.root.js    |   2 +-
 .../_tools/pkgs/names/test/test.root.js       |   2 +-
 .../pkgs/namespace-deps/test/test.root.js     |   2 +-
 .../_tools/repl-txt/validate/test/test.js     |  24 ++--
 .../utils/jsdelivr-url/test/test.url.js       |   2 +-
 .../tex-equation-to-svg/test/test.cli.js      |   4 +-
 .../tex-equation-to-svg/test/test.factory.js  |   4 +-
 .../tex-equation-to-svg/test/test.main.js     |   4 +-
 .../@stdlib/assert/deep-equal/test/test.js    | 132 +++++++++---------
 .../deep-has-own-property/test/test.has.js    |  22 +--
 .../assert/deep-has-own-property/test/test.js |  50 +++----
 .../assert/deep-has-property/test/test.has.js |  22 +--
 .../assert/deep-has-property/test/test.js     |  50 +++----
 .../assert/has-own-property/test/test.js      |  26 ++--
 .../@stdlib/assert/has-property/test/test.js  |  28 ++--
 .../@stdlib/assert/instance-of/test/test.js   |   9 +-
 .../is-absolute-path/test/test.posix.js       |   2 +-
 .../is-absolute-path/test/test.win32.js       |   2 +-
 .../is-accessor-property-in/test/test.js      |  38 ++---
 .../assert/is-accessor-property/test/test.js  |  32 ++---
 .../@stdlib/assert/is-alphagram/test/test.js  |   4 +-
 .../@stdlib/assert/is-arguments/test/test.js  |   2 +-
 .../assert/is-array-array/test/test.js        |  12 +-
 .../assert/is-array-length/test/test.js       |  12 +-
 .../assert/is-array-like-object/test/test.js  |   6 +-
 .../@stdlib/assert/is-array-like/test/test.js |   6 +-
 .../@stdlib/assert/is-array/test/test.js      |   4 +-
 .../assert/is-arraybuffer/test/test.js        |   5 +-
 .../test/es2015-arrow-function/index.js       |   2 +-
 .../assert/is-arrow-function/test/test.js     |   8 +-
 .../@stdlib/assert/is-ascii/test/test.js      |   2 +-
 .../assert/is-between-array/test/test.js      | 116 +++++++--------
 .../@stdlib/assert/is-between/test/test.js    | 100 ++++++-------
 .../assert/is-bigint/test/test.generic.js     |   4 +-
 .../assert/is-bigint/test/test.object.js      |   5 +-
 .../assert/is-bigint/test/test.primitive.js   |   5 +-
 .../assert/is-bigint/test/test.try2valueof.js |   8 +-
 .../assert/is-bigint64array/test/test.js      |   5 +-
 .../assert/is-biguint64array/test/test.js     |   5 +-
 .../assert/is-binary-string/test/test.js      |   4 +-
 .../assert/is-blank-string/test/test.js       |   4 +-
 .../assert/is-boolean-array/test/test.js      |  18 +--
 .../assert/is-boolean/test/test.main.js       |   8 +-
 .../assert/is-boolean/test/test.object.js     |  14 +-
 .../assert/is-boolean/test/test.primitive.js  |   8 +-
 .../is-boolean/test/test.try2serialize.js     |  10 +-
 .../assert/is-boxed-primitive/test/test.js    |   6 +-
 .../assert/is-browser/test/test.browser.js    |   2 +-
 .../assert/is-browser/test/test.main.js       |   8 +-
 .../is-centrosymmetric-matrix/test/test.js    |  16 +--
 .../assert/is-circular-array/test/test.js     |   6 +-
 .../is-circular-plain-object/test/test.js     |   6 +-
 .../@stdlib/assert/is-circular/test/test.js   |  14 +-
 .../is-class/test/es2015-class/index.js       |   6 +-
 .../assert/is-complex-like/test/test.js       |   6 +-
 .../is-complex-typed-array/test/test.js       |   4 +-
 .../@stdlib/assert/is-complex/test/test.js    |   4 +-
 .../@stdlib/assert/is-complex128/test/test.js |   2 +-
 .../assert/is-complex128array/test/test.js    |   2 +-
 .../is-complex128matrix-like/test/test.js     |   4 +-
 .../is-complex128ndarray-like/test/test.js    |   4 +-
 .../is-complex128vector-like/test/test.js     |   4 +-
 .../@stdlib/assert/is-complex64/test/test.js  |   2 +-
 .../assert/is-complex64array/test/test.js     |   2 +-
 .../is-complex64matrix-like/test/test.js      |   4 +-
 .../is-complex64ndarray-like/test/test.js     |   4 +-
 .../is-complex64vector-like/test/test.js      |   4 +-
 .../assert/is-composite/test/test.object.js   |   6 +-
 .../is-configurable-property-in/test/test.js  |  28 ++--
 .../is-configurable-property/test/test.js     |  24 ++--
 .../assert/is-cube-number/test/test.main.js   |   4 +-
 .../assert/is-cube-number/test/test.object.js |   4 +-
 .../is-cube-number/test/test.primitive.js     |   4 +-
 .../assert/is-data-property-in/test/test.js   |  26 ++--
 .../assert/is-data-property/test/test.js      |  24 ++--
 .../@stdlib/assert/is-dataview/test/test.js   |   5 +-
 .../assert/is-date-object-array/test/test.js  |   8 +-
 .../assert/is-date-object/test/test.js        |  10 +-
 .../assert/is-digit-string/test/test.js       |   2 +-
 .../assert/is-docker/test/test.browser.js     |   2 +-
 .../assert/is-docker/test/test.main.js        |   6 +-
 .../assert/is-domain-name/test/test.js        |  12 +-
 .../is-electron-main/test/test.browser.js     |   2 +-
 .../assert/is-electron-main/test/test.main.js |   6 +-
 .../is-electron-renderer/test/test.browser.js |   2 +-
 .../is-electron-renderer/test/test.main.js    |   6 +-
 .../assert/is-electron/test/test.browser.js   |   2 +-
 .../assert/is-electron/test/test.main.js      |  14 +-
 .../assert/is-email-address/test/test.js      |   4 +-
 .../assert/is-empty-array/test/test.js        |   9 +-
 .../assert/is-empty-object/test/test.js       |   9 +-
 .../assert/is-empty-string/test/test.main.js  |   4 +-
 .../is-empty-string/test/test.object.js       |   8 +-
 .../is-empty-string/test/test.primitive.js    |   4 +-
 .../is-enumerable-property-in/test/test.js    |  30 ++--
 .../is-enumerable-property/test/test.js       |  34 ++---
 .../@stdlib/assert/is-error/test/test.js      |   4 +-
 .../@stdlib/assert/is-eval-error/test/test.js |   4 +-
 .../@stdlib/assert/is-even/test/test.main.js  |   4 +-
 .../assert/is-even/test/test.object.js        |   4 +-
 .../assert/is-even/test/test.primitive.js     |   4 +-
 .../assert/is-falsy-array/test/test.js        |   4 +-
 .../@stdlib/assert/is-falsy/test/test.js      |  12 +-
 .../assert/is-finite-array/test/test.js       |  28 ++--
 .../assert/is-finite/test/test.main.js        |   6 +-
 .../assert/is-finite/test/test.object.js      |   6 +-
 .../assert/is-finite/test/test.primitive.js   |   6 +-
 .../assert/is-float32array/test/test.js       |   2 +-
 .../assert/is-float32matrix-like/test/test.js |   4 +-
 .../is-float32ndarray-like/test/test.js       |   4 +-
 .../assert/is-float32vector-like/test/test.js |   4 +-
 .../assert/is-float64array/test/test.js       |   2 +-
 .../assert/is-float64matrix-like/test/test.js |   4 +-
 .../is-float64ndarray-like/test/test.js       |   4 +-
 .../assert/is-float64vector-like/test/test.js |   4 +-
 .../assert/is-function-array/test/test.js     |   4 +-
 .../@stdlib/assert/is-function/test/test.js   |   2 +-
 .../test/es2015-generator/index.js            |   4 +-
 .../is-generator-object-like/test/test.js     |   4 +-
 .../test/es2015-generator/index.js            |   4 +-
 .../assert/is-generator-object/test/test.js   |   2 +-
 .../@stdlib/assert/is-hex-string/test/test.js |   2 +-
 .../assert/is-infinite/test/test.main.js      |  10 +-
 .../assert/is-infinite/test/test.object.js    |  10 +-
 .../assert/is-infinite/test/test.primitive.js |  10 +-
 .../assert/is-inherited-property/test/test.js |  32 ++---
 .../@stdlib/assert/is-int16array/test/test.js |   2 +-
 .../@stdlib/assert/is-int32array/test/test.js |   2 +-
 .../@stdlib/assert/is-int8array/test/test.js  |   2 +-
 .../assert/is-integer-array/test/test.js      |  22 +--
 .../assert/is-integer/test/test.main.js       |   4 +-
 .../assert/is-integer/test/test.object.js     |   4 +-
 .../assert/is-integer/test/test.primitive.js  |   4 +-
 .../@stdlib/assert/is-kebabcase/test/test.js  |   2 +-
 .../@stdlib/assert/is-leap-year/test/test.js  |   2 +-
 .../@stdlib/assert/is-localhost/test/test.js  |   4 +-
 .../assert/is-matrix-like/test/test.js        |   4 +-
 .../@stdlib/assert/is-method-in/test/test.js  |  32 ++---
 .../@stdlib/assert/is-method/test/test.js     |  22 +--
 .../assert/is-mobile/test/test.browser.js     |   6 +-
 .../assert/is-mobile/test/test.main.js        |   2 +-
 .../assert/is-multi-slice/test/test.js        |   2 +-
 .../@stdlib/assert/is-nan-array/test/test.js  |  30 ++--
 .../@stdlib/assert/is-nan/test/test.main.js   |   4 +-
 .../@stdlib/assert/is-nan/test/test.object.js |   8 +-
 .../assert/is-nan/test/test.primitive.js      |   8 +-
 .../assert/is-native-function/test/test.js    |  12 +-
 .../assert/is-ndarray-like/test/test.js       |   4 +-
 .../is-negative-finite/test/test.main.js      |   4 +-
 .../is-negative-finite/test/test.object.js    |   4 +-
 .../is-negative-finite/test/test.primitive.js |   4 +-
 .../is-negative-integer-array/test/test.js    |  24 ++--
 .../is-negative-integer/test/test.main.js     |   4 +-
 .../is-negative-integer/test/test.object.js   |   4 +-
 .../test/test.primitive.js                    |   4 +-
 .../is-negative-number-array/test/test.js     |  24 ++--
 .../is-negative-number/test/test.main.js      |   4 +-
 .../is-negative-number/test/test.object.js    |   4 +-
 .../is-negative-number/test/test.primitive.js |   4 +-
 .../assert/is-negative-zero/test/test.main.js |   6 +-
 .../is-negative-zero/test/test.object.js      |   6 +-
 .../is-negative-zero/test/test.primitive.js   |   6 +-
 .../assert/is-node-builtin/test/test.js       |   2 +-
 .../assert/is-node-repl/test/test.browser.js  |  16 +--
 .../@stdlib/assert/is-node-repl/test/test.js  |   2 +-
 .../assert/is-node-repl/test/test.main.js     |  16 +--
 .../assert/is-node/test/test.browser.js       |   2 +-
 .../@stdlib/assert/is-node/test/test.main.js  |  24 ++--
 .../test/test.js                              |  32 ++---
 .../is-nonconfigurable-property/test/test.js  |  22 +--
 .../is-nonenumerable-property-in/test/test.js |  32 ++---
 .../is-nonenumerable-property/test/test.js    |  22 +--
 .../is-nonnegative-integer-array/test/test.js |  24 ++--
 .../is-nonnegative-integer/test/test.main.js  |   4 +-
 .../test/test.object.js                       |   4 +-
 .../test/test.primitive.js                    |   4 +-
 .../is-nonnegative-number-array/test/test.js  |  24 ++--
 .../is-nonnegative-number/test/test.main.js   |   4 +-
 .../is-nonnegative-number/test/test.object.js |   4 +-
 .../test/test.primitive.js                    |   4 +-
 .../is-nonpositive-finite/test/test.main.js   |   4 +-
 .../is-nonpositive-finite/test/test.object.js |   4 +-
 .../test/test.primitive.js                    |   4 +-
 .../is-nonpositive-integer-array/test/test.js |  24 ++--
 .../is-nonpositive-integer/test/test.main.js  |   4 +-
 .../test/test.object.js                       |   4 +-
 .../test/test.primitive.js                    |   4 +-
 .../is-nonpositive-number-array/test/test.js  |  24 ++--
 .../is-nonpositive-number/test/test.main.js   |   4 +-
 .../is-nonpositive-number/test/test.object.js |   4 +-
 .../test/test.primitive.js                    |   4 +-
 .../is-nonsymmetric-matrix/test/test.js       |  12 +-
 .../@stdlib/assert/is-null-array/test/test.js |   8 +-
 .../@stdlib/assert/is-null/test/test.js       |   2 +-
 .../assert/is-number-array/test/test.js       |  20 ++-
 .../assert/is-number/test/test.main.js        |  10 +-
 .../assert/is-number/test/test.object.js      |  16 +--
 .../assert/is-number/test/test.primitive.js   |  10 +-
 .../is-number/test/test.try2serialize.js      |   8 +-
 .../assert/is-object-array/test/test.js       |   6 +-
 .../assert/is-object-like/test/test.array.js  |   4 +-
 .../assert/is-object-like/test/test.js        |  12 +-
 .../@stdlib/assert/is-object/test/test.js     |   4 +-
 .../@stdlib/assert/is-odd/test/test.main.js   |   4 +-
 .../@stdlib/assert/is-odd/test/test.object.js |   8 +-
 .../assert/is-odd/test/test.primitive.js      |   4 +-
 .../@stdlib/assert/is-pascalcase/test/test.js |   4 +-
 .../is-persymmetric-matrix/test/test.js       |  12 +-
 .../assert/is-plain-object-array/test/test.js |   8 +-
 .../assert/is-plain-object/test/test.js       |  24 ++--
 .../is-positive-finite/test/test.main.js      |   4 +-
 .../is-positive-finite/test/test.object.js    |   6 +-
 .../is-positive-finite/test/test.primitive.js |   6 +-
 .../is-positive-integer-array/test/test.js    |  24 ++--
 .../is-positive-integer/test/test.main.js     |   4 +-
 .../is-positive-integer/test/test.object.js   |   4 +-
 .../test/test.primitive.js                    |   4 +-
 .../is-positive-number-array/test/test.js     |  24 ++--
 .../is-positive-number/test/test.main.js      |   4 +-
 .../is-positive-number/test/test.object.js    |   4 +-
 .../is-positive-number/test/test.primitive.js |   4 +-
 .../assert/is-positive-zero/test/test.main.js |   6 +-
 .../is-positive-zero/test/test.object.js      |   6 +-
 .../is-positive-zero/test/test.primitive.js   |   6 +-
 .../assert/is-prime/test/test.object.js       |   6 +-
 .../assert/is-prime/test/test.primitive.js    |   6 +-
 .../assert/is-primitive-array/test/test.js    |  10 +-
 .../@stdlib/assert/is-primitive/test/test.js  |   6 +-
 .../assert/is-probability-array/test/test.js  |  22 +--
 .../assert/is-probability/test/test.main.js   |   4 +-
 .../assert/is-probability/test/test.object.js |   4 +-
 .../is-probability/test/test.primitive.js     |   4 +-
 .../assert/is-property-key/test/test.js       |  12 +-
 .../assert/is-prototype-of/test/test.js       |  12 +-
 .../assert/is-range-error/test/test.js        |   4 +-
 .../is-read-only-property-in/test/test.js     |  44 +++---
 .../assert/is-read-only-property/test/test.js |  38 ++---
 .../is-read-write-property-in/test/test.js    |  28 ++--
 .../is-read-write-property/test/test.js       |  30 ++--
 .../is-readable-property-in/test/test.js      |  26 ++--
 .../assert/is-readable-property/test/test.js  |  26 ++--
 .../assert/is-reference-error/test/test.js    |   4 +-
 .../assert/is-regexp-string/test/test.js      |   4 +-
 .../@stdlib/assert/is-regexp/test/test.js     |  12 +-
 .../is-relative-path/test/test.posix.js       |   2 +-
 .../is-relative-path/test/test.win32.js       |   2 +-
 .../assert/is-safe-integer-array/test/test.js |  28 ++--
 .../assert/is-safe-integer/test/test.main.js  |   8 +-
 .../is-safe-integer/test/test.object.js       |   6 +-
 .../is-safe-integer/test/test.primitive.js    |   6 +-
 .../assert/is-same-native-class/test/test.js  |   4 +-
 .../@stdlib/assert/is-same-type/test/test.js  |   4 +-
 .../assert/is-sharedarraybuffer/test/test.js  |   5 +-
 .../test/test.js                              |  16 +--
 .../is-skew-persymmetric-matrix/test/test.js  |  12 +-
 .../is-skew-symmetric-matrix/test/test.js     |  12 +-
 .../@stdlib/assert/is-slice/test/test.js      |   2 +-
 .../@stdlib/assert/is-snakecase/test/test.js  |   2 +-
 .../assert/is-square-matrix/test/test.js      |   8 +-
 .../assert/is-square-number/test/test.main.js |   4 +-
 .../is-square-number/test/test.object.js      |   4 +-
 .../is-square-number/test/test.primitive.js   |   4 +-
 .../test/test.main.js                         |   4 +-
 .../test/test.object.js                       |   4 +-
 .../test/test.primitive.js                    |   4 +-
 .../@stdlib/assert/is-startcase/test/test.js  |   2 +-
 .../assert/is-string-array/test/test.js       |  12 +-
 .../assert/is-string/test/test.main.js        |   4 +-
 .../assert/is-string/test/test.object.js      |  10 +-
 .../assert/is-string/test/test.primitive.js   |   4 +-
 .../assert/is-string/test/test.try2valueof.js |   6 +-
 .../assert/is-symbol-array/test/test.js       |  26 ++--
 .../assert/is-symbol/test/test.generic.js     |   4 +-
 .../assert/is-symbol/test/test.object.js      |   4 +-
 .../assert/is-symbol/test/test.primitive.js   |   4 +-
 .../is-symbol/test/test.try2tostring.js       |  10 +-
 .../assert/is-symmetric-matrix/test/test.js   |  12 +-
 .../assert/is-syntax-error/test/test.js       |   4 +-
 .../is-touch-device/test/test.browser.js      |  14 +-
 .../assert/is-touch-device/test/test.main.js  |   2 +-
 .../is-triangular-number/test/test.main.js    |   4 +-
 .../is-triangular-number/test/test.object.js  |   4 +-
 .../test/test.primitive.js                    |   4 +-
 .../assert/is-truthy-array/test/test.js       |   4 +-
 .../@stdlib/assert/is-truthy/test/test.js     |  12 +-
 .../@stdlib/assert/is-type-error/test/test.js |   4 +-
 .../assert/is-typed-array-length/test/test.js |  12 +-
 .../assert/is-typed-array/test/test.js        |   4 +-
 .../assert/is-uint16array/test/test.js        |   2 +-
 .../assert/is-uint32array/test/test.js        |   2 +-
 .../@stdlib/assert/is-uint8array/test/test.js |   2 +-
 .../assert/is-uint8clampedarray/test/test.js  |   2 +-
 .../is-unity-probability-array/test/test.js   |   2 +-
 .../@stdlib/assert/is-uri-error/test/test.js  |   4 +-
 .../assert/is-vector-like/test/test.js        |   4 +-
 .../assert/is-web-worker/test/test.main.js    |  16 +--
 .../is-well-formed-string/test/test.main.js   |   4 +-
 .../is-well-formed-string/test/test.object.js |   4 +-
 .../test/test.primitive.js                    |   4 +-
 .../is-writable-property-in/test/test.js      |  24 ++--
 .../assert/is-writable-property/test/test.js  |  24 ++--
 .../is-write-only-property-in/test/test.js    |  40 +++---
 .../is-write-only-property/test/test.js       |  36 ++---
 .../assert/tools/array-function/test/test.js  |   2 +-
 .../tools/array-like-function/test/test.js    |   2 +-
 .../tools/typed-array-function/test/test.js   |   2 +-
 .../@stdlib/buffer/alloc-unsafe/test/test.js  |   2 +-
 .../buffer/alloc-unsafe/test/test.main.js     |   2 +-
 .../buffer/alloc-unsafe/test/test.polyfill.js |   2 +-
 .../@stdlib/buffer/from-array/test/test.js    |   8 +-
 .../buffer/from-array/test/test.main.js       |   8 +-
 .../buffer/from-array/test/test.polyfill.js   |   8 +-
 .../buffer/from-arraybuffer/test/test.js      |   8 +-
 .../buffer/from-arraybuffer/test/test.main.js |  10 +-
 .../from-arraybuffer/test/test.polyfill.js    |  12 +-
 .../@stdlib/buffer/from-string/test/test.js   |   4 +-
 .../buffer/from-string/test/test.main.js      |   4 +-
 .../buffer/from-string/test/test.polyfill.js  |   4 +-
 .../datasets/sotu/test/test.re_filename.js    |   8 +-
 .../error/tools/fmtprodmsg/test/test.js       |   2 +-
 .../@stdlib/error/tools/id2msg/test/test.js   |   2 +-
 .../@stdlib/error/tools/id2pkg/test/test.js   |   2 +-
 .../@stdlib/error/tools/msg2id/test/test.js   |   2 +-
 .../@stdlib/error/tools/pkg2id/test/test.js   |   4 +-
 .../@stdlib/fs/exists/test/test.async.js      |  16 +--
 .../@stdlib/fs/exists/test/test.sync.js       |   8 +-
 .../@stdlib/iter/any/test/test.js             |   6 +-
 .../@stdlib/iter/every/test/test.js           |   6 +-
 .../@stdlib/iter/none/test/test.js            |   6 +-
 .../@stdlib/iter/some/test/test.js            |   6 +-
 .../tools/evalpoly-compile-c/test/test.js     |  24 ++--
 .../base/tools/evalpoly-compile/test/test.js  |  24 ++--
 .../tools/evalrational-compile-c/test/test.js |  24 ++--
 .../tools/evalrational-compile/test/test.js   |  24 ++--
 .../math/iter/special/abs/test/test.js        |  16 +--
 .../math/iter/special/abs2/test/test.js       |  16 +--
 .../math/iter/special/acos/test/test.js       |  16 +--
 .../math/iter/special/acosh/test/test.js      |  16 +--
 .../math/iter/special/acot/test/test.js       |  16 +--
 .../math/iter/special/acoth/test/test.js      |  16 +--
 .../math/iter/special/acovercos/test/test.js  |  16 +--
 .../math/iter/special/acoversin/test/test.js  |  16 +--
 .../math/iter/special/ahavercos/test/test.js  |  16 +--
 .../math/iter/special/ahaversin/test/test.js  |  16 +--
 .../math/iter/special/asin/test/test.js       |  16 +--
 .../math/iter/special/asinh/test/test.js      |  16 +--
 .../math/iter/special/atan/test/test.js       |  16 +--
 .../math/iter/special/atan2/test/test.js      |  32 ++---
 .../math/iter/special/atanh/test/test.js      |  16 +--
 .../math/iter/special/avercos/test/test.js    |  16 +--
 .../math/iter/special/aversin/test/test.js    |  16 +--
 .../math/iter/special/besselj0/test/test.js   |  16 +--
 .../math/iter/special/besselj1/test/test.js   |  16 +--
 .../math/iter/special/bessely0/test/test.js   |  16 +--
 .../math/iter/special/bessely1/test/test.js   |  16 +--
 .../math/iter/special/beta/test/test.js       |  32 ++---
 .../math/iter/special/betaln/test/test.js     |  32 ++---
 .../math/iter/special/binet/test/test.js      |  16 +--
 .../math/iter/special/cbrt/test/test.js       |  16 +--
 .../math/iter/special/ceil/test/test.js       |  16 +--
 .../math/iter/special/ceil10/test/test.js     |  16 +--
 .../math/iter/special/ceil2/test/test.js      |  16 +--
 .../math/iter/special/cos/test/test.js        |  16 +--
 .../math/iter/special/cosh/test/test.js       |  16 +--
 .../math/iter/special/cosm1/test/test.js      |  16 +--
 .../math/iter/special/cospi/test/test.js      |  16 +--
 .../math/iter/special/covercos/test/test.js   |  16 +--
 .../math/iter/special/coversin/test/test.js   |  16 +--
 .../math/iter/special/deg2rad/test/test.js    |  16 +--
 .../math/iter/special/digamma/test/test.js    |  16 +--
 .../iter/special/dirac-delta/test/test.js     |  16 +--
 .../iter/special/dirichlet-eta/test/test.js   |  16 +--
 .../math/iter/special/ellipe/test/test.js     |  16 +--
 .../math/iter/special/ellipk/test/test.js     |  16 +--
 .../math/iter/special/erf/test/test.js        |  16 +--
 .../math/iter/special/erfc/test/test.js       |  16 +--
 .../math/iter/special/erfcinv/test/test.js    |  16 +--
 .../math/iter/special/erfinv/test/test.js     |  16 +--
 .../math/iter/special/exp/test/test.js        |  16 +--
 .../math/iter/special/exp10/test/test.js      |  16 +--
 .../math/iter/special/exp2/test/test.js       |  16 +--
 .../math/iter/special/expit/test/test.js      |  16 +--
 .../math/iter/special/expm1/test/test.js      |  16 +--
 .../math/iter/special/expm1rel/test/test.js   |  16 +--
 .../math/iter/special/factorial/test/test.js  |  16 +--
 .../iter/special/factorialln/test/test.js     |  16 +--
 .../math/iter/special/floor/test/test.js      |  16 +--
 .../math/iter/special/floor10/test/test.js    |  16 +--
 .../math/iter/special/floor2/test/test.js     |  16 +--
 .../math/iter/special/fresnelc/test/test.js   |  16 +--
 .../math/iter/special/fresnels/test/test.js   |  16 +--
 .../math/iter/special/gamma/test/test.js      |  16 +--
 .../math/iter/special/gamma1pm1/test/test.js  |  16 +--
 .../math/iter/special/gammaln/test/test.js    |  16 +--
 .../math/iter/special/hacovercos/test/test.js |  16 +--
 .../math/iter/special/hacoversin/test/test.js |  16 +--
 .../math/iter/special/havercos/test/test.js   |  16 +--
 .../math/iter/special/haversin/test/test.js   |  16 +--
 .../math/iter/special/inv/test/test.js        |  16 +--
 .../@stdlib/math/iter/special/ln/test/test.js |  16 +--
 .../math/iter/special/log/test/test.js        |  32 ++---
 .../math/iter/special/log10/test/test.js      |  16 +--
 .../math/iter/special/log1mexp/test/test.js   |  16 +--
 .../math/iter/special/log1p/test/test.js      |  16 +--
 .../math/iter/special/log1pexp/test/test.js   |  16 +--
 .../math/iter/special/log2/test/test.js       |  16 +--
 .../math/iter/special/logit/test/test.js      |  16 +--
 .../math/iter/special/pow/test/test.js        |  32 ++---
 .../math/iter/special/rad2deg/test/test.js    |  16 +--
 .../math/iter/special/ramp/test/test.js       |  16 +--
 .../iter/special/riemann-zeta/test/test.js    |  16 +--
 .../math/iter/special/round/test/test.js      |  16 +--
 .../math/iter/special/round10/test/test.js    |  16 +--
 .../math/iter/special/round2/test/test.js     |  16 +--
 .../math/iter/special/rsqrt/test/test.js      |  16 +--
 .../math/iter/special/signum/test/test.js     |  16 +--
 .../math/iter/special/sin/test/test.js        |  16 +--
 .../math/iter/special/sinc/test/test.js       |  16 +--
 .../math/iter/special/sinh/test/test.js       |  16 +--
 .../math/iter/special/sinpi/test/test.js      |  16 +--
 .../math/iter/special/spence/test/test.js     |  16 +--
 .../math/iter/special/sqrt/test/test.js       |  16 +--
 .../math/iter/special/sqrt1pm1/test/test.js   |  16 +--
 .../math/iter/special/tan/test/test.js        |  16 +--
 .../math/iter/special/tanh/test/test.js       |  16 +--
 .../math/iter/special/trigamma/test/test.js   |  16 +--
 .../math/iter/special/trunc/test/test.js      |  16 +--
 .../math/iter/special/trunc10/test/test.js    |  16 +--
 .../math/iter/special/trunc2/test/test.js     |  16 +--
 .../math/iter/special/vercos/test/test.js     |  16 +--
 .../math/iter/special/versin/test/test.js     |  16 +--
 .../@stdlib/namespace/alias2pkg/test/test.js  |   2 +-
 .../namespace/alias2standalone/test/test.js   |   2 +-
 .../@stdlib/namespace/pkg2alias/test/test.js  |   4 +-
 .../namespace/pkg2standalone/test/test.js     |   2 +-
 .../namespace/standalone2pkg/test/test.js     |   2 +-
 .../number/float32/base/exponent/test/test.js |   2 +-
 .../float32/base/exponent/test/test.native.js |   2 +-
 .../number/float32/base/signbit/test/test.js  |   2 +-
 .../float32/base/signbit/test/test.native.js  |   2 +-
 .../float32/base/significand/test/test.js     |   2 +-
 .../base/significand/test/test.native.js      |   2 +-
 .../number/float64/base/exponent/test/test.js |   2 +-
 .../float64/base/exponent/test/test.native.js |   2 +-
 .../float64/base/from-words/test/test.js      |   4 +-
 .../base/from-words/test/test.native.js       |   4 +-
 .../float64/base/get-high-word/test/test.js   |   2 +-
 .../base/get-high-word/test/test.native.js    |   2 +-
 .../float64/base/get-low-word/test/test.js    |   2 +-
 .../base/get-low-word/test/test.native.js     |   2 +-
 .../float64/base/set-high-word/test/test.js   |   2 +-
 .../base/set-high-word/test/test.native.js    |   2 +-
 .../float64/base/set-low-word/test/test.js    |  12 +-
 .../base/set-low-word/test/test.native.js     |  12 +-
 .../number/float64/base/signbit/test/test.js  |   2 +-
 .../float64/base/signbit/test/test.native.js  |   2 +-
 .../uint16/base/to-binary-string/test/test.js |   2 +-
 .../uint32/base/to-binary-string/test/test.js |   2 +-
 .../uint8/base/to-binary-string/test/test.js  |   2 +-
 .../@stdlib/object/every-in-by/test/test.js   |   2 +-
 .../@stdlib/object/every-own-by/test/test.js  |   8 +-
 .../@stdlib/object/none-in-by/test/test.js    |   8 +-
 .../@stdlib/object/some-in-by/test/test.js    |  14 +-
 .../@stdlib/os/tmpdir/test/test.js            |   2 +-
 .../@stdlib/process/read-stdin/test/test.js   |  14 +-
 .../process/umask/test/test.browser.js        |  16 +--
 .../@stdlib/process/umask/test/test.js        |  16 +--
 .../random/base/arcsine/test/test.factory.js  |  14 +-
 .../@stdlib/random/base/arcsine/test/test.js  |   2 +-
 .../base/bernoulli/test/test.factory.js       |  16 +--
 .../random/base/beta/test/test.factory.js     |  24 ++--
 .../@stdlib/random/base/beta/test/test.js     |   2 +-
 .../base/betaprime/test/test.factory.js       |  24 ++--
 .../random/base/betaprime/test/test.js        |   2 +-
 .../random/base/binomial/test/test.factory.js |  26 ++--
 .../base/box-muller/test/test.factory.js      |   6 +-
 .../random/base/box-muller/test/test.js       |   2 +-
 .../random/base/cauchy/test/test.factory.js   |  18 +--
 .../@stdlib/random/base/cauchy/test/test.js   |   2 +-
 .../random/base/chi/test/test.factory.js      |  16 +--
 .../@stdlib/random/base/chi/test/test.js      |   2 +-
 .../base/chisquare/test/test.factory.js       |  16 +--
 .../random/base/chisquare/test/test.js        |   2 +-
 .../random/base/cosine/test/test.factory.js   |  18 +--
 .../@stdlib/random/base/cosine/test/test.js   |   2 +-
 .../test/test.discrete_uniform.js             |  22 +--
 .../discrete-uniform/test/test.factory.js     |  20 +--
 .../random/base/discrete-uniform/test/test.js |   2 +-
 .../random/base/erlang/test/test.factory.js   |  22 +--
 .../@stdlib/random/base/erlang/test/test.js   |   2 +-
 .../base/exponential/test/test.factory.js     |  16 +--
 .../random/base/exponential/test/test.js      |   2 +-
 .../random/base/f/test/test.factory.js        |  22 +--
 .../@stdlib/random/base/f/test/test.js        |   2 +-
 .../random/base/frechet/test/test.factory.js  |  16 +--
 .../@stdlib/random/base/frechet/test/test.js  |   2 +-
 .../random/base/gamma/test/test.factory.js    |  22 +--
 .../@stdlib/random/base/gamma/test/test.js    |   4 +-
 .../base/geometric/test/test.factory.js       |  16 +--
 .../random/base/gumbel/test/test.factory.js   |  18 +--
 .../@stdlib/random/base/gumbel/test/test.js   |   2 +-
 .../base/hypergeometric/test/test.factory.js  |  24 ++--
 .../improved-ziggurat/test/test.factory.js    |   6 +-
 .../base/improved-ziggurat/test/test.js       |   2 +-
 .../random/base/invgamma/test/test.factory.js |  22 +--
 .../@stdlib/random/base/invgamma/test/test.js |   2 +-
 .../base/kumaraswamy/test/test.factory.js     |  24 ++--
 .../random/base/kumaraswamy/test/test.js      |   2 +-
 .../random/base/laplace/test/test.factory.js  |  18 +--
 .../@stdlib/random/base/laplace/test/test.js  |   2 +-
 .../random/base/levy/test/test.factory.js     |  18 +--
 .../@stdlib/random/base/levy/test/test.js     |   2 +-
 .../random/base/logistic/test/test.factory.js |  18 +--
 .../@stdlib/random/base/logistic/test/test.js |   2 +-
 .../base/lognormal/test/test.factory.js       |  18 +--
 .../random/base/lognormal/test/test.js        |   2 +-
 .../base/minstd-shuffle/test/test.factory.js  |   6 +-
 .../random/base/minstd-shuffle/test/test.js   |   4 +-
 .../random/base/minstd/test/test.factory.js   |   6 +-
 .../@stdlib/random/base/minstd/test/test.js   |   4 +-
 .../random/base/mt19937/test/test.factory.js  |   6 +-
 .../@stdlib/random/base/mt19937/test/test.js  |   4 +-
 .../negative-binomial/test/test.factory.js    |  24 ++--
 .../random/base/normal/test/test.factory.js   |  18 +--
 .../@stdlib/random/base/normal/test/test.js   |   2 +-
 .../base/pareto-type1/test/test.factory.js    |  22 +--
 .../random/base/pareto-type1/test/test.js     |   2 +-
 .../random/base/poisson/test/test.factory.js  |  16 +--
 .../random/base/randi/test/test.factory.js    |   2 +-
 .../@stdlib/random/base/randi/test/test.js    |   2 +-
 .../random/base/randn/test/test.factory.js    |   6 +-
 .../@stdlib/random/base/randn/test/test.js    |   2 +-
 .../random/base/randu/test/test.factory.js    |   2 +-
 .../@stdlib/random/base/randu/test/test.js    |   2 +-
 .../random/base/rayleigh/test/test.factory.js |  16 +--
 .../@stdlib/random/base/rayleigh/test/test.js |   2 +-
 .../random/base/t/test/test.factory.js        |  16 +--
 .../@stdlib/random/base/t/test/test.js        |   2 +-
 .../base/triangular/test/test.factory.js      |  16 +--
 .../random/base/triangular/test/test.js       |   2 +-
 .../random/base/uniform/test/test.factory.js  |  14 +-
 .../@stdlib/random/base/uniform/test/test.js  |   2 +-
 .../random/base/weibull/test/test.factory.js  |  22 +--
 .../@stdlib/random/base/weibull/test/test.js  |   2 +-
 .../random/streams/arcsine/test/test.main.js  |   4 +-
 .../streams/bernoulli/test/test.main.js       |   4 +-
 .../random/streams/beta/test/test.main.js     |   4 +-
 .../streams/betaprime/test/test.main.js       |   4 +-
 .../random/streams/binomial/test/test.main.js |   4 +-
 .../streams/box-muller/test/test.main.js      |   4 +-
 .../random/streams/cauchy/test/test.main.js   |   4 +-
 .../random/streams/chi/test/test.main.js      |   4 +-
 .../streams/chisquare/test/test.main.js       |   4 +-
 .../random/streams/cosine/test/test.main.js   |   4 +-
 .../discrete-uniform/test/test.main.js        |   4 +-
 .../random/streams/erlang/test/test.main.js   |   4 +-
 .../streams/exponential/test/test.main.js     |   4 +-
 .../random/streams/f/test/test.main.js        |   4 +-
 .../random/streams/frechet/test/test.main.js  |   4 +-
 .../random/streams/gamma/test/test.main.js    |   4 +-
 .../streams/geometric/test/test.main.js       |   4 +-
 .../random/streams/gumbel/test/test.main.js   |   4 +-
 .../streams/hypergeometric/test/test.main.js  |   4 +-
 .../improved-ziggurat/test/test.main.js       |   4 +-
 .../random/streams/invgamma/test/test.main.js |   4 +-
 .../streams/kumaraswamy/test/test.main.js     |   4 +-
 .../random/streams/laplace/test/test.main.js  |   4 +-
 .../random/streams/levy/test/test.main.js     |   4 +-
 .../random/streams/logistic/test/test.main.js |   4 +-
 .../streams/lognormal/test/test.main.js       |   4 +-
 .../streams/minstd-shuffle/test/test.main.js  |   4 +-
 .../random/streams/minstd/test/test.main.js   |   4 +-
 .../random/streams/mt19937/test/test.main.js  |   4 +-
 .../negative-binomial/test/test.main.js       |   4 +-
 .../random/streams/normal/test/test.main.js   |   4 +-
 .../streams/pareto-type1/test/test.main.js    |   4 +-
 .../random/streams/poisson/test/test.main.js  |   4 +-
 .../random/streams/randi/test/test.main.js    |   2 +-
 .../random/streams/randn/test/test.main.js    |   2 +-
 .../random/streams/randu/test/test.main.js    |   2 +-
 .../random/streams/rayleigh/test/test.main.js |   4 +-
 .../random/streams/t/test/test.main.js        |   4 +-
 .../streams/triangular/test/test.main.js      |   4 +-
 .../random/streams/uniform/test/test.main.js  |   4 +-
 .../random/streams/weibull/test/test.main.js  |   4 +-
 .../random/strided/arcsine/test/test.main.js  |   8 +-
 .../strided/arcsine/test/test.ndarray.js      |   8 +-
 .../random/strided/beta/test/test.main.js     |   8 +-
 .../random/strided/beta/test/test.ndarray.js  |   8 +-
 .../strided/betaprime/test/test.main.js       |   8 +-
 .../strided/betaprime/test/test.ndarray.js    |   8 +-
 .../random/strided/cosine/test/test.main.js   |   8 +-
 .../strided/cosine/test/test.ndarray.js       |   8 +-
 .../discrete-uniform/test/test.main.js        |   8 +-
 .../discrete-uniform/test/test.ndarray.js     |   8 +-
 .../random/strided/gamma/test/test.main.js    |   8 +-
 .../random/strided/gamma/test/test.ndarray.js |   8 +-
 .../random/strided/invgamma/test/test.main.js |   8 +-
 .../strided/invgamma/test/test.ndarray.js     |   8 +-
 .../strided/lognormal/test/test.main.js       |   8 +-
 .../strided/lognormal/test/test.ndarray.js    |   8 +-
 .../strided/minstd-shuffle/test/test.main.js  |   4 +-
 .../minstd-shuffle/test/test.ndarray.js       |   4 +-
 .../minstd-shuffle/test/test.normalized.js    |   4 +-
 .../test/test.normalized.ndarray.js           |   4 +-
 .../random/strided/minstd/test/test.main.js   |   4 +-
 .../strided/minstd/test/test.ndarray.js       |   4 +-
 .../strided/minstd/test/test.normalized.js    |   4 +-
 .../minstd/test/test.normalized.ndarray.js    |   4 +-
 .../random/strided/mt19937/test/test.main.js  |   4 +-
 .../strided/mt19937/test/test.ndarray.js      |   4 +-
 .../strided/mt19937/test/test.normalized.js   |   4 +-
 .../mt19937/test/test.normalized.ndarray.js   |   4 +-
 .../random/strided/normal/test/test.main.js   |   8 +-
 .../strided/normal/test/test.ndarray.js       |   8 +-
 .../random/strided/randu/test/test.main.js    |   4 +-
 .../random/strided/randu/test/test.ndarray.js |   4 +-
 .../random/strided/uniform/test/test.main.js  |   8 +-
 .../strided/uniform/test/test.ndarray.js      |   8 +-
 .../random/strided/weibull/test/test.main.js  |   8 +-
 .../strided/weibull/test/test.ndarray.js      |   8 +-
 .../@stdlib/stats/anova1/test/test.js         |   2 +-
 .../@stdlib/stats/bartlett-test/test/test.js  |   4 +-
 .../arcsine/quantile/test/test.native.js      |  18 +--
 .../arcsine/quantile/test/test.quantile.js    |  18 +--
 .../bernoulli/quantile/test/test.native.js    |  14 +-
 .../bernoulli/quantile/test/test.quantile.js  |  14 +-
 .../base/dists/beta/mgf/test/test.mgf.js      |   2 +-
 .../base/dists/beta/mgf/test/test.native.js   |  36 ++---
 .../dists/cauchy/quantile/test/test.native.js |  26 ++--
 .../dists/cosine/quantile/test/test.native.js |  22 +--
 .../quantile/test/test.native.js              |  10 +-
 .../quantile/test/test.quantile.js            |  20 +--
 .../erlang/quantile/test/test.quantile.js     |  38 ++---
 .../exponential/quantile/test/test.native.js  |  22 +--
 .../quantile/test/test.quantile.js            |  22 +--
 .../dists/f/quantile/test/test.quantile.js    |  38 ++---
 .../frechet/quantile/test/test.quantile.js    |  40 +++---
 .../gamma/quantile/test/test.quantile.js      |  40 +++---
 .../geometric/quantile/test/test.native.js    |  14 +-
 .../geometric/quantile/test/test.quantile.js  |  14 +-
 .../base/dists/gumbel/mgf/test/test.mgf.js    |  26 ++--
 .../base/dists/gumbel/mgf/test/test.native.js |  26 ++--
 .../dists/gumbel/quantile/test/test.native.js |  26 ++--
 .../gumbel/quantile/test/test.quantile.js     |  26 ++--
 .../quantile/test/test.quantile.js            |  48 +++----
 .../invgamma/quantile/test/test.quantile.js   |  34 ++---
 .../dists/kumaraswamy/cdf/test/test.cdf.js    |  36 ++---
 .../dists/kumaraswamy/cdf/test/test.native.js |  36 ++---
 .../dists/kumaraswamy/kurtosis/test/test.js   |  34 ++---
 .../kumaraswamy/kurtosis/test/test.native.js  |  34 ++---
 .../kumaraswamy/logcdf/test/test.logcdf.js    |  36 ++---
 .../kumaraswamy/logcdf/test/test.native.js    |  36 ++---
 .../dists/kumaraswamy/pdf/test/test.pdf.js    |  36 ++---
 .../kumaraswamy/quantile/test/test.native.js  |  40 +++---
 .../quantile/test/test.quantile.js            |  40 +++---
 .../dists/kumaraswamy/skewness/test/test.js   |  34 ++---
 .../kumaraswamy/skewness/test/test.native.js  |  34 ++---
 .../laplace/quantile/test/test.native.js      |  26 ++--
 .../laplace/quantile/test/test.quantile.js    |  26 ++--
 .../dists/levy/quantile/test/test.native.js   |  22 +--
 .../dists/levy/quantile/test/test.quantile.js |  22 +--
 .../logistic/quantile/test/test.native.js     |  22 +--
 .../logistic/quantile/test/test.quantile.js   |  22 +--
 .../lognormal/quantile/test/test.quantile.js  |  24 ++--
 .../negative-binomial/mgf/test/test.mgf.js    |  28 ++--
 .../negative-binomial/mgf/test/test.native.js |  28 ++--
 .../quantile/test/test.quantile.js            |  24 ++--
 .../dists/normal/quantile/test/test.native.js |  22 +--
 .../normal/quantile/test/test.quantile.js     |  22 +--
 .../pareto-type1/quantile/test/test.native.js |  38 ++---
 .../quantile/test/test.quantile.js            |  38 ++---
 .../poisson/quantile/test/test.quantile.js    |  20 +--
 .../base/dists/rayleigh/mgf/test/test.mgf.js  |  10 +-
 .../dists/rayleigh/mgf/test/test.native.js    |  10 +-
 .../rayleigh/quantile/test/test.native.js     |  14 +-
 .../rayleigh/quantile/test/test.quantile.js   |  14 +-
 .../signrank/quantile/test/test.quantile.js   |  18 +--
 .../dists/t/quantile/test/test.quantile.js    |  16 +--
 .../triangular/quantile/test/test.native.js   |  20 +--
 .../triangular/quantile/test/test.quantile.js |  20 +--
 .../uniform/quantile/test/test.native.js      |  18 +--
 .../uniform/quantile/test/test.quantile.js    |  18 +--
 .../base/dists/weibull/mgf/test/test.mgf.js   |  36 ++---
 .../dists/weibull/mgf/test/test.native.js     |  36 ++---
 .../weibull/quantile/test/test.quantile.js    |  38 ++---
 .../@stdlib/stats/chi2gof/test/test.js        |   6 +-
 .../@stdlib/stats/chi2test/test/test.js       |   4 +-
 .../@stdlib/stats/fligner-test/test/test.js   |   4 +-
 .../@stdlib/stats/kruskal-test/test/test.js   |   4 +-
 .../@stdlib/stats/kstest/test/test.js         |   4 +-
 .../@stdlib/stats/levene-test/test/test.js    |   4 +-
 .../streams/node/from-array/test/test.main.js |   6 +-
 .../from-circular-array/test/test.main.js     |   6 +-
 .../node/from-constant/test/test.main.js      |   6 +-
 .../node/from-iterator/test/test.main.js      |   8 +-
 .../node/from-strided-array/test/test.main.js |   4 +-
 .../string/base/starts-with/test/test.js      |  52 +++----
 .../string/base/starts-with/test/test.main.js |  52 +++----
 .../base/starts-with/test/test.polyfill.js    |  52 +++----
 .../string/base/stickycase/test/test.js       |   6 +-
 .../@stdlib/string/starts-with/test/test.js   |  52 +++----
 .../@stdlib/time/day-of-quarter/test/test.js  |   2 +-
 .../@stdlib/time/day-of-year/test/test.js     |   2 +-
 .../@stdlib/time/days-in-month/test/test.js   |   2 +-
 .../@stdlib/time/days-in-year/test/test.js    |   2 +-
 .../@stdlib/time/hours-in-month/test/test.js  |   2 +-
 .../@stdlib/time/hours-in-year/test/test.js   |   2 +-
 .../time/iso-weeks-in-year/test/test.js       |   2 +-
 .../time/minutes-in-month/test/test.js        |   2 +-
 .../@stdlib/time/minutes-in-year/test/test.js |   2 +-
 .../@stdlib/time/quarter-of-year/test/test.js |   2 +-
 .../time/seconds-in-month/test/test.js        |   2 +-
 .../@stdlib/time/seconds-in-year/test/test.js |   2 +-
 .../@stdlib/utils/any-by-right/test/test.js   |  20 +--
 .../@stdlib/utils/any-by/test/test.js         |  20 +--
 .../@stdlib/utils/any-in-by/test/test.js      |   6 +-
 .../@stdlib/utils/any-own-by/test/test.js     |   8 +-
 .../@stdlib/utils/any/test/test.js            |  14 +-
 .../async/any-by-right/test/test.main.js      |  38 ++---
 .../utils/async/any-by/test/test.main.js      |  38 ++---
 .../async/every-by-right/test/test.main.js    |  38 ++---
 .../utils/async/every-by/test/test.main.js    |  38 ++---
 .../async/none-by-right/test/test.main.js     |  38 ++---
 .../utils/async/none-by/test/test.main.js     |  38 ++---
 .../async/some-by-right/test/test.main.js     |  38 ++---
 .../utils/async/some-by/test/test.main.js     |  38 ++---
 .../@stdlib/utils/deep-set/test/test.dset.js  |  14 +-
 .../@stdlib/utils/deep-set/test/test.js       |  10 +-
 .../@stdlib/utils/every-by-right/test/test.js |  20 +--
 .../@stdlib/utils/every-by/test/test.js       |  20 +--
 .../@stdlib/utils/every/test/test.js          |  14 +-
 .../@stdlib/utils/none-by-right/test/test.js  |  20 +--
 .../@stdlib/utils/none-by/test/test.js        |  20 +--
 .../@stdlib/utils/none-own-by/test/test.js    |   4 +-
 .../@stdlib/utils/none/test/test.js           |  14 +-
 .../@stdlib/utils/some-by-right/test/test.js  |  20 +--
 .../@stdlib/utils/some-by/test/test.js        |  20 +--
 .../@stdlib/utils/some-own-by/test/test.js    |  10 +-
 .../@stdlib/utils/some/test/test.js           |  14 +-
 .../@stdlib/utils/type-of/test/test.check.js  |   8 +-
 753 files changed, 4439 insertions(+), 4459 deletions(-)

diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.data.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.data.js
index 608d0c4e1ddd..c07d9704936c 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.data.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.data.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.strictEqual( typeof data( 'Big bug', setup() ), 'string', 'returns a string' );
+	t.strictEqual( typeof data( 'Big bug', setup() ), 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.data.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.data.js
index fe8e75921db4..7e1146c90fcd 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.data.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.data.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.strictEqual( typeof data( 'sum_series', setup() ), 'string', 'returns a string' );
+	t.strictEqual( typeof data( 'sum_series', setup() ), 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.data.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.data.js
index 7e92b50931e8..a4245e2897f8 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.data.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.data.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.strictEqual( typeof data( setup() ), 'string', 'returns a string' );
+	t.strictEqual( typeof data( setup() ), 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.data.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.data.js
index 011720afc101..6014ef3300de 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.data.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.data.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.strictEqual( typeof data( setup() ), 'string', 'returns a string' );
+	t.strictEqual( typeof data( setup() ), 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/licenses/insert-header/test/test.js b/lib/node_modules/@stdlib/_tools/licenses/insert-header/test/test.js
index c1740fe4b318..c36975a9654f 100644
--- a/lib/node_modules/@stdlib/_tools/licenses/insert-header/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/licenses/insert-header/test/test.js
@@ -115,7 +115,7 @@ tape( 'the function inserts a license header into a source code string', functio
 
 	actual = insertHeader( src, HEADER );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -140,7 +140,7 @@ tape( 'the function inserts a license header into a source code string (empty he
 
 	actual = insertHeader( src, '' );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -166,7 +166,7 @@ tape( 'the function inserts a license header into a source code string (buffer h
 
 	actual = insertHeader( src, string2buffer( HEADER ) );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -192,7 +192,7 @@ tape( 'the function inserts a license header into a source code buffer', functio
 
 	actual = insertHeader( src, HEADER );
 
-	t.strictEqual( isBuffer( actual ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.toString(), expected, 'returns expected value' );
 	t.end();
 });
@@ -218,7 +218,7 @@ tape( 'the function inserts a license header into a source code buffer (buffer h
 
 	actual = insertHeader( src, string2buffer( HEADER ) );
 
-	t.strictEqual( isBuffer( actual ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.toString(), expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/licenses/remove-header/test/test.js b/lib/node_modules/@stdlib/_tools/licenses/remove-header/test/test.js
index f5a92403dc1f..9b483bc4a781 100644
--- a/lib/node_modules/@stdlib/_tools/licenses/remove-header/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/licenses/remove-header/test/test.js
@@ -114,7 +114,7 @@ tape( 'the function removes a license header from a source code string', functio
 
 	actual = removeHeader( src, HEADER+'\n' );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -139,7 +139,7 @@ tape( 'the function removes a license header from a source code string (empty he
 
 	actual = removeHeader( src, '' );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -164,7 +164,7 @@ tape( 'the function removes a license header from a source code string (buffer h
 
 	actual = removeHeader( src, string2buffer( HEADER+'\n' ) );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -189,7 +189,7 @@ tape( 'the function removes a license header from a source code string (empty bu
 
 	actual = removeHeader( src, string2buffer( '' ) );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -214,7 +214,7 @@ tape( 'the function removes a license header from a source code string (regular
 
 	actual = removeHeader( src, /\/\/ @license Apache-2\.0\n\n/ );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -241,7 +241,7 @@ tape( 'the function removes a multi-line license header from a source code strin
 
 	actual = removeHeader( src, /\/\*\*\n\* @license Apache-2\.0\n\*\/\n\n/ );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -266,7 +266,7 @@ tape( 'the function removes a license header from a source code buffer', functio
 
 	actual = removeHeader( src, HEADER+'\n' );
 
-	t.strictEqual( isBuffer( actual ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.toString(), expected, 'returns expected value' );
 	t.end();
 });
@@ -291,7 +291,7 @@ tape( 'the function removes a license header from a source code buffer (empty he
 
 	actual = removeHeader( src, '' );
 
-	t.strictEqual( isBuffer( actual ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.toString(), expected, 'returns expected value' );
 	t.end();
 });
@@ -316,7 +316,7 @@ tape( 'the function removes a license header from a source code buffer (buffer h
 
 	actual = removeHeader( src, string2buffer( HEADER+'\n' ) );
 
-	t.strictEqual( isBuffer( actual ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.toString(), expected, 'returns expected value' );
 	t.end();
 });
@@ -341,7 +341,7 @@ tape( 'the function removes a license header from a source code buffer (regular
 
 	actual = removeHeader( src, /\/\/ @license Apache-2\.0\n\n/ );
 
-	t.strictEqual( isBuffer( actual ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.toString(), expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/licenses/update-header/test/test.js b/lib/node_modules/@stdlib/_tools/licenses/update-header/test/test.js
index 6eaffa405a77..aec709c74bb1 100644
--- a/lib/node_modules/@stdlib/_tools/licenses/update-header/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/licenses/update-header/test/test.js
@@ -143,7 +143,7 @@ tape( 'the function updates a license header in a source code string', function
 
 	actual = updateHeader( src, OLD_HEADER, NEW_HEADER );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -168,7 +168,7 @@ tape( 'the function updates a license header in a source code string (empty new
 
 	actual = updateHeader( src, OLD_HEADER+'\n', '' );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -193,7 +193,7 @@ tape( 'the function updates a license header in a source code string (empty old
 
 	actual = updateHeader( src, '', NEW_HEADER+'\n' );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -216,7 +216,7 @@ tape( 'the function updates a license header in a source code string (empty head
 
 	actual = updateHeader( src, '', '' );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -242,7 +242,7 @@ tape( 'the function updates a license header in a source code string (buffer old
 
 	actual = updateHeader( src, string2buffer( OLD_HEADER ), NEW_HEADER );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -268,7 +268,7 @@ tape( 'the function updates a license header in a source code string (buffer new
 
 	actual = updateHeader( src, OLD_HEADER, string2buffer( NEW_HEADER ) );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -294,7 +294,7 @@ tape( 'the function updates a license header in a source code string (regular ex
 
 	actual = updateHeader( src, /\/\/ @license MIT\n\n/, NEW_HEADER+'\n' );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -322,7 +322,7 @@ tape( 'the function updates a multi-line license header in a source code string
 
 	actual = updateHeader( src, /\/\*\*\n\* @license Apache-2\.0\n\*\/\n\n/, NEW_HEADER );
 
-	t.strictEqual( isString( actual ), true, 'returns a string' );
+	t.strictEqual( isString( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
@@ -348,7 +348,7 @@ tape( 'the function updates a license header in a source code buffer', function
 
 	actual = updateHeader( src, OLD_HEADER, NEW_HEADER );
 
-	t.strictEqual( isBuffer( actual ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.toString(), expected, 'returns expected value' );
 	t.end();
 });
@@ -374,7 +374,7 @@ tape( 'the function updates a license header in a source code buffer (buffer old
 
 	actual = updateHeader( src, string2buffer( OLD_HEADER ), NEW_HEADER );
 
-	t.strictEqual( isBuffer( actual ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.toString(), expected, 'returns expected value' );
 	t.end();
 });
@@ -400,7 +400,7 @@ tape( 'the function updates a license header in a source code buffer (regular ex
 
 	actual = updateHeader( src, /\/\/ @license MIT\n/, NEW_HEADER );
 
-	t.strictEqual( isBuffer( actual ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.toString(), expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.escape_html.js b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.escape_html.js
index 86fdee4751cc..92629a55e196 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.escape_html.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.escape_html.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a string', function test( t ) {
 	var str = escapeHTML( 'beep' );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.render.js b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.render.js
index 4f58e6fa7e87..c0d979923844 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.render.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/img-svg-equation/test/test.render.js
@@ -48,7 +48,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a string', function test( t ) {
 	var str = render( setup() );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.escape_html.js b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.escape_html.js
index 86fdee4751cc..92629a55e196 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.escape_html.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.escape_html.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a string', function test( t ) {
 	var str = escapeHTML( 'beep' );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.render.js b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.render.js
index 159d8cd3d055..23af9f27056b 100644
--- a/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.render.js
+++ b/lib/node_modules/@stdlib/_tools/markdown/inline-svg-equation/test/test.render.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a string', function test( t ) {
 	var str = render( setup() );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/package-json/validate/test/test.js b/lib/node_modules/@stdlib/_tools/package-json/validate/test/test.js
index b91b4955631a..97fd45db982f 100644
--- a/lib/node_modules/@stdlib/_tools/package-json/validate/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/package-json/validate/test/test.js
@@ -40,7 +40,7 @@ tape( 'the function returns `true` if provided a valid `package.json`', function
 	pkg = require( './../package.json' );
 	bool = isValid( pkg );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( isValid.errors, null, 'errors property is `null`' );
 	t.end();
 });
@@ -54,7 +54,7 @@ tape( 'the function returns `false` if provided an invalid `package.json`', func
 	};
 	bool = isValid( pkg );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.strictEqual( isArray( isValid.errors ), true, 'errors property is an array' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.root.js b/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.root.js
index 7607eb5d8b3f..a1702655745f 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.root.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.root.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.strictEqual( typeof getRoot( '' ), 'string', 'returns a string' );
+	t.strictEqual( typeof getRoot( '' ), 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.root.js b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.root.js
index 7607eb5d8b3f..a1702655745f 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.root.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.root.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.strictEqual( typeof getRoot( '' ), 'string', 'returns a string' );
+	t.strictEqual( typeof getRoot( '' ), 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.root.js b/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.root.js
index 7607eb5d8b3f..a1702655745f 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.root.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.root.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.strictEqual( typeof getRoot( '' ), 'string', 'returns a string' );
+	t.strictEqual( typeof getRoot( '' ), 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/repl-txt/validate/test/test.js b/lib/node_modules/@stdlib/_tools/repl-txt/validate/test/test.js
index 2d96f04de00b..0c026dfaa6be 100644
--- a/lib/node_modules/@stdlib/_tools/repl-txt/validate/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/repl-txt/validate/test/test.js
@@ -56,7 +56,7 @@ tape( 'the function returns `true` if provided a valid `repl.txt`', function tes
 
 	bool = isValid( REPL1 );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( isValid.errors, null, 'errors property is `null`' );
 	t.end();
 });
@@ -66,7 +66,7 @@ tape( 'the function returns `true` if provided a valid `repl.txt` (multiple docu
 
 	bool = isValid( REPL2 );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( isValid.errors, null, 'errors property is `null`' );
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns `false` if provided an invalid `repl.txt` (invalid s
 
 	bool = isValid( REPL3 );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.strictEqual( isArray( isValid.errors ), true, 'errors property is an array' );
 	t.end();
 });
@@ -86,7 +86,7 @@ tape( 'the function returns `false` if provided an invalid `repl.txt` (unknown s
 
 	bool = isValid( REPL4 );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.strictEqual( isArray( isValid.errors ), true, 'errors property is an array' );
 	t.end();
 });
@@ -96,7 +96,7 @@ tape( 'the function returns `false` if provided an invalid `repl.txt` (line with
 
 	bool = isValid( REPL5 );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.strictEqual( isArray( isValid.errors ), true, 'errors property is an array' );
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'the function returns `false` if provided an invalid `repl.txt` (invalid p
 
 	bool = isValid( REPL6 );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.strictEqual( isArray( isValid.errors ), true, 'errors property is an array' );
 	t.end();
 });
@@ -116,7 +116,7 @@ tape( 'the function returns `false` if provided an invalid `repl.txt` (invalid "
 
 	bool = isValid( REPL7 );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.strictEqual( isArray( isValid.errors ), true, 'errors property is an array' );
 	t.end();
 });
@@ -126,7 +126,7 @@ tape( 'the function returns `false` if provided an invalid `repl.txt` (invalid t
 
 	bool = isValid( REPL8 );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.strictEqual( isArray( isValid.errors ), true, 'errors property is an array' );
 	t.end();
 });
@@ -136,7 +136,7 @@ tape( 'the function returns `false` if provided an invalid `repl.txt` (invalid t
 
 	bool = isValid( REPL9 );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.strictEqual( isArray( isValid.errors ), true, 'errors property is an array' );
 	t.end();
 });
@@ -146,7 +146,7 @@ tape( 'the function returns `true` if provided a valid `repl.txt` (multi-line pa
 
 	bool = isValid( REPL10 );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( isValid.errors, null, 'errors property is `null`' );
 	t.end();
 });
@@ -156,7 +156,7 @@ tape( 'the function returns `true` if provided a valid `repl.txt` (TODO comment)
 
 	bool = isValid( REPL11 );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( isValid.errors, null, 'errors property is `null`' );
 	t.end();
 });
@@ -166,7 +166,7 @@ tape( 'the function returns `true` if provided a valid `repl.txt` (multi-line pa
 
 	bool = isValid( REPL12 );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( isValid.errors, null, 'errors property is `null`' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/utils/jsdelivr-url/test/test.url.js b/lib/node_modules/@stdlib/_tools/utils/jsdelivr-url/test/test.url.js
index 21ca15c2db95..d7b94a97be7d 100644
--- a/lib/node_modules/@stdlib/_tools/utils/jsdelivr-url/test/test.url.js
+++ b/lib/node_modules/@stdlib/_tools/utils/jsdelivr-url/test/test.url.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a string', function test( t ) {
 	var u = url( setup() );
-	t.strictEqual( typeof u, 'string', 'returns a string' );
+	t.strictEqual( typeof u, 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.cli.js b/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.cli.js
index 50735731df46..a7bdb3575741 100644
--- a/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.cli.js
+++ b/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.cli.js
@@ -162,7 +162,7 @@ tape( 'the command-line interface converts a TeX or LaTeX string to an SVG (no o
 			t.fail( error.message );
 		} else {
 			svg = stdout.toString();
-			t.strictEqual( typeof svg, 'string', 'returns a string' );
+			t.strictEqual( typeof svg, 'string', 'returns expected value' );
 			t.strictEqual( svg.substring( 0, 4 ), '<svg', 'svg tag' );
 			t.strictEqual( svg.substring( svg.length-7, svg.length-1 ), '</svg>', 'closing svg tag' );
 			t.strictEqual( svg.substring( svg.length-1 ), '\n', 'new line' );
@@ -196,7 +196,7 @@ tape( 'the command-line interface converts a TeX or LaTeX string to an SVG (opti
 			t.fail( error.message );
 		} else {
 			svg = stdout.toString();
-			t.strictEqual( typeof svg, 'string', 'returns a string' );
+			t.strictEqual( typeof svg, 'string', 'returns expected value' );
 			t.strictEqual( svg.substring( 0, 4 ), '<svg', 'svg tag' );
 			t.strictEqual( svg.substring( svg.length-7, svg.length-1 ), '</svg>', 'closing svg tag' );
 			t.strictEqual( svg.substring( svg.length-1 ), '\n', 'new line' );
diff --git a/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.factory.js b/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.factory.js
index 1bb933660e08..df079043ba7f 100644
--- a/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.factory.js
@@ -159,7 +159,7 @@ tape( 'the function returns a function which converts an input string to an SVG'
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( typeof svg, 'string', 'returns a string' );
+		t.strictEqual( typeof svg, 'string', 'returns expected value' );
 		t.strictEqual( svg.substring( 0, 4 ), '<svg', 'svg tag' );
 		t.strictEqual( svg.substring( svg.length-6 ), '</svg>', 'closing svg tag' );
 		t.strictEqual( svg, TEST1, 'expected value' );
@@ -184,7 +184,7 @@ tape( 'the function returns a function which converts an input string to an SVG
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( typeof svg, 'string', 'returns a string' );
+		t.strictEqual( typeof svg, 'string', 'returns expected value' );
 		t.strictEqual( svg.substring( 0, 4 ), '<svg', 'svg tag' );
 		t.strictEqual( svg.substring( svg.length-6 ), '</svg>', 'closing svg tag' );
 		t.strictEqual( svg, TEST3, 'expected value' );
diff --git a/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.main.js b/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.main.js
index 75b405122e39..95311e44b717 100644
--- a/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.main.js
@@ -207,7 +207,7 @@ tape( 'the function converts an input string to an SVG', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( typeof svg, 'string', 'returns a string' );
+		t.strictEqual( typeof svg, 'string', 'returns expected value' );
 		t.strictEqual( svg.substring( 0, 4 ), '<svg', 'svg tag' );
 		t.strictEqual( svg.substring( svg.length-6 ), '</svg>', 'closing svg tag' );
 		t.strictEqual( svg, TEST1, 'expected value' );
@@ -228,7 +228,7 @@ tape( 'the function converts an input string to an SVG (options)', function test
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( typeof svg, 'string', 'returns a string' );
+		t.strictEqual( typeof svg, 'string', 'returns expected value' );
 		t.strictEqual( svg.substring( 0, 4 ), '<svg', 'svg tag' );
 		t.strictEqual( svg.substring( svg.length-6 ), '</svg>', 'closing svg tag' );
 		t.strictEqual( svg, TEST3, 'expected value' );
diff --git a/lib/node_modules/@stdlib/assert/deep-equal/test/test.js b/lib/node_modules/@stdlib/assert/deep-equal/test/test.js
index 740eeb67cdd2..4c166cd4723b 100644
--- a/lib/node_modules/@stdlib/assert/deep-equal/test/test.js
+++ b/lib/node_modules/@stdlib/assert/deep-equal/test/test.js
@@ -62,25 +62,25 @@ tape( 'the function compares boolean, string, and number primitives using strict
 	for ( i = 1; i < values.length; i++ ) {
 		a = values[ i-1 ];
 		b = values[ i ];
-		t.strictEqual( deepEqual( a, a ), true, 'returns true' );
-		t.strictEqual( deepEqual( b, b ), true, 'returns true' );
-		t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+		t.strictEqual( deepEqual( a, a ), true, 'returns expected value' );
+		t.strictEqual( deepEqual( b, b ), true, 'returns expected value' );
+		t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` for two `NaN`s', function test( t ) {
-	t.strictEqual( deepEqual( NaN, NaN ), false, 'returns false' );
+	t.strictEqual( deepEqual( NaN, NaN ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` for two `null`s', function test( t ) {
-	t.strictEqual( deepEqual( null, null ), true, 'returns true' );
+	t.strictEqual( deepEqual( null, null ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` for two `undefined`s', function test( t ) {
-	t.strictEqual( deepEqual( void 0, void 0 ), true, 'returns true' );
+	t.strictEqual( deepEqual( void 0, void 0 ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -89,10 +89,10 @@ tape( 'the function compares `arguments` objects', function test( t ) {
 	var b = returnArgs( 1, 2, 3 );
 	var c = returnArgs( 3, 2, 1 );
 
-	t.strictEqual( deepEqual( a, b ), true, 'returns true' );
-	t.strictEqual( deepEqual( a, c ), false, 'returns false' );
-	t.strictEqual( deepEqual( b, c ), false, 'returns false' );
-	t.strictEqual( deepEqual( a, [ 1, 2, 3 ] ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), true, 'returns expected value' );
+	t.strictEqual( deepEqual( a, c ), false, 'returns expected value' );
+	t.strictEqual( deepEqual( b, c ), false, 'returns expected value' );
+	t.strictEqual( deepEqual( a, [ 1, 2, 3 ] ), false, 'returns expected value' );
 	t.end();
 
 	function returnArgs() {
@@ -101,9 +101,9 @@ tape( 'the function compares `arguments` objects', function test( t ) {
 });
 
 tape( 'the function distinguishes between `null`, `NaN`, and `undefined`', function test( t ) {
-	t.strictEqual( deepEqual( NaN, null ), false, 'returns false' );
-	t.strictEqual( deepEqual( NaN, void 0 ), false, 'returns false' );
-	t.strictEqual( deepEqual( null, void 0 ), false, 'returns false' );
+	t.strictEqual( deepEqual( NaN, null ), false, 'returns expected value' );
+	t.strictEqual( deepEqual( NaN, void 0 ), false, 'returns expected value' );
+	t.strictEqual( deepEqual( null, void 0 ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -113,35 +113,35 @@ tape( 'the function returns `false` if provided a primitive and an object type',
 
 	a = 'abc';
 	b = new String( 'abc' ); // eslint-disable-line no-new-wrappers
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 
 	a = 'abc';
 	b = string2buffer( 'abc' );
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
-	t.strictEqual( deepEqual( b, a ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
+	t.strictEqual( deepEqual( b, a ), false, 'returns expected value' );
 
 	a = null;
 	b = [];
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 
 	a = true;
-	b = new Boolean( true ); // eslint-disable-line no-new-wrappers
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	b = new Boolean( true );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 
 	a = 3.12;
-	b = new Number( 3.12 ); // eslint-disable-line no-new-wrappers
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	b = new Number( 3.12 );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `false` for objects of different types', function test( t ) {
-	t.strictEqual( deepEqual( [], {} ), false, 'returns false' );
-	t.strictEqual( deepEqual( [], new RegExp( '[0-9]' ) ), false, 'returns false' ); // eslint-disable-line prefer-regex-literals
-	t.strictEqual( deepEqual( new Date(), new RegExp( '[0-9]' ) ), false, 'returns false' ); // eslint-disable-line prefer-regex-literals
-	t.strictEqual( deepEqual( new Int8Array(), [] ), false, 'returns false' );
-	t.strictEqual( deepEqual( string2buffer( 'xyz' ), new String( 'xyz' ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
-	t.strictEqual( deepEqual( array2buffer( [ 1, 2, 3 ] ), [ 1, 2, 3 ] ), false, 'returns false' );
+	t.strictEqual( deepEqual( [], {} ), false, 'returns expected value' );
+	t.strictEqual( deepEqual( [], new RegExp( '[0-9]' ) ), false, 'returns expected value' ); // eslint-disable-line prefer-regex-literals
+	t.strictEqual( deepEqual( new Date(), new RegExp( '[0-9]' ) ), false, 'returns expected value' ); // eslint-disable-line prefer-regex-literals
+	t.strictEqual( deepEqual( new Int8Array(), [] ), false, 'returns expected value' );
+	t.strictEqual( deepEqual( string2buffer( 'xyz' ), new String( 'xyz' ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( deepEqual( array2buffer( [ 1, 2, 3 ] ), [ 1, 2, 3 ] ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -151,10 +151,10 @@ tape( 'the function checks deep equality of `Date` objects', function test( t )
 	var b = new Date( 1537406608936 );
 	var c = new Date();
 
-	t.strictEqual( deepEqual( a, b ), true, 'returns true' );
-	t.strictEqual( deepEqual( c, c ), true, 'returns true' );
-	t.strictEqual( deepEqual( a, c ), false, 'returns false' );
-	t.strictEqual( deepEqual( b, c ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), true, 'returns expected value' );
+	t.strictEqual( deepEqual( c, c ), true, 'returns expected value' );
+	t.strictEqual( deepEqual( a, c ), false, 'returns expected value' );
+	t.strictEqual( deepEqual( b, c ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -163,10 +163,10 @@ tape( 'the function checks equality of `RegExp` objects', function test( t ) {
 	var b = /[0-9]+/gi;
 	var c = /[0-9]+/;
 
-	t.strictEqual( deepEqual( a, b ), true, 'returns true' );
-	t.strictEqual( deepEqual( c, c ), true, 'returns true' );
-	t.strictEqual( deepEqual( a, c ), false, 'returns false' );
-	t.strictEqual( deepEqual( b, c ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), true, 'returns expected value' );
+	t.strictEqual( deepEqual( c, c ), true, 'returns expected value' );
+	t.strictEqual( deepEqual( a, c ), false, 'returns expected value' );
+	t.strictEqual( deepEqual( b, c ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -186,9 +186,9 @@ tape( 'the function checks equality of `Error` objects', function test( t ) {
 	for ( i = 1; i < values.length; i++ ) {
 		a = values[ i-1 ];
 		b = values[ i ];
-		t.strictEqual( deepEqual( a, a ), true, 'returns true' );
-		t.strictEqual( deepEqual( b, b ), true, 'returns true' );
-		t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+		t.strictEqual( deepEqual( a, a ), true, 'returns expected value' );
+		t.strictEqual( deepEqual( b, b ), true, 'returns expected value' );
+		t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -199,11 +199,11 @@ tape( 'the function checks deep equality of `Buffers`', function test( t ) {
 	var c = string2buffer( 'abcdef' );
 	var d = string2buffer( 'abc' );
 
-	t.strictEqual( deepEqual( a, b ), true, 'returns true' );
-	t.strictEqual( deepEqual( a, c ), false, 'returns false' );
-	t.strictEqual( deepEqual( b, c ), false, 'returns false' );
-	t.strictEqual( deepEqual( c, d ), false, 'returns false' );
-	t.strictEqual( deepEqual( a, d ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), true, 'returns expected value' );
+	t.strictEqual( deepEqual( a, c ), false, 'returns expected value' );
+	t.strictEqual( deepEqual( b, c ), false, 'returns expected value' );
+	t.strictEqual( deepEqual( c, d ), false, 'returns expected value' );
+	t.strictEqual( deepEqual( a, d ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -213,35 +213,35 @@ tape( 'the function compares arrays for deep equality', function test( t ) {
 
 	a = [ 'beep', 'boop', 'baz' ];
 	b = [ 'beep', 'boop', 'baz' ];
-	t.strictEqual( deepEqual( a, b ), true, 'returns true' );
+	t.strictEqual( deepEqual( a, b ), true, 'returns expected value' );
 	b[ 1 ] = 'bap';
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 	b = [];
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 
 	a = [ true, false, true ];
 	b = [ true, false, true ];
-	t.strictEqual( deepEqual( a, b ), true, 'returns true' );
+	t.strictEqual( deepEqual( a, b ), true, 'returns expected value' );
 	b[ 1 ] = true;
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 
 	a = [ 0, 1, 0 ];
 	b = [ 0, 1, 0 ];
-	t.strictEqual( deepEqual( a, b ), true, 'returns true' );
+	t.strictEqual( deepEqual( a, b ), true, 'returns expected value' );
 	b = [ 1, 1, 1 ];
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 
 	a = [ null, null, null ];
 	b = [ null, null, null ];
-	t.strictEqual( deepEqual( a, b ), true, 'returns true' );
+	t.strictEqual( deepEqual( a, b ), true, 'returns expected value' );
 	b = [ NaN, NaN, NaN ];
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 	b = [ void 0, void 0, void 0 ];
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 
 	a = [ void 0, void 0, void 0 ];
 	b = [ void 0, void 0, void 0 ];
-	t.strictEqual( deepEqual( a, b ), true, 'returns true' );
+	t.strictEqual( deepEqual( a, b ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -252,10 +252,10 @@ tape( 'the function compares nested arrays for deep equality', function test( t
 
 	a = [ [ 1, 2 ], [ true, false ] ];
 	b = [ [ 1, 2 ], [ true, false ] ];
-	t.strictEqual( deepEqual( a, b ), true, 'returns true' );
+	t.strictEqual( deepEqual( a, b ), true, 'returns expected value' );
 
 	b = [ [ true, false ], [ 1, 2 ] ];
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -270,9 +270,9 @@ tape( 'the function compares plain objects for deep equality', function test( t
 	b = {
 		'beep': 'boop'
 	};
-	t.strictEqual( deepEqual( a, b ), true, 'returns true' );
+	t.strictEqual( deepEqual( a, b ), true, 'returns expected value' );
 	b.beep = 'baz';
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 
 	a = {
 		'beep': [ 0 ]
@@ -280,7 +280,7 @@ tape( 'the function compares plain objects for deep equality', function test( t
 	b = {
 		'beep': 0
 	};
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 
 	a = {
 		'beep': 'boop',
@@ -290,8 +290,8 @@ tape( 'the function compares plain objects for deep equality', function test( t
 		'beep': 'boop',
 		'baz': 23
 	};
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
-	t.strictEqual( deepEqual( b, a ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
+	t.strictEqual( deepEqual( b, a ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -303,7 +303,7 @@ tape( 'the function distinguishes between array-like objects and arrays', functi
 		'1': 1,
 		'length': 2
 	};
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -313,9 +313,9 @@ tape( 'the function compares constructor instances for deep equality', function
 
 	a = new Person( 'Methuselah', 969 );
 	b = new Person( 'Methuselah', 969 );
-	t.strictEqual( deepEqual( a, b ), true, 'returns true' );
+	t.strictEqual( deepEqual( a, b ), true, 'returns expected value' );
 	b.beep = 'boop';
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 
 	t.end();
 
@@ -332,11 +332,11 @@ tape( 'the function returns `false` for instances of constructors with different
 
 	a = new Person( 'Methuselah', 969 );
 	b = new Person( 'Methuselah', 969 );
-	t.strictEqual( deepEqual( a, b ), true, 'returns true' );
+	t.strictEqual( deepEqual( a, b ), true, 'returns expected value' );
 
 	inherit( Person, Foo );
 	b = new Person( 'Methuselah', 969 );
-	t.strictEqual( deepEqual( a, b ), false, 'returns false' );
+	t.strictEqual( deepEqual( a, b ), false, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.has.js b/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.has.js
index 897bd704fbdf..bb3ce92d5d83 100644
--- a/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.has.js
+++ b/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.has.js
@@ -47,7 +47,7 @@ tape( 'the function returns `true` if an object has a specified path', function
 	path = [ 'a', 'b', 'c' ];
 
 	bool = has( obj, path );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -66,7 +66,7 @@ tape( 'the function returns `true` if an object has a specified path', function
 	path = [ 'a', '0', 'b', '0', 'c' ];
 
 	bool = has( obj, path );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,7 +86,7 @@ tape( 'the function returns `false` if an object does not have a specified path'
 	path = [ 'a', 'b', 'c', 'd', 'e' ];
 
 	bool = has( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -105,7 +105,7 @@ tape( 'the function returns `false` if an object does not have a specified path'
 	path = [ '0', 'a', '0', 'b', '0', 'e' ];
 
 	bool = has( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -119,13 +119,13 @@ tape( 'the function returns `false` if provided an empty object', function test(
 	obj = {};
 
 	bool = has( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	path = [];
 	obj = {};
 
 	bool = has( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -141,13 +141,13 @@ tape( 'the function returns `false` if provided an empty key path', function tes
 	};
 
 	bool = has( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	path = [];
 	obj = {};
 
 	bool = has( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -167,11 +167,11 @@ tape( 'the function only returns `true` for "own" properties', function test( t
 
 	path = [ 'a' ];
 	bool = has( foo, path );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	path = [ 'c' ];
 	bool = has( foo, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -189,7 +189,7 @@ tape( 'the function coerces path values to strings', function test( t ) {
 
 	path = [ 'a', {} ];
 	bool = has( obj, path );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.js b/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.js
index e98c15f7b7b5..b44625a50026 100644
--- a/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/deep-has-own-property/test/test.js
@@ -168,7 +168,7 @@ tape( 'the function returns `true` if an object has a specified path (delimited
 		}
 	};
 	bool = deepHasOwnProp( obj, 'a.b.c' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -185,7 +185,7 @@ tape( 'the function returns `true` if an object has a specified path (delimited
 		]
 	};
 	bool = deepHasOwnProp( obj, 'a.0.b.0.c' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -204,7 +204,7 @@ tape( 'the function returns `true` if an object has a specified path (key array)
 	};
 	path = [ 'a', 'b', 'c' ];
 	bool = deepHasOwnProp( obj, path );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -222,7 +222,7 @@ tape( 'the function returns `true` if an object has a specified path (key array)
 	};
 	path = [ 'a', '0', 'b', '0', 'c' ];
 	bool = deepHasOwnProp( obj, path );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -243,7 +243,7 @@ tape( 'the function returns `true` if an object has a specified path (custom del
 		'sep': '/'
 	};
 	bool = deepHasOwnProp( obj, 'a/b/c', opts );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -263,7 +263,7 @@ tape( 'the function returns `true` if an object has a specified path (custom del
 		'sep': '/'
 	};
 	bool = deepHasOwnProp( obj, 'a/0/b/0/c', opts );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -280,7 +280,7 @@ tape( 'the function returns `false` if an object does not have a specified path
 		}
 	};
 	bool = deepHasOwnProp( obj, 'a.b.c.d.e' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -297,7 +297,7 @@ tape( 'the function returns `false` if an object does not have a specified path
 		]
 	};
 	bool = deepHasOwnProp( obj, '0.a.0.b.0.e' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -316,7 +316,7 @@ tape( 'the function returns `false` if an object does not have a specified path
 	};
 	path = [ 'a', 'b', 'c', 'd', 'e' ];
 	bool = deepHasOwnProp( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -334,7 +334,7 @@ tape( 'the function returns `false` if an object does not have a specified path
 	};
 	path = [ '0', 'a', '0', 'b', '0', 'e' ];
 	bool = deepHasOwnProp( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -355,7 +355,7 @@ tape( 'the function returns `false` if an object does not have a specified path
 		'sep': '/'
 	};
 	bool = deepHasOwnProp( obj, 'a/b/c/d/e', opts );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -375,7 +375,7 @@ tape( 'the function returns `false` if an object does not have a specified path
 		'sep': '/'
 	};
 	bool = deepHasOwnProp( obj, '0/a/0/b/0/e', opts );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -384,10 +384,10 @@ tape( 'the function returns `false` if provided an empty object (no options)', f
 	var bool;
 
 	bool = deepHasOwnProp( {}, 'a.b.c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = deepHasOwnProp( {}, '' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -401,10 +401,10 @@ tape( 'the function returns `false` if provided an empty object (options)', func
 	};
 
 	bool = deepHasOwnProp( {}, 'a/b/c', opts );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = deepHasOwnProp( {}, '', opts );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -417,10 +417,10 @@ tape( 'the function returns `false` if provided an empty path array (no options)
 		'a': 'b'
 	};
 	bool = deepHasOwnProp( obj, [] );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = deepHasOwnProp( {}, [] );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -437,10 +437,10 @@ tape( 'the function returns `false` if provided an empty path array (options)',
 		'a': 'b'
 	};
 	bool = deepHasOwnProp( obj, [], opts );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = deepHasOwnProp( {}, [], opts );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -453,7 +453,7 @@ tape( 'the function can return `true` if provided an empty key path string (no o
 		'': 'b'
 	};
 	bool = deepHasOwnProp( obj, '' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -470,7 +470,7 @@ tape( 'the function can return `true` if provided an empty key path string (opti
 		'sep': '/'
 	};
 	bool = deepHasOwnProp( obj, '', opts );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -488,16 +488,16 @@ tape( 'the function only returns `true` for "own" properties', function test( t
 	foo = new Foo();
 
 	bool = deepHasOwnProp( foo, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = deepHasOwnProp( foo, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function coerces primitives to objects', function test( t ) {
 	var bool = deepHasOwnProp( 'beep', 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/deep-has-property/test/test.has.js b/lib/node_modules/@stdlib/assert/deep-has-property/test/test.has.js
index 8c7c1da561ba..254934916023 100644
--- a/lib/node_modules/@stdlib/assert/deep-has-property/test/test.has.js
+++ b/lib/node_modules/@stdlib/assert/deep-has-property/test/test.has.js
@@ -47,7 +47,7 @@ tape( 'the function returns `true` if an object has a specified path', function
 	path = [ 'a', 'b', 'c' ];
 
 	bool = has( obj, path );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -66,7 +66,7 @@ tape( 'the function returns `true` if an object has a specified path', function
 	path = [ 'a', '0', 'b', '0', 'c' ];
 
 	bool = has( obj, path );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,7 +86,7 @@ tape( 'the function returns `false` if an object does not have a specified path'
 	path = [ 'a', 'b', 'c', 'd', 'e' ];
 
 	bool = has( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -105,7 +105,7 @@ tape( 'the function returns `false` if an object does not have a specified path'
 	path = [ '0', 'a', '0', 'b', '0', 'e' ];
 
 	bool = has( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -119,13 +119,13 @@ tape( 'the function returns `false` if provided an empty object', function test(
 	obj = {};
 
 	bool = has( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	path = [];
 	obj = {};
 
 	bool = has( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -141,13 +141,13 @@ tape( 'the function returns `false` if provided an empty key path', function tes
 	};
 
 	bool = has( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	path = [];
 	obj = {};
 
 	bool = has( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -167,11 +167,11 @@ tape( 'the function supports paths including inherited properties', function tes
 
 	path = [ 'a' ];
 	bool = has( foo, path );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	path = [ 'c' ];
 	bool = has( foo, path );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -189,7 +189,7 @@ tape( 'the function coerces path values to strings', function test( t ) {
 
 	path = [ 'a', {} ];
 	bool = has( obj, path );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/deep-has-property/test/test.js b/lib/node_modules/@stdlib/assert/deep-has-property/test/test.js
index 971331d643c0..b95cceb0cf79 100644
--- a/lib/node_modules/@stdlib/assert/deep-has-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/deep-has-property/test/test.js
@@ -168,7 +168,7 @@ tape( 'the function returns `true` if an object has a specified path (delimited
 		}
 	};
 	bool = deepHasProp( obj, 'a.b.c' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -185,7 +185,7 @@ tape( 'the function returns `true` if an object has a specified path (delimited
 		]
 	};
 	bool = deepHasProp( obj, 'a.0.b.0.c' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -204,7 +204,7 @@ tape( 'the function returns `true` if an object has a specified path (key array)
 	};
 	path = [ 'a', 'b', 'c' ];
 	bool = deepHasProp( obj, path );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -222,7 +222,7 @@ tape( 'the function returns `true` if an object has a specified path (key array)
 	};
 	path = [ 'a', '0', 'b', '0', 'c' ];
 	bool = deepHasProp( obj, path );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -243,7 +243,7 @@ tape( 'the function returns `true` if an object has a specified path (custom del
 		'sep': '/'
 	};
 	bool = deepHasProp( obj, 'a/b/c', opts );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -263,7 +263,7 @@ tape( 'the function returns `true` if an object has a specified path (custom del
 		'sep': '/'
 	};
 	bool = deepHasProp( obj, 'a/0/b/0/c', opts );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -280,7 +280,7 @@ tape( 'the function returns `false` if an object does not have a specified path
 		}
 	};
 	bool = deepHasProp( obj, 'a.b.c.d.e' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -297,7 +297,7 @@ tape( 'the function returns `false` if an object does not have a specified path
 		]
 	};
 	bool = deepHasProp( obj, '0.a.0.b.0.e' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -316,7 +316,7 @@ tape( 'the function returns `false` if an object does not have a specified path
 	};
 	path = [ 'a', 'b', 'c', 'd', 'e' ];
 	bool = deepHasProp( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -334,7 +334,7 @@ tape( 'the function returns `false` if an object does not have a specified path
 	};
 	path = [ '0', 'a', '0', 'b', '0', 'e' ];
 	bool = deepHasProp( obj, path );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -355,7 +355,7 @@ tape( 'the function returns `false` if an object does not have a specified path
 		'sep': '/'
 	};
 	bool = deepHasProp( obj, 'a/b/c/d/e', opts );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {
 		'a': [
@@ -375,7 +375,7 @@ tape( 'the function returns `false` if an object does not have a specified path
 		'sep': '/'
 	};
 	bool = deepHasProp( obj, '0/a/0/b/0/e', opts );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -384,10 +384,10 @@ tape( 'the function returns `false` if provided an empty object (no options)', f
 	var bool;
 
 	bool = deepHasProp( {}, 'a.b.c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = deepHasProp( {}, '' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -401,10 +401,10 @@ tape( 'the function returns `false` if provided an empty object (options)', func
 	};
 
 	bool = deepHasProp( {}, 'a/b/c', opts );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = deepHasProp( {}, '', opts );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -417,10 +417,10 @@ tape( 'the function returns `false` if provided an empty path array (no options)
 		'a': 'b'
 	};
 	bool = deepHasProp( obj, [] );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = deepHasProp( {}, [] );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -437,10 +437,10 @@ tape( 'the function returns `false` if provided an empty path array (options)',
 		'a': 'b'
 	};
 	bool = deepHasProp( obj, [], opts );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = deepHasProp( {}, [], opts );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -453,7 +453,7 @@ tape( 'the function can return `true` if provided an empty key path string (no o
 		'': 'b'
 	};
 	bool = deepHasProp( obj, '' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -470,7 +470,7 @@ tape( 'the function can return `true` if provided an empty key path string (opti
 		'sep': '/'
 	};
 	bool = deepHasProp( obj, '', opts );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -490,16 +490,16 @@ tape( 'the function supports paths including inherited properties', function tes
 	};
 
 	bool = deepHasProp( foo, 'a.a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = deepHasProp( foo, 'a.c' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function coerces primitives to objects', function test( t ) {
 	var bool = deepHasProp( 'beep', 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/has-own-property/test/test.js b/lib/node_modules/@stdlib/assert/has-own-property/test/test.js
index 776fa3d1b909..bcda326afbd4 100644
--- a/lib/node_modules/@stdlib/assert/has-own-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/has-own-property/test/test.js
@@ -49,14 +49,14 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 tape( 'the function returns `true` if an object has a specified property', function test( t ) {
 	var bool;
 
-	bool = hasOwnProp( { 'a': 'b' }, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	bool = hasOwnProp({ 'a': 'b' }, 'a' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = hasOwnProp( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = hasOwnProp( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -64,11 +64,11 @@ tape( 'the function returns `true` if an object has a specified property', funct
 tape( 'the function returns `false` if an object does not have a specified property', function test( t ) {
 	var bool;
 
-	bool = hasOwnProp( { 'a': 'b' }, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	bool = hasOwnProp({ 'a': 'b' }, 'c' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
-	bool = hasOwnProp( { 'a': 'b' }, null );
-	t.strictEqual( bool, false, 'returns false' );
+	bool = hasOwnProp({ 'a': 'b' }, null );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -86,7 +86,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = hasOwnProp( 'beep', 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,11 +94,11 @@ tape( 'values are coerced to objects', function test( t ) {
 tape( 'property values are coerced to strings', function test( t ) {
 	var bool;
 
-	bool = hasOwnProp( { 'null': false }, null );
-	t.strictEqual( bool, true, 'returns true' );
+	bool = hasOwnProp({ 'null': false }, null );
+	t.strictEqual( bool, true, 'returns expected value' );
 
-	bool = hasOwnProp( { '[object Object]': false }, {} );
-	t.strictEqual( bool, true, 'returns true' );
+	bool = hasOwnProp({ '[object Object]': false }, {} );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/has-property/test/test.js b/lib/node_modules/@stdlib/assert/has-property/test/test.js
index c46219480c0d..5048dba3e4a2 100644
--- a/lib/node_modules/@stdlib/assert/has-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/has-property/test/test.js
@@ -51,14 +51,14 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 tape( 'the function returns `true` if an object has a specified property (either own or inherited)', function test( t ) {
 	var bool;
 
-	bool = hasProp( { 'a': 'b' }, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	bool = hasProp({ 'a': 'b' }, 'a' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = hasProp( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = hasProp( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = hasProp( {}, 'hasOwnProperty' );
 	t.strictEqual( bool, true, 'returns true when provided a prototype property' );
@@ -69,11 +69,11 @@ tape( 'the function returns `true` if an object has a specified property (either
 tape( 'the function returns `false` if an object does not have a specified property (either own or inherited)', function test( t ) {
 	var bool;
 
-	bool = hasProp( { 'a': 'b' }, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	bool = hasProp({ 'a': 'b' }, 'c' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
-	bool = hasProp( { 'a': 'b' }, null );
-	t.strictEqual( bool, false, 'returns false' );
+	bool = hasProp({ 'a': 'b' }, null );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -82,7 +82,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = hasProp( 'beep', 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -90,11 +90,11 @@ tape( 'values are coerced to objects', function test( t ) {
 tape( 'non-symbol property values are coerced to strings', function test( t ) {
 	var bool;
 
-	bool = hasProp( { 'null': false }, null );
-	t.strictEqual( bool, true, 'returns true' );
+	bool = hasProp({ 'null': false }, null );
+	t.strictEqual( bool, true, 'returns expected value' );
 
-	bool = hasProp( { '[object Object]': false }, {} );
-	t.strictEqual( bool, true, 'returns true' );
+	bool = hasProp({ '[object Object]': false }, {} );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'the function supports symbols', function test( t ) {
 		s = Symbol( 'foo' );
 		obj[ s ] = true;
 		bool = hasProp( obj, s );
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 	} else {
 		t.pass( 'environment does not support symbols' );
 	}
diff --git a/lib/node_modules/@stdlib/assert/instance-of/test/test.js b/lib/node_modules/@stdlib/assert/instance-of/test/test.js
index 1ce62e969664..852da46aebfc 100644
--- a/lib/node_modules/@stdlib/assert/instance-of/test/test.js
+++ b/lib/node_modules/@stdlib/assert/instance-of/test/test.js
@@ -22,7 +22,10 @@
 
 var tape = require( 'tape' );
 var inherit = require( '@stdlib/utils/inherit' );
+var Boolean = require( '@stdlib/boolean/ctor' );
+var Function = require( '@stdlib/function/ctor' );
 var Number = require( '@stdlib/number/ctor' );
+var Object = require( '@stdlib/object/ctor' );
 var instanceOf = require( './../lib' );
 
 
@@ -70,7 +73,7 @@ tape( 'the function returns `true` if provided a value which is an instance of a
 	bool = instanceOf( [], Object );
 	t.strictEqual( bool, true, 'returns expected value' );
 
-	bool = instanceOf( new Object(), Object ); // eslint-disable-line no-new-object
+	bool = instanceOf( new Object(), Object );
 	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = instanceOf( instanceOf, Function );
@@ -111,7 +114,7 @@ tape( 'the function returns `true` if a provided a value which is an instance of
 	bar = new Bar();
 	bool = instanceOf( bar, Foo );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( bar instanceof Bar, true, 'is instance of Bar' );
 	t.strictEqual( bar instanceof Foo, true, 'is instance of Foo' );
 	t.end();
@@ -153,7 +156,7 @@ tape( 'the function returns `false` if a provided value which is not an instance
 	bar = new Bar();
 	bool = instanceOf( bar, Foo );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.strictEqual( bar instanceof Bar, true, 'is instance of Bar' );
 	t.strictEqual( bar instanceof Foo, false, 'is not instance of Foo' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.posix.js b/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.posix.js
index 523a1793fa6f..06cc96148182 100644
--- a/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.posix.js
+++ b/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.posix.js
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 
 tape( 'the function returns `false` if provided an empty string', function test( t ) {
 	var bool = isAbsolutePath( '' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.win32.js b/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.win32.js
index 4acef0178e1d..78f55f6bf24e 100644
--- a/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.win32.js
+++ b/lib/node_modules/@stdlib/assert/is-absolute-path/test/test.win32.js
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 
 tape( 'the function returns `false` if provided an empty string', function test( t ) {
 	var bool = isAbsolutePath( '' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-accessor-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-accessor-property-in/test/test.js
index 522540358a1c..cc4e6c8ddcff 100644
--- a/lib/node_modules/@stdlib/assert/is-accessor-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-accessor-property-in/test/test.js
@@ -59,13 +59,13 @@ tape( 'the function returns `true` if an object property has an accessor descrip
 	});
 
 	bool = isAccessorPropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isAccessorPropertyIn( obj, 'b' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isAccessorPropertyIn( obj, 'c' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -108,13 +108,13 @@ tape( 'the function returns `true` if provided an inherited property having an a
 	obj = new Foo();
 
 	bool = isAccessorPropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isAccessorPropertyIn( obj, 'b' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isAccessorPropertyIn( obj, 'c' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -140,19 +140,19 @@ tape( 'the function returns `false` if an object property has a data descriptor'
 		'a': 'b'
 	};
 	bool = isAccessorPropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorPropertyIn( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorPropertyIn( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorPropertyIn( new Foo(), 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorPropertyIn( [ 'a' ], 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -163,7 +163,7 @@ tape( 'the function returns `false` if an object property has a data descriptor'
 	});
 
 	bool = isAccessorPropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -189,10 +189,10 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isAccessorPropertyIn( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorPropertyIn( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -215,16 +215,16 @@ tape( 'the function returns `false` if provided an inherited property having a d
 	obj = new Foo();
 
 	bool = isAccessorPropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorPropertyIn( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorPropertyIn( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorPropertyIn( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -233,7 +233,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isAccessorPropertyIn( 'beep', 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-accessor-property/test/test.js b/lib/node_modules/@stdlib/assert/is-accessor-property/test/test.js
index 693e13f9090d..6670605433da 100644
--- a/lib/node_modules/@stdlib/assert/is-accessor-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-accessor-property/test/test.js
@@ -59,13 +59,13 @@ tape( 'the function returns `true` if an object property has an accessor descrip
 	});
 
 	bool = isAccessorProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isAccessorProperty( obj, 'b' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isAccessorProperty( obj, 'c' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -91,19 +91,19 @@ tape( 'the function returns `false` if an object property has a data descriptor'
 		'a': 'b'
 	};
 	bool = isAccessorProperty( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorProperty( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorProperty( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorProperty( new Foo(), 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorProperty( [ 'a' ], 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -114,7 +114,7 @@ tape( 'the function returns `false` if an object property has a data descriptor'
 	});
 
 	bool = isAccessorProperty( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -140,10 +140,10 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isAccessorProperty( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorProperty( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -165,16 +165,16 @@ tape( 'the function returns `false` if provided an inherited property', function
 	obj = new Foo();
 
 	bool = isAccessorProperty( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorProperty( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorProperty( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isAccessorProperty( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -187,7 +187,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isAccessorProperty( 'beep', 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-alphagram/test/test.js b/lib/node_modules/@stdlib/assert/is-alphagram/test/test.js
index d555f094cf4c..96601b680166 100644
--- a/lib/node_modules/@stdlib/assert/is-alphagram/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-alphagram/test/test.js
@@ -33,8 +33,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an alphagram', function test( t ) {
-	t.strictEqual( isAlphagram( 'abcdef' ), true, 'returns true' );
-	t.strictEqual( isAlphagram( new String( 'beep' ) ), true, 'returns true' );
+	t.strictEqual( isAlphagram( 'abcdef' ), true, 'returns expected value' );
+	t.strictEqual( isAlphagram( new String( 'beep' ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-arguments/test/test.js b/lib/node_modules/@stdlib/assert/is-arguments/test/test.js
index b9f841bf6c23..4d34352597fb 100644
--- a/lib/node_modules/@stdlib/assert/is-arguments/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-arguments/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an `arguments` object', function test( t ) {
-	t.strictEqual( isArguments( arguments ), true, 'returns true' );
+	t.strictEqual( isArguments( arguments ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-array-array/test/test.js b/lib/node_modules/@stdlib/assert/is-array-array/test/test.js
index 9212815ace4a..6fb6db3ad5ad 100644
--- a/lib/node_modules/@stdlib/assert/is-array-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-array-array/test/test.js
@@ -36,29 +36,29 @@ tape( 'the function tests for an array of arrays', function test( t ) {
 	var arr;
 
 	arr = [ [] ];
-	t.strictEqual( isArrayArray( arr ), true, 'returns true' );
+	t.strictEqual( isArrayArray( arr ), true, 'returns expected value' );
 
 	arr = [ [], [], [] ];
-	t.strictEqual( isArrayArray( arr ), true, 'returns true' );
+	t.strictEqual( isArrayArray( arr ), true, 'returns expected value' );
 
 	arr = [ {} ];
-	t.strictEqual( isArrayArray( arr ), false, 'returns false' );
+	t.strictEqual( isArrayArray( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': [],
 		'1': []
 	};
-	t.strictEqual( isArrayArray( arr ), false, 'returns false' );
+	t.strictEqual( isArrayArray( arr ), false, 'returns expected value' );
 
 	arr = [];
 	t.strictEqual( isArrayArray( arr ), false, 'returns false when provided an empty array' );
 
 	arr = {};
-	t.strictEqual( isArrayArray( arr ), false, 'returns false' );
+	t.strictEqual( isArrayArray( arr ), false, 'returns expected value' );
 
 	arr = null;
-	t.strictEqual( isArrayArray( arr ), false, 'returns false' );
+	t.strictEqual( isArrayArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-array-length/test/test.js b/lib/node_modules/@stdlib/assert/is-array-length/test/test.js
index 22d1dc1ddc7d..8922c0f38521 100644
--- a/lib/node_modules/@stdlib/assert/is-array-length/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-array-length/test/test.js
@@ -34,16 +34,16 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a valid array length', function test( t ) {
-	t.strictEqual( isArrayLength( 0 ), true, 'returns true' );
-	t.strictEqual( isArrayLength( 10 ), true, 'returns true' );
-	t.strictEqual( isArrayLength( MAX_ARRAY_LENGTH ), true, 'returns true' );
+	t.strictEqual( isArrayLength( 0 ), true, 'returns expected value' );
+	t.strictEqual( isArrayLength( 10 ), true, 'returns expected value' );
+	t.strictEqual( isArrayLength( MAX_ARRAY_LENGTH ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a valid array length', function test( t ) {
-	t.strictEqual( isArrayLength( MAX_ARRAY_LENGTH+1 ), false, 'returns false' );
-	t.strictEqual( isArrayLength( -1 ), false, 'returns false' );
-	t.strictEqual( isArrayLength( 3.14 ), false, 'returns false' );
+	t.strictEqual( isArrayLength( MAX_ARRAY_LENGTH+1 ), false, 'returns expected value' );
+	t.strictEqual( isArrayLength( -1 ), false, 'returns expected value' );
+	t.strictEqual( isArrayLength( 3.14 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-array-like-object/test/test.js b/lib/node_modules/@stdlib/assert/is-array-like-object/test/test.js
index 60af65c8ced9..cf2bea1e0896 100644
--- a/lib/node_modules/@stdlib/assert/is-array-like-object/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-array-like-object/test/test.js
@@ -55,19 +55,19 @@ tape( 'the function returns `true` if provided an array-like object', function t
 
 tape( 'the function returns `false` if provided an array-like object whose length exceeds the maximum array length', function test( t ) {
 	var o = { 'length': MAX_ARRAY_LENGTH+1 };
-	t.strictEqual( isArrayLikeObject( o ), false, 'returns false' );
+	t.strictEqual( isArrayLikeObject( o ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided an array-like object whose length property is not an integer', function test( t ) {
 	var o = { 'length': 3.14 };
-	t.strictEqual( isArrayLikeObject( o ), false, 'returns false' );
+	t.strictEqual( isArrayLikeObject( o ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided an array-like object whose length property is a negative integer', function test( t ) {
 	var o = { 'length': -1 };
-	t.strictEqual( isArrayLikeObject( o ), false, 'returns false' );
+	t.strictEqual( isArrayLikeObject( o ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-array-like/test/test.js b/lib/node_modules/@stdlib/assert/is-array-like/test/test.js
index 7df64870e4d6..65fa5b224a33 100644
--- a/lib/node_modules/@stdlib/assert/is-array-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-array-like/test/test.js
@@ -56,19 +56,19 @@ tape( 'the function returns `true` if provided an array-like value', function te
 
 tape( 'the function returns `false` if provided an array-like value whose length exceeds the maximum array length', function test( t ) {
 	var o = { 'length': MAX_ARRAY_LENGTH+1 };
-	t.strictEqual( isArrayLike( o ), false, 'returns false' );
+	t.strictEqual( isArrayLike( o ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided an array-like value whose length property is not an integer', function test( t ) {
 	var o = { 'length': 3.14 };
-	t.strictEqual( isArrayLike( o ), false, 'returns false' );
+	t.strictEqual( isArrayLike( o ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided an array-like value whose length property is a negative integer', function test( t ) {
 	var o = { 'length': -1 };
-	t.strictEqual( isArrayLike( o ), false, 'returns false' );
+	t.strictEqual( isArrayLike( o ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-array/test/test.js b/lib/node_modules/@stdlib/assert/is-array/test/test.js
index c84bdc770088..e86f1d4ef425 100644
--- a/lib/node_modules/@stdlib/assert/is-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-array/test/test.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an array', function test( t ) {
-	t.strictEqual( isArray( [] ), true, 'returns true' );
-	t.strictEqual( isArray( zeros( 10 ) ), true, 'returns true' );
+	t.strictEqual( isArray( [] ), true, 'returns expected value' );
+	t.strictEqual( isArray( zeros( 10 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-arraybuffer/test/test.js b/lib/node_modules/@stdlib/assert/is-arraybuffer/test/test.js
index 5e0c7d87fe8f..7dc75944d5b5 100644
--- a/lib/node_modules/@stdlib/assert/is-arraybuffer/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-arraybuffer/test/test.js
@@ -31,6 +31,7 @@ var Uint8ClampedArray = require( '@stdlib/array/uint8c' );
 var Uint16Array = require( '@stdlib/array/uint16' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var ArrayBuffer = require( '@stdlib/array/buffer' );
+var zeros = require( '@stdlib/array/zeros' );
 var isArrayBuffer = require( './../lib' );
 
 
@@ -43,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an ArrayBuffer', function test( t ) {
-	t.strictEqual( isArrayBuffer( new ArrayBuffer( 10 ) ), true, 'returns true' );
+	t.strictEqual( isArrayBuffer( new ArrayBuffer( 10 ) ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,7 +62,7 @@ tape( 'the function returns `false` if not provided an ArrayBuffer', function te
 		[],
 		{},
 		function noop() {},
-		new Array( 10 ),
+		zeros( 10, 'generic' ),
 		new Float64Array( 10 ),
 		new Float32Array( 10 ),
 		new Uint32Array( 10 ),
diff --git a/lib/node_modules/@stdlib/assert/is-arrow-function/test/es2015-arrow-function/index.js b/lib/node_modules/@stdlib/assert/is-arrow-function/test/es2015-arrow-function/index.js
index f051e851d4b6..706bddd7a38d 100644
--- a/lib/node_modules/@stdlib/assert/is-arrow-function/test/es2015-arrow-function/index.js
+++ b/lib/node_modules/@stdlib/assert/is-arrow-function/test/es2015-arrow-function/index.js
@@ -29,6 +29,6 @@ var isArrowFunction = require( './../../lib' );
 // TESTS //
 
 tape( 'the function returns `true` if provided an arrow function', function test( t ) {
-	t.strictEqual( isArrowFunction( () => {} ), true, 'returns true' );
+	t.strictEqual( isArrowFunction( () => {} ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-arrow-function/test/test.js b/lib/node_modules/@stdlib/assert/is-arrow-function/test/test.js
index 2705fb562d44..8cf099ee2b19 100644
--- a/lib/node_modules/@stdlib/assert/is-arrow-function/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-arrow-function/test/test.js
@@ -48,7 +48,7 @@ tape( 'the function returns `false` if provided a function trying to impersonate
 	pretend.toString = function toString() {
 		return '() => {}';
 	};
-	t.strictEqual( isArrowFunction( pretend ), false, 'returns false' );
+	t.strictEqual( isArrowFunction( pretend ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -57,17 +57,17 @@ tape( 'the function returns `false` if provided a function which is not an arrow
 	var beep = function () {
 		return 'boop';
 	};
-	t.strictEqual( isArrowFunction( beep ), false, 'returns false' );
+	t.strictEqual( isArrowFunction( beep ), false, 'returns expected value' );
 
 	beep = function beep() {
 		return 'boop';
 	};
-	t.strictEqual( isArrowFunction( beep ), false, 'returns false' );
+	t.strictEqual( isArrowFunction( beep ), false, 'returns expected value' );
 
 	function baz() {
 		return 'boop';
 	}
-	t.strictEqual( isArrowFunction( baz ), false, 'returns false' );
+	t.strictEqual( isArrowFunction( baz ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-ascii/test/test.js b/lib/node_modules/@stdlib/assert/is-ascii/test/test.js
index bc20bfcdd0b2..54ae678d7687 100644
--- a/lib/node_modules/@stdlib/assert/is-ascii/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-ascii/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a string containing all ASCII characters', function test( t ) {
-	t.strictEqual( isASCII( 'abcdef' ), true, 'returns true' );
+	t.strictEqual( isASCII( 'abcdef' ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-between-array/test/test.js b/lib/node_modules/@stdlib/assert/is-between-array/test/test.js
index 7922e6e96c96..aafe04f7bd17 100644
--- a/lib/node_modules/@stdlib/assert/is-between-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-between-array/test/test.js
@@ -110,14 +110,14 @@ tape( 'the function returns `true` if provided an array-like object where every
 	var arr;
 
 	arr = new Int32Array( [ 3, 4, 5 ] );
-	t.strictEqual( isBetweenArray( arr, 3, 5 ), true, 'returns true' );
-	t.strictEqual( isBetweenArray( arr, 3, 5 ), true, 'returns true' );
-	t.strictEqual( isBetweenArray( arr, 3, 5 ), true, 'returns true' );
+	t.strictEqual( isBetweenArray( arr, 3, 5 ), true, 'returns expected value' );
+	t.strictEqual( isBetweenArray( arr, 3, 5 ), true, 'returns expected value' );
+	t.strictEqual( isBetweenArray( arr, 3, 5 ), true, 'returns expected value' );
 
 	arr = [ 'a', 'b', 'c' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c' ), true, 'returns true' );
-	t.strictEqual( isBetweenArray( arr, 'a', 'c' ), true, 'returns true' );
-	t.strictEqual( isBetweenArray( arr, 'a', 'c' ), true, 'returns true' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c' ), true, 'returns expected value' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c' ), true, 'returns expected value' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c' ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -126,14 +126,14 @@ tape( 'the function returns `true` if provided an array-like object where every
 	var arr;
 
 	arr = new Int16Array( [ 3, 4, 5 ] );
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'closed' ), true, 'returns true' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'closed' ), true, 'returns expected value' );
 
 	arr = [ 'a', 'b', 'c' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'closed' ), true, 'returns true' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'closed' ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -142,12 +142,12 @@ tape( 'the function returns `true` if provided an array-like object where every
 	var arr;
 
 	arr = new Uint32Array( [ 4, 5 ] );
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'closed' ), true, 'returns true' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'closed' ), true, 'returns expected value' );
 
 	arr = [ 'b', 'c' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'closed' ), true, 'returns true' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'closed' ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -156,12 +156,12 @@ tape( 'the function returns `true` if provided an array-like object where every
 	var arr;
 
 	arr = new Uint16Array( [ 3, 4 ] );
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'open' ), true, 'returns true' );
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'open' ), true, 'returns true' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'open' ), true, 'returns expected value' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'open' ), true, 'returns expected value' );
 
 	arr = [ 'a', 'b' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'open' ), true, 'returns true' );
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'open' ), true, 'returns true' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'open' ), true, 'returns expected value' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'open' ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -170,10 +170,10 @@ tape( 'the function returns `true` if provided an array-like object where every
 	var arr;
 
 	arr = new Int8Array( [ 4 ] );
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'open' ), true, 'returns true' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'open' ), true, 'returns expected value' );
 
 	arr = [ 'b' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'open' ), true, 'returns true' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'open' ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -182,16 +182,16 @@ tape( 'the function returns `false` if not provided an array-like object where e
 	var arr;
 
 	arr = new Uint8Array( [ 2 ] );
-	t.strictEqual( isBetweenArray( arr, 3, 5 ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5 ), false, 'returns expected value' );
 
 	arr = new Uint8ClampedArray( [ 6 ] );
-	t.strictEqual( isBetweenArray( arr, 3, 5 ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5 ), false, 'returns expected value' );
 
 	arr = [ 'a' ];
-	t.strictEqual( isBetweenArray( arr, 'b', 'c' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'b', 'c' ), false, 'returns expected value' );
 
 	arr = [ 'd' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c' ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -203,16 +203,16 @@ tape( 'the function returns `false` if not provided an array-like object where e
 		'length': 1,
 		'0': 2
 	};
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'closed' ), false, 'returns expected value' );
 
 	arr = [ 6 ];
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'closed' ), false, 'returns expected value' );
 
 	arr = [ 'a' ];
-	t.strictEqual( isBetweenArray( arr, 'b', 'c', 'closed', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'b', 'c', 'closed', 'closed' ), false, 'returns expected value' );
 
 	arr = [ 'd' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'closed' ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -221,22 +221,22 @@ tape( 'the function returns `false` if not provided an array-like object where e
 	var arr;
 
 	arr = [ 2 ];
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'closed' ), false, 'returns expected value' );
 
 	arr = [ 3 ];
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'closed' ), false, 'returns expected value' );
 
 	arr = [ 6 ];
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'closed' ), false, 'returns expected value' );
 
 	arr = [ 'a' ];
-	t.strictEqual( isBetweenArray( arr, 'b', 'c', 'open', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'b', 'c', 'open', 'closed' ), false, 'returns expected value' );
 
 	arr = [ 'a' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'closed' ), false, 'returns expected value' );
 
 	arr = [ 'd' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'closed' ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -245,22 +245,22 @@ tape( 'the function returns `false` if not provided an array-like object where e
 	var arr;
 
 	arr = [ 2 ];
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'open' ), false, 'returns expected value' );
 
 	arr = [ 5 ];
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'open' ), false, 'returns expected value' );
 
 	arr = [ 6 ];
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'closed', 'open' ), false, 'returns expected value' );
 
 	arr = [ 'a' ];
-	t.strictEqual( isBetweenArray( arr, 'b', 'c', 'closed', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'b', 'c', 'closed', 'open' ), false, 'returns expected value' );
 
 	arr = [ 'c' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'open' ), false, 'returns expected value' );
 
 	arr = [ 'd' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'closed', 'open' ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -269,28 +269,28 @@ tape( 'the function returns `false` if not provided an array-like object where e
 	var arr;
 
 	arr = [ 2 ];
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'open' ), false, 'returns expected value' );
 
 	arr = [ 3 ];
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'open' ), false, 'returns expected value' );
 
 	arr = [ 5 ];
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'open' ), false, 'returns expected value' );
 
 	arr = [ 6 ];
-	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 3, 5, 'open', 'open' ), false, 'returns expected value' );
 
 	arr = [ 'a' ];
-	t.strictEqual( isBetweenArray( arr, 'b', 'c', 'open', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'b', 'c', 'open', 'open' ), false, 'returns expected value' );
 
 	arr = [ 'a' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'open' ), false, 'returns expected value' );
 
 	arr = [ 'c' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'open' ), false, 'returns expected value' );
 
 	arr = [ 'd' ];
-	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c', 'open', 'open' ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -299,30 +299,30 @@ tape( 'the function returns `false` if provided an empty array-like object', fun
 	var arr;
 
 	arr = [];
-	t.strictEqual( isBetweenArray( arr, 0.0, 1.0 ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 0.0, 1.0 ), false, 'returns expected value' );
 
 	arr = [];
-	t.strictEqual( isBetweenArray( arr, 0.0, 1.0, 'closed', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 0.0, 1.0, 'closed', 'closed' ), false, 'returns expected value' );
 
 	arr = [];
-	t.strictEqual( isBetweenArray( arr, 0.0, 1.0, 'open', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 0.0, 1.0, 'open', 'closed' ), false, 'returns expected value' );
 
 	arr = [];
-	t.strictEqual( isBetweenArray( arr, 0.0, 1.0, 'closed', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 0.0, 1.0, 'closed', 'open' ), false, 'returns expected value' );
 
 	arr = [];
-	t.strictEqual( isBetweenArray( arr, 0.0, 1.0, 'open', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 0.0, 1.0, 'open', 'open' ), false, 'returns expected value' );
 
 	arr = new Float64Array();
-	t.strictEqual( isBetweenArray( arr, 0.0, 1.0 ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 0.0, 1.0 ), false, 'returns expected value' );
 
 	arr = {
 		'length': 0
 	};
-	t.strictEqual( isBetweenArray( arr, 0.0, 1.0 ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 0.0, 1.0 ), false, 'returns expected value' );
 
 	arr = '';
-	t.strictEqual( isBetweenArray( arr, 'a', 'c' ), false, 'returns false' );
+	t.strictEqual( isBetweenArray( arr, 'a', 'c' ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-between/test/test.js b/lib/node_modules/@stdlib/assert/is-between/test/test.js
index 4a5173c66dff..2dd48d470a2c 100644
--- a/lib/node_modules/@stdlib/assert/is-between/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-between/test/test.js
@@ -99,91 +99,91 @@ tape( 'the function throws an error if provided an unrecognized `right` argument
 });
 
 tape( 'the function returns `true` if provided a value which is between two values (default)', function test( t ) {
-	t.strictEqual( isBetween( 4, 3, 5 ), true, 'returns true' );
-	t.strictEqual( isBetween( 3, 3, 5 ), true, 'returns true' );
-	t.strictEqual( isBetween( 5, 3, 5 ), true, 'returns true' );
-	t.strictEqual( isBetween( 'b', 'a', 'c' ), true, 'returns true' );
-	t.strictEqual( isBetween( 'a', 'a', 'c' ), true, 'returns true' );
-	t.strictEqual( isBetween( 'c', 'a', 'c' ), true, 'returns true' );
+	t.strictEqual( isBetween( 4, 3, 5 ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 3, 3, 5 ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 5, 3, 5 ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 'b', 'a', 'c' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 'a', 'a', 'c' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 'c', 'a', 'c' ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided a value which is between two values (closed,closed)', function test( t ) {
-	t.strictEqual( isBetween( 4, 3, 5, 'closed', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetween( 3, 3, 5, 'closed', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetween( 5, 3, 5, 'closed', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetween( 'b', 'a', 'c', 'closed', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetween( 'a', 'a', 'c', 'closed', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetween( 'c', 'a', 'c', 'closed', 'closed' ), true, 'returns true' );
+	t.strictEqual( isBetween( 4, 3, 5, 'closed', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 3, 3, 5, 'closed', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 5, 3, 5, 'closed', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 'b', 'a', 'c', 'closed', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 'a', 'a', 'c', 'closed', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 'c', 'a', 'c', 'closed', 'closed' ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided a value which is between two values (open,closed)', function test( t ) {
-	t.strictEqual( isBetween( 4, 3, 5, 'open', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetween( 5, 3, 5, 'open', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetween( 'b', 'a', 'c', 'open', 'closed' ), true, 'returns true' );
-	t.strictEqual( isBetween( 'c', 'a', 'c', 'open', 'closed' ), true, 'returns true' );
+	t.strictEqual( isBetween( 4, 3, 5, 'open', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 5, 3, 5, 'open', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 'b', 'a', 'c', 'open', 'closed' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 'c', 'a', 'c', 'open', 'closed' ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided a value which is between two values (closed,open)', function test( t ) {
-	t.strictEqual( isBetween( 4, 3, 5, 'closed', 'open' ), true, 'returns true' );
-	t.strictEqual( isBetween( 3, 3, 5, 'closed', 'open' ), true, 'returns true' );
-	t.strictEqual( isBetween( 'b', 'a', 'c', 'closed', 'open' ), true, 'returns true' );
-	t.strictEqual( isBetween( 'a', 'a', 'c', 'closed', 'open' ), true, 'returns true' );
+	t.strictEqual( isBetween( 4, 3, 5, 'closed', 'open' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 3, 3, 5, 'closed', 'open' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 'b', 'a', 'c', 'closed', 'open' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 'a', 'a', 'c', 'closed', 'open' ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided a value which is between two values (open,open)', function test( t ) {
-	t.strictEqual( isBetween( 4, 3, 5, 'open', 'open' ), true, 'returns true' );
-	t.strictEqual( isBetween( 'b', 'a', 'c', 'open', 'open' ), true, 'returns true' );
+	t.strictEqual( isBetween( 4, 3, 5, 'open', 'open' ), true, 'returns expected value' );
+	t.strictEqual( isBetween( 'b', 'a', 'c', 'open', 'open' ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a value which is between two values (default)', function test( t ) {
-	t.strictEqual( isBetween( 2, 3, 5 ), false, 'returns false' );
-	t.strictEqual( isBetween( 6, 3, 5 ), false, 'returns false' );
-	t.strictEqual( isBetween( 'a', 'b', 'c' ), false, 'returns false' );
-	t.strictEqual( isBetween( 'd', 'a', 'c' ), false, 'returns false' );
+	t.strictEqual( isBetween( 2, 3, 5 ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 6, 3, 5 ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'a', 'b', 'c' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'd', 'a', 'c' ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a value which is between two values (closed,closed)', function test( t ) {
-	t.strictEqual( isBetween( 2, 3, 5, 'closed', 'closed' ), false, 'returns false' );
-	t.strictEqual( isBetween( 6, 3, 5, 'closed', 'closed' ), false, 'returns false' );
-	t.strictEqual( isBetween( 'a', 'b', 'c', 'closed', 'closed' ), false, 'returns false' );
-	t.strictEqual( isBetween( 'd', 'a', 'c', 'closed', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetween( 2, 3, 5, 'closed', 'closed' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 6, 3, 5, 'closed', 'closed' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'a', 'b', 'c', 'closed', 'closed' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'd', 'a', 'c', 'closed', 'closed' ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a value which is between two values (open,closed)', function test( t ) {
-	t.strictEqual( isBetween( 2, 3, 5, 'open', 'closed' ), false, 'returns false' );
-	t.strictEqual( isBetween( 3, 3, 5, 'open', 'closed' ), false, 'returns false' );
-	t.strictEqual( isBetween( 6, 3, 5, 'open', 'closed' ), false, 'returns false' );
-	t.strictEqual( isBetween( 'a', 'b', 'c', 'open', 'closed' ), false, 'returns false' );
-	t.strictEqual( isBetween( 'a', 'a', 'c', 'open', 'closed' ), false, 'returns false' );
-	t.strictEqual( isBetween( 'd', 'a', 'c', 'open', 'closed' ), false, 'returns false' );
+	t.strictEqual( isBetween( 2, 3, 5, 'open', 'closed' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 3, 3, 5, 'open', 'closed' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 6, 3, 5, 'open', 'closed' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'a', 'b', 'c', 'open', 'closed' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'a', 'a', 'c', 'open', 'closed' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'd', 'a', 'c', 'open', 'closed' ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a value which is between two values (closed,open)', function test( t ) {
-	t.strictEqual( isBetween( 2, 3, 5, 'closed', 'open' ), false, 'returns false' );
-	t.strictEqual( isBetween( 5, 3, 5, 'closed', 'open' ), false, 'returns false' );
-	t.strictEqual( isBetween( 6, 3, 5, 'closed', 'open' ), false, 'returns false' );
-	t.strictEqual( isBetween( 'a', 'b', 'c', 'closed', 'open' ), false, 'returns false' );
-	t.strictEqual( isBetween( 'c', 'a', 'c', 'closed', 'open' ), false, 'returns false' );
-	t.strictEqual( isBetween( 'd', 'a', 'c', 'closed', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetween( 2, 3, 5, 'closed', 'open' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 5, 3, 5, 'closed', 'open' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 6, 3, 5, 'closed', 'open' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'a', 'b', 'c', 'closed', 'open' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'c', 'a', 'c', 'closed', 'open' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'd', 'a', 'c', 'closed', 'open' ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a value which is between two values (open,open)', function test( t ) {
-	t.strictEqual( isBetween( 2, 3, 5, 'open', 'open' ), false, 'returns false' );
-	t.strictEqual( isBetween( 3, 3, 5, 'open', 'open' ), false, 'returns false' );
-	t.strictEqual( isBetween( 5, 3, 5, 'open', 'open' ), false, 'returns false' );
-	t.strictEqual( isBetween( 6, 3, 5, 'open', 'open' ), false, 'returns false' );
-	t.strictEqual( isBetween( 'a', 'b', 'c', 'open', 'open' ), false, 'returns false' );
-	t.strictEqual( isBetween( 'a', 'a', 'c', 'open', 'open' ), false, 'returns false' );
-	t.strictEqual( isBetween( 'c', 'a', 'c', 'open', 'open' ), false, 'returns false' );
-	t.strictEqual( isBetween( 'd', 'a', 'c', 'open', 'open' ), false, 'returns false' );
+	t.strictEqual( isBetween( 2, 3, 5, 'open', 'open' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 3, 3, 5, 'open', 'open' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 5, 3, 5, 'open', 'open' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 6, 3, 5, 'open', 'open' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'a', 'b', 'c', 'open', 'open' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'a', 'a', 'c', 'open', 'open' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'c', 'a', 'c', 'open', 'open' ), false, 'returns expected value' );
+	t.strictEqual( isBetween( 'd', 'a', 'c', 'open', 'open' ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-bigint/test/test.generic.js b/lib/node_modules/@stdlib/assert/is-bigint/test/test.generic.js
index dbb4a619a57c..5b0e82e1bae0 100644
--- a/lib/node_modules/@stdlib/assert/is-bigint/test/test.generic.js
+++ b/lib/node_modules/@stdlib/assert/is-bigint/test/test.generic.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a BigInt', opts, function test( t ) {
-	t.strictEqual( isBigInt( BigInt( '1' ) ), true, 'returns true' );
-	t.strictEqual( isBigInt( Object( BigInt( '1' ) ) ), true, 'returns true' );
+	t.strictEqual( isBigInt( BigInt( '1' ) ), true, 'returns expected value' );
+	t.strictEqual( isBigInt( Object( BigInt( '1' ) ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-bigint/test/test.object.js b/lib/node_modules/@stdlib/assert/is-bigint/test/test.object.js
index 48bfa5805042..ee198c25eca8 100644
--- a/lib/node_modules/@stdlib/assert/is-bigint/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-bigint/test/test.object.js
@@ -23,6 +23,7 @@
 var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
 var BigInt = require( '@stdlib/bigint/ctor' );
+var Object = require( '@stdlib/object/ctor' );
 var hasBigInts = require( '@stdlib/assert/has-bigint-support' );
 var isBigInt = require( './../lib/object.js' );
 
@@ -43,12 +44,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a BigInt object', opts, function test( t ) {
-	t.strictEqual( isBigInt( Object( BigInt( '1' ) ) ), true, 'returns true' );
+	t.strictEqual( isBigInt( Object( BigInt( '1' ) ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive BigInt', opts, function test( t ) {
-	t.strictEqual( isBigInt( BigInt( '1' ) ), false, 'returns false' );
+	t.strictEqual( isBigInt( BigInt( '1' ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-bigint/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-bigint/test/test.primitive.js
index e6588f2eb215..411c35e2d8b3 100644
--- a/lib/node_modules/@stdlib/assert/is-bigint/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-bigint/test/test.primitive.js
@@ -22,6 +22,7 @@
 
 var tape = require( 'tape' );
 var BigInt = require( '@stdlib/bigint/ctor' );
+var Object = require( '@stdlib/object/ctor' );
 var hasBigInts = require( '@stdlib/assert/has-bigint-support' );
 var isBigInt = require( './../lib/primitive.js' );
 
@@ -42,12 +43,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive BigInt', opts, function test( t ) {
-	t.strictEqual( isBigInt( BigInt( '1' ) ), true, 'returns true' );
+	t.strictEqual( isBigInt( BigInt( '1' ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a BigInt object', opts, function test( t ) {
-	t.strictEqual( isBigInt( Object( BigInt( '1' ) ) ), false, 'returns false' );
+	t.strictEqual( isBigInt( Object( BigInt( '1' ) ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-bigint/test/test.try2valueof.js b/lib/node_modules/@stdlib/assert/is-bigint/test/test.try2valueof.js
index 60c704f16cd5..1ec62577960d 100644
--- a/lib/node_modules/@stdlib/assert/is-bigint/test/test.try2valueof.js
+++ b/lib/node_modules/@stdlib/assert/is-bigint/test/test.try2valueof.js
@@ -67,7 +67,7 @@ tape( 'the function returns `false` if not provided a BigInt', function test( t
 
 tape( 'the function returns `false` if provided an empty object without a prototype', function test( t ) {
 	var o = Object.create( null );
-	t.strictEqual( tryValueOf( o ), false, 'returns false' );
+	t.strictEqual( tryValueOf( o ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -75,7 +75,7 @@ tape( 'the function returns `true` if able to successfully call a BigInt method'
 	var o = Object.create( null );
 	o.valueOf = valueOf;
 
-	t.strictEqual( tryValueOf( o ), true, 'returns true' );
+	t.strictEqual( tryValueOf( o ), true, 'returns expected value' );
 	t.end();
 
 	function valueOf() {
@@ -84,7 +84,7 @@ tape( 'the function returns `true` if able to successfully call a BigInt method'
 });
 
 tape( 'if an environment supports BigInts, the function returns `true`', opts, function test( t ) {
-	t.strictEqual( tryValueOf( BigInt( '1' ) ), true, 'returns true' );
-	t.strictEqual( tryValueOf( Object( BigInt( '1' ) ) ), true, 'returns true' );
+	t.strictEqual( tryValueOf( BigInt( '1' ) ), true, 'returns expected value' );
+	t.strictEqual( tryValueOf( Object( BigInt( '1' ) ) ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-bigint64array/test/test.js b/lib/node_modules/@stdlib/assert/is-bigint64array/test/test.js
index acd8bcd925a2..8dc871804747 100644
--- a/lib/node_modules/@stdlib/assert/is-bigint64array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-bigint64array/test/test.js
@@ -30,6 +30,7 @@ var Int32Array = require( '@stdlib/array/int32' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var Float32Array = require( '@stdlib/array/float32' );
 var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
 var isBigInt64Array = require( './../lib' );
 
 
@@ -42,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a BigInt64Array', function test( t ) {
-	t.strictEqual( isBigInt64Array( new BigInt64Array( 10 ) ), true, 'returns true' ); // eslint-disable-line stdlib/require-globals, no-undef
+	t.strictEqual( isBigInt64Array( new BigInt64Array( 10 ) ), true, 'returns expected value' ); // eslint-disable-line stdlib/require-globals, no-undef
 	t.end();
 });
 
@@ -60,7 +61,7 @@ tape( 'the function returns `false` if not provided a BigInt64Array', function t
 		[],
 		{},
 		function noop() {},
-		new Array( 10 ),
+		zeros( 10, 'generic' ),
 		new Float32Array( 10 ),
 		new Float64Array( 10 ),
 		new Uint32Array( 10 ),
diff --git a/lib/node_modules/@stdlib/assert/is-biguint64array/test/test.js b/lib/node_modules/@stdlib/assert/is-biguint64array/test/test.js
index 4a983ea2b81d..eceb741666c4 100644
--- a/lib/node_modules/@stdlib/assert/is-biguint64array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-biguint64array/test/test.js
@@ -30,6 +30,7 @@ var Int32Array = require( '@stdlib/array/int32' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var Float32Array = require( '@stdlib/array/float32' );
 var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
 var isBigUint64Array = require( './../lib' );
 
 
@@ -42,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a BigUint64Array', function test( t ) {
-	t.strictEqual( isBigUint64Array( new BigUint64Array( 10 ) ), true, 'returns true' ); // eslint-disable-line stdlib/require-globals, no-undef
+	t.strictEqual( isBigUint64Array( new BigUint64Array( 10 ) ), true, 'returns expected value' ); // eslint-disable-line stdlib/require-globals, no-undef
 	t.end();
 });
 
@@ -60,7 +61,7 @@ tape( 'the function returns `false` if not provided a BigUint64Array', function
 		[],
 		{},
 		function noop() {},
-		new Array( 10 ),
+		zeros( 10, 'generic' ),
 		new Float32Array( 10 ),
 		new Float64Array( 10 ),
 		new Uint32Array( 10 ),
diff --git a/lib/node_modules/@stdlib/assert/is-binary-string/test/test.js b/lib/node_modules/@stdlib/assert/is-binary-string/test/test.js
index 319a648697ef..ebd8fd3e2656 100644
--- a/lib/node_modules/@stdlib/assert/is-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-binary-string/test/test.js
@@ -45,13 +45,13 @@ tape( 'the function returns `true` if provided a binary string', function test(
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isBinaryString( values[i] ), true, 'returns true' );
+		t.strictEqual( isBinaryString( values[i] ), true, 'returns expected value' );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a `String` object, even if the value of the `String` object is a binary string', function test( t ) {
-	t.strictEqual( isBinaryString( new String( '0101' ) ), false, 'returns false' );
+	t.strictEqual( isBinaryString( new String( '0101' ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-blank-string/test/test.js b/lib/node_modules/@stdlib/assert/is-blank-string/test/test.js
index 73b06056e0de..1da793493042 100644
--- a/lib/node_modules/@stdlib/assert/is-blank-string/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-blank-string/test/test.js
@@ -44,13 +44,13 @@ tape( 'the function returns `true` if provided a blank string', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isBlankString( values[i] ), true, 'returns true' );
+		t.strictEqual( isBlankString( values[i] ), true, 'returns expected value' );
 	}
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a `String` object, even if the value of the `String` object is a blank string', function test( t ) {
-	t.strictEqual( isBlankString( new String( ' ' ) ), false, 'returns false' );
+	t.strictEqual( isBlankString( new String( ' ' ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-boolean-array/test/test.js b/lib/node_modules/@stdlib/assert/is-boolean-array/test/test.js
index bc8c4740c2d3..999fc796c249 100644
--- a/lib/node_modules/@stdlib/assert/is-boolean-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-boolean-array/test/test.js
@@ -37,17 +37,17 @@ tape( 'the function tests for an array-like object containing only booleans', fu
 	var arr;
 
 	arr = [ true, new Boolean( true ), false, new Boolean( false ) ];
-	t.strictEqual( isBooleanArray( arr ), true, 'returns true' );
+	t.strictEqual( isBooleanArray( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': true,
 		'1': false
 	};
-	t.strictEqual( isBooleanArray( arr ), true, 'returns true' );
+	t.strictEqual( isBooleanArray( arr ), true, 'returns expected value' );
 
 	arr = [ true, 'true', null ];
-	t.strictEqual( isBooleanArray( arr ), false, 'returns false' );
+	t.strictEqual( isBooleanArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -56,17 +56,17 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ true, false, true, false ];
-	t.strictEqual( isBooleanArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isBooleanArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': false,
 		'1': true
 	};
-	t.strictEqual( isBooleanArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isBooleanArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ new Boolean( true ), false, false ];
-	t.strictEqual( isBooleanArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isBooleanArray.primitives( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -75,17 +75,17 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Boolean( true ), new Boolean( false ), new Boolean( true ) ];
-	t.strictEqual( isBooleanArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isBooleanArray.objects( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Boolean( true ),
 		'1': new Boolean( true )
 	};
-	t.strictEqual( isBooleanArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isBooleanArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ new Boolean( true ), false, false ];
-	t.strictEqual( isBooleanArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isBooleanArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-boolean/test/test.main.js b/lib/node_modules/@stdlib/assert/is-boolean/test/test.main.js
index 4b54f989f15b..988f3669f5d4 100644
--- a/lib/node_modules/@stdlib/assert/is-boolean/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-boolean/test/test.main.js
@@ -34,10 +34,10 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a boolean', function test( t ) {
-	t.strictEqual( isBoolean( false ), true, 'returns true' );
-	t.strictEqual( isBoolean( new Boolean( false ) ), true, 'returns true' );
-	t.strictEqual( isBoolean( true ), true, 'returns true' );
-	t.strictEqual( isBoolean( new Boolean( true ) ), true, 'returns true' );
+	t.strictEqual( isBoolean( false ), true, 'returns expected value' );
+	t.strictEqual( isBoolean( new Boolean( false ) ), true, 'returns expected value' );
+	t.strictEqual( isBoolean( true ), true, 'returns expected value' );
+	t.strictEqual( isBoolean( new Boolean( true ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-boolean/test/test.object.js b/lib/node_modules/@stdlib/assert/is-boolean/test/test.object.js
index 52b03cb2e5a9..36f7f5536bd9 100644
--- a/lib/node_modules/@stdlib/assert/is-boolean/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-boolean/test/test.object.js
@@ -44,14 +44,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a boolean object', function test( t ) {
-	t.strictEqual( isBoolean( new Boolean( false ) ), true, 'returns true' );
-	t.strictEqual( isBoolean( new Boolean( true ) ), true, 'returns true' );
+	t.strictEqual( isBoolean( new Boolean( false ) ), true, 'returns expected value' );
+	t.strictEqual( isBoolean( new Boolean( true ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive boolean', function test( t ) {
-	t.strictEqual( isBoolean( true ), false, 'returns false' );
-	t.strictEqual( isBoolean( false ), false, 'returns false' );
+	t.strictEqual( isBoolean( true ), false, 'returns expected value' );
+	t.strictEqual( isBoolean( false ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -70,7 +70,7 @@ tape( 'if `Symbol.toStringTag` is supported, the function guards against objects
 	if ( hasToStringTag() ) {
 		mock[ Symbol.toStringTag ] = 'Boolean';
 	}
-	t.strictEqual( isBoolean( mock ), false, 'returns false' );
+	t.strictEqual( isBoolean( mock ), false, 'returns expected value' );
 	t.end();
 
 	function detect() {
@@ -89,8 +89,8 @@ tape( 'if `Symbol.toStringTag` is not supported, the function attempts to determ
 		'@stdlib/assert/has-tostringtag-support': detect
 	});
 
-	t.strictEqual( isBoolean( new Boolean( true ) ), true, 'returns true' );
-	t.strictEqual( isBoolean( {} ), false, 'returns false' );
+	t.strictEqual( isBoolean( new Boolean( true ) ), true, 'returns expected value' );
+	t.strictEqual( isBoolean( {} ), false, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/assert/is-boolean/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-boolean/test/test.primitive.js
index 4b4a7f586aaf..f03df8d033f9 100644
--- a/lib/node_modules/@stdlib/assert/is-boolean/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-boolean/test/test.primitive.js
@@ -34,14 +34,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive boolean', function test( t ) {
-	t.strictEqual( isBoolean( true ), true, 'returns true' );
-	t.strictEqual( isBoolean( false ), true, 'returns true' );
+	t.strictEqual( isBoolean( true ), true, 'returns expected value' );
+	t.strictEqual( isBoolean( false ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a boolean object', function test( t ) {
-	t.strictEqual( isBoolean( new Boolean( true ) ), false, 'returns false' );
-	t.strictEqual( isBoolean( new Boolean( false ) ), false, 'returns false' );
+	t.strictEqual( isBoolean( new Boolean( true ) ), false, 'returns expected value' );
+	t.strictEqual( isBoolean( new Boolean( false ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-boolean/test/test.try2serialize.js b/lib/node_modules/@stdlib/assert/is-boolean/test/test.try2serialize.js
index 721ce4cb2062..ff0716ecf2b6 100644
--- a/lib/node_modules/@stdlib/assert/is-boolean/test/test.try2serialize.js
+++ b/lib/node_modules/@stdlib/assert/is-boolean/test/test.try2serialize.js
@@ -34,14 +34,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if able to serialize', function test( t ) {
-	t.strictEqual( serialize( true ), true, 'returns true' );
-	t.strictEqual( serialize( new Boolean( true ) ), true, 'returns true' );
-	t.strictEqual( serialize( false ), true, 'returns true' );
-	t.strictEqual( serialize( new Boolean( false ) ), true, 'returns true' );
+	t.strictEqual( serialize( true ), true, 'returns expected value' );
+	t.strictEqual( serialize( new Boolean( true ) ), true, 'returns expected value' );
+	t.strictEqual( serialize( false ), true, 'returns expected value' );
+	t.strictEqual( serialize( new Boolean( false ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if unable to serialize', function test( t ) {
-	t.strictEqual( serialize( {} ), false, 'returns false' );
+	t.strictEqual( serialize( {} ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-boxed-primitive/test/test.js b/lib/node_modules/@stdlib/assert/is-boxed-primitive/test/test.js
index 261af6149c28..8e858186c8c7 100644
--- a/lib/node_modules/@stdlib/assert/is-boxed-primitive/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-boxed-primitive/test/test.js
@@ -56,18 +56,18 @@ tape( 'the function returns `true` if provided a boxed primitive', function test
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isBoxedPrimitive( values[i] ), true, 'returns true' );
+		t.strictEqual( isBoxedPrimitive( values[i] ), true, 'returns expected value' );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided a boxed `Symbol`', opts, function test( t ) {
-	t.strictEqual( isBoxedPrimitive( Object( Symbol( 'symbol' ) ) ), true, 'returns true' );
+	t.strictEqual( isBoxedPrimitive( Object( Symbol( 'symbol' ) ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive `Symbol`', opts, function test( t ) {
-	t.strictEqual( isBoxedPrimitive( Symbol( 'symbol' ) ), false, 'returns false' );
+	t.strictEqual( isBoxedPrimitive( Symbol( 'symbol' ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-browser/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-browser/test/test.browser.js
index 91bcad10229e..8fa0486ab449 100644
--- a/lib/node_modules/@stdlib/assert/is-browser/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-browser/test/test.browser.js
@@ -33,6 +33,6 @@ tape( 'main export is a boolean', function test( t ) {
 });
 
 tape( 'the exported value is always `true`', function test( t ) {
-	t.strictEqual( IS_BROWSER, true, 'returns true' );
+	t.strictEqual( IS_BROWSER, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-browser/test/test.main.js b/lib/node_modules/@stdlib/assert/is-browser/test/test.main.js
index aa6d8c77c14b..07ff263fc0a9 100644
--- a/lib/node_modules/@stdlib/assert/is-browser/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-browser/test/test.main.js
@@ -58,7 +58,7 @@ tape( 'the function returns `true` if the runtime is a web browser', function te
 		'./global_scope.js': true
 	});
 
-	t.strictEqual( isBrowser(), true, 'returns true' );
+	t.strictEqual( isBrowser(), true, 'returns expected value' );
 	t.end();
 
 	function getGlobal() {
@@ -79,7 +79,7 @@ tape( 'the function returns `false` if the runtime is not a web browser (`window
 		'./global_scope.js': true
 	});
 
-	t.strictEqual( isBrowser(), false, 'returns false' );
+	t.strictEqual( isBrowser(), false, 'returns expected value' );
 	t.end();
 
 	function getGlobal() {
@@ -100,7 +100,7 @@ tape( 'the function returns `false` if the runtime is not a web browser (`window
 		'./global_scope.js': true
 	});
 
-	t.strictEqual( isBrowser(), false, 'returns false' );
+	t.strictEqual( isBrowser(), false, 'returns expected value' );
 	t.end();
 
 	function getGlobal() {
@@ -121,7 +121,7 @@ tape( 'the function returns `false` if the runtime is not a web browser (`window
 		'./global_scope.js': false
 	});
 
-	t.strictEqual( isBrowser(), false, 'returns false' );
+	t.strictEqual( isBrowser(), false, 'returns expected value' );
 	t.end();
 
 	function getGlobal() {
diff --git a/lib/node_modules/@stdlib/assert/is-centrosymmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-centrosymmetric-matrix/test/test.js
index eeafaf106561..067a6247564a 100644
--- a/lib/node_modules/@stdlib/assert/is-centrosymmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-centrosymmetric-matrix/test/test.js
@@ -49,7 +49,7 @@ tape( 'the function returns `true` if provided a centrosymmetric matrix (odd ord
 	];
 	arr = ndarray( 'generic', buffer, [ 5, 5 ], [ 5, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isCentrosymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'the function returns `true` if provided a centrosymmetric matrix (even or
 	];
 	arr = ndarray( 'generic', buffer, [ 6, 6 ], [ 6, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isCentrosymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -90,7 +90,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isCentrosymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
@@ -101,14 +101,14 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 tape( 'the function returns `false` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a centrosymmetric matrix (even order)', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 3, 4 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -123,7 +123,7 @@ tape( 'the function returns `false` if not provided a centrosymmetric matrix (od
 	];
 	arr = ndarray( 'generic', buffer, [ 3, 3 ], [ 3, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -144,7 +144,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -165,7 +165,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isCentrosymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
diff --git a/lib/node_modules/@stdlib/assert/is-circular-array/test/test.js b/lib/node_modules/@stdlib/assert/is-circular-array/test/test.js
index 46a2aa32e837..e5de85439c72 100644
--- a/lib/node_modules/@stdlib/assert/is-circular-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-circular-array/test/test.js
@@ -69,7 +69,7 @@ tape( 'the function returns `false` if not provided an array', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isCircularArray( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircularArray( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns `false` if provided an array not containing a circul
 		arr3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isCircularArray( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircularArray( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -127,7 +127,7 @@ tape( 'the function returns `true` if provided an array containing a circular re
 		arr3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isCircularArray( values[i] ), true, 'returns true' );
+		t.strictEqual( isCircularArray( values[i] ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-circular-plain-object/test/test.js b/lib/node_modules/@stdlib/assert/is-circular-plain-object/test/test.js
index ec66ae7e5b66..53f3bf1fdf2d 100644
--- a/lib/node_modules/@stdlib/assert/is-circular-plain-object/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-circular-plain-object/test/test.js
@@ -49,7 +49,7 @@ tape( 'the function returns `false` if not provided a plain object', function te
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isCircularPlainObject( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircularPlainObject( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns `false` if provided a plain object not containing a
 		obj3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isCircularPlainObject( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircularPlainObject( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -117,7 +117,7 @@ tape( 'the function returns `true` if provided a plain object containing a circu
 		obj3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isCircularPlainObject( values[i] ), true, 'returns true' );
+		t.strictEqual( isCircularPlainObject( values[i] ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-circular/test/test.js b/lib/node_modules/@stdlib/assert/is-circular/test/test.js
index 7d0d2c79ad31..e81f62a6db1d 100644
--- a/lib/node_modules/@stdlib/assert/is-circular/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-circular/test/test.js
@@ -45,7 +45,7 @@ tape( 'the function returns `false` if not provided an object-like value', funct
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isCircular( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircular( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns `false` if provided an object not containing a circu
 		new RegExp( '[0-9]' ) // eslint-disable-line prefer-regex-literals
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isCircular( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircular( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function returns `false` if provided an array not containing a circul
 		arr3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isCircular( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircular( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -135,7 +135,7 @@ tape( 'the function returns `false` if provided a function not containing a circ
 		fcn3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isCircular( values[i] ), false, 'returns false' );
+		t.strictEqual( isCircular( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -179,7 +179,7 @@ tape( 'the function returns `true` if provided an object containing a circular r
 		date
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isCircular( values[i] ), true, 'returns true' );
+		t.strictEqual( isCircular( values[i] ), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -208,7 +208,7 @@ tape( 'the function returns `true` if provided an array containing a circular re
 		arr3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isCircular( values[i] ), true, 'returns true' );
+		t.strictEqual( isCircular( values[i] ), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -235,7 +235,7 @@ tape( 'the function returns `true` if provided a function containing a circular
 		fcn3
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isCircular( values[i] ), true, 'returns true' );
+		t.strictEqual( isCircular( values[i] ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-class/test/es2015-class/index.js b/lib/node_modules/@stdlib/assert/is-class/test/es2015-class/index.js
index 65c64d850591..ea3ee2b2655e 100644
--- a/lib/node_modules/@stdlib/assert/is-class/test/es2015-class/index.js
+++ b/lib/node_modules/@stdlib/assert/is-class/test/es2015-class/index.js
@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-restricted-syntax, max-classes-per-file */
+/* eslint-disable no-restricted-syntax, max-classes-per-file, node/no-unsupported-features/es-syntax */
 
 'use strict';
 
@@ -30,8 +30,8 @@ var isClass = require( './../../lib' );
 
 tape( 'the function returns `true` if provided an ES2015 class', function test( t ) {
 	var Rectangle = class {};
-	t.strictEqual( isClass( Rectangle ), true, 'returns true' );
+	t.strictEqual( isClass( Rectangle ), true, 'returns expected value' );
 
-	t.strictEqual( isClass( class Person {} ), true, 'returns true' );
+	t.strictEqual( isClass( class Person {} ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-complex-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex-like/test/test.js
index db87d29ecc33..1270804803d8 100644
--- a/lib/node_modules/@stdlib/assert/is-complex-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex-like/test/test.js
@@ -38,16 +38,16 @@ tape( 'the function returns `true` if provided a complex number-like object', fu
 	var v;
 
 	v = new Complex64( 3.0, 2.0 );
-	t.strictEqual( isComplexLike( v ), true, 'returns true' );
+	t.strictEqual( isComplexLike( v ), true, 'returns expected value' );
 
 	v = new Complex128( 3.0, 2.0 );
-	t.strictEqual( isComplexLike( v ), true, 'returns true' );
+	t.strictEqual( isComplexLike( v ), true, 'returns expected value' );
 
 	v = {
 		're': 1.0,
 		'im': -1.0
 	};
-	t.strictEqual( isComplexLike( v ), true, 'returns true' );
+	t.strictEqual( isComplexLike( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-complex-typed-array/test/test.js b/lib/node_modules/@stdlib/assert/is-complex-typed-array/test/test.js
index 17842944ef58..f8814433b3db 100644
--- a/lib/node_modules/@stdlib/assert/is-complex-typed-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex-typed-array/test/test.js
@@ -114,7 +114,7 @@ tape( 'the function returns `true` if provided a complex typed array from a diff
 		'require': require
 	};
 	arr = vm.runInNewContext( 'new ( require( "@stdlib/array/complex64" ) )( [ 5.0, 3.0 ] )', ctx );
-	t.strictEqual( isComplexTypedArray( arr ), true, 'returns true' );
+	t.strictEqual( isComplexTypedArray( arr ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -128,7 +128,7 @@ tape( 'the function returns `true` if provided an object from a different realm
 		'require': require
 	};
 	arr = vm.runInNewContext( 'function Arr() { return this; }; Arr.prototype = Object.create( require( "@stdlib/array/complex64" ).prototype ); Arr.prototype.constructor = Arr; new Arr( [ 5.0, 3.0 ] );', ctx );
-	t.strictEqual( isComplexTypedArray( arr ), true, 'returns true' );
+	t.strictEqual( isComplexTypedArray( arr ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-complex/test/test.js b/lib/node_modules/@stdlib/assert/is-complex/test/test.js
index 560d7d4440cc..a9888da4b28a 100644
--- a/lib/node_modules/@stdlib/assert/is-complex/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex/test/test.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a 64-bit or 128-bit complex number', function test( t ) {
-	t.strictEqual( isComplex( new Complex64( 3.0, 2.0 ) ), true, 'returns true' );
-	t.strictEqual( isComplex( new Complex128( 3.0, 2.0 ) ), true, 'returns true' );
+	t.strictEqual( isComplex( new Complex64( 3.0, 2.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isComplex( new Complex128( 3.0, 2.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-complex128/test/test.js b/lib/node_modules/@stdlib/assert/is-complex128/test/test.js
index 4ff904abf04d..46730af53e34 100644
--- a/lib/node_modules/@stdlib/assert/is-complex128/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex128/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a 128-bit complex number', function test( t ) {
-	t.strictEqual( isComplex128( new Complex128( 3.0, 2.0 ) ), true, 'returns true' );
+	t.strictEqual( isComplex128( new Complex128( 3.0, 2.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-complex128array/test/test.js b/lib/node_modules/@stdlib/assert/is-complex128array/test/test.js
index 1b79b266af45..e5f16af571c1 100644
--- a/lib/node_modules/@stdlib/assert/is-complex128array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex128array/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a Complex128Array', function test( t ) {
-	t.strictEqual( isComplex128Array( new Complex128Array( 10 ) ), true, 'returns true' );
+	t.strictEqual( isComplex128Array( new Complex128Array( 10 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-complex128matrix-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex128matrix-like/test/test.js
index bccd17dbab2c..0d45e0d8f9f6 100644
--- a/lib/node_modules/@stdlib/assert/is-complex128matrix-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex128matrix-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 2-dimensional ndarray containing double-precision complex floating-point numbers', function test( t ) {
 	var arr = ndarray( 'complex128', new Complex128Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isComplex128MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex128MatrixLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isComplex128MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex128MatrixLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-complex128ndarray-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex128ndarray-like/test/test.js
index b77e3bfdc1b5..d5f791f48f35 100644
--- a/lib/node_modules/@stdlib/assert/is-complex128ndarray-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex128ndarray-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided an ndarray containing double-precision complex floating-point numbers', function test( t ) {
 	var arr = ndarray( 'complex128', new Complex128Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isComplex128ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex128ndarrayLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided an ndarray-like object containing
 		'set': noop
 	};
 
-	t.strictEqual( isComplex128ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex128ndarrayLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-complex128vector-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex128vector-like/test/test.js
index d221375d9c95..bf8800a478ab 100644
--- a/lib/node_modules/@stdlib/assert/is-complex128vector-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex128vector-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 1-dimensional ndarray containing double-precision complex floating-point numbers', function test( t ) {
 	var arr = ndarray( 'complex128', new Complex128Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 4 ], [ 1 ], 0, 'row-major' );
 
-	t.strictEqual( isComplex128VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex128VectorLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 1-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isComplex128VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex128VectorLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-complex64/test/test.js b/lib/node_modules/@stdlib/assert/is-complex64/test/test.js
index f35e667a7d05..4f91252ce5da 100644
--- a/lib/node_modules/@stdlib/assert/is-complex64/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex64/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a 64-bit complex number', function test( t ) {
-	t.strictEqual( isComplex64( new Complex64( 3.0, 2.0 ) ), true, 'returns true' );
+	t.strictEqual( isComplex64( new Complex64( 3.0, 2.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-complex64array/test/test.js b/lib/node_modules/@stdlib/assert/is-complex64array/test/test.js
index 295f96e7f5d2..3a0d424c15f5 100644
--- a/lib/node_modules/@stdlib/assert/is-complex64array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex64array/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a Complex64Array', function test( t ) {
-	t.strictEqual( isComplex64Array( new Complex64Array( 10 ) ), true, 'returns true' );
+	t.strictEqual( isComplex64Array( new Complex64Array( 10 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-complex64matrix-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex64matrix-like/test/test.js
index ab4319138945..a813dcf8e538 100644
--- a/lib/node_modules/@stdlib/assert/is-complex64matrix-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex64matrix-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 2-dimensional ndarray containing single-precision complex floating-point numbers', function test( t ) {
 	var arr = ndarray( 'complex64', new Complex64Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isComplex64MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex64MatrixLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isComplex64MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex64MatrixLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-complex64ndarray-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex64ndarray-like/test/test.js
index ada63714d77a..2bee90bf5f4a 100644
--- a/lib/node_modules/@stdlib/assert/is-complex64ndarray-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex64ndarray-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided an ndarray containing single-precision complex floating-point numbers', function test( t ) {
 	var arr = ndarray( 'complex64', new Complex64Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isComplex64ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex64ndarrayLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided an ndarray-like object containing
 		'set': noop
 	};
 
-	t.strictEqual( isComplex64ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex64ndarrayLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-complex64vector-like/test/test.js b/lib/node_modules/@stdlib/assert/is-complex64vector-like/test/test.js
index 1b300d49d62d..9131ef8458af 100644
--- a/lib/node_modules/@stdlib/assert/is-complex64vector-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-complex64vector-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 1-dimensional ndarray containing single-precision complex floating-point numbers', function test( t ) {
 	var arr = ndarray( 'complex64', new Complex64Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 4 ], [ 1 ], 0, 'row-major' );
 
-	t.strictEqual( isComplex64VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex64VectorLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 1-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isComplex64VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isComplex64VectorLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-composite/test/test.object.js b/lib/node_modules/@stdlib/assert/is-composite/test/test.object.js
index d5557cea1067..965682fb6efc 100644
--- a/lib/node_modules/@stdlib/assert/is-composite/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-composite/test/test.object.js
@@ -67,9 +67,9 @@ tape( 'the function returns `false` if provided a number object whose value is a
 });
 
 tape( 'the function returns `false` if provided a primitive composite number', function test( t ) {
-	t.strictEqual( isComposite( 6.0 ), false, 'returns false' );
-	t.strictEqual( isComposite( 10.0 ), false, 'returns false' );
-	t.strictEqual( isComposite( 49.0 ), false, 'returns false' );
+	t.strictEqual( isComposite( 6.0 ), false, 'returns expected value' );
+	t.strictEqual( isComposite( 10.0 ), false, 'returns expected value' );
+	t.strictEqual( isComposite( 49.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-configurable-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-configurable-property-in/test/test.js
index 2ee19fd3d877..2ec283989877 100644
--- a/lib/node_modules/@stdlib/assert/is-configurable-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-configurable-property-in/test/test.js
@@ -46,16 +46,16 @@ tape( 'the function returns `true` if an object property is configurable', funct
 		'a': 'b'
 	};
 	bool = isConfigurablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isConfigurablePropertyIn( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isConfigurablePropertyIn( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isConfigurablePropertyIn( new Foo(), 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -66,7 +66,7 @@ tape( 'the function returns `true` if an object property is configurable', funct
 	});
 
 	bool = isConfigurablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,13 +75,13 @@ tape( 'the function returns `true` if provided a configurable inherited property
 	var bool;
 
 	bool = isConfigurablePropertyIn( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isConfigurablePropertyIn( {}, 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isConfigurablePropertyIn( {}, 'constructor' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -114,13 +114,13 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isConfigurablePropertyIn( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isConfigurablePropertyIn( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isConfigurablePropertyIn( [ 'a' ], 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function returns `false` if provided a non-configurable inherited pro
 	obj = new Foo();
 
 	bool = isConfigurablePropertyIn( obj, 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -152,10 +152,10 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isConfigurablePropertyIn( 'beep', 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isConfigurablePropertyIn( 'beep', 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-configurable-property/test/test.js b/lib/node_modules/@stdlib/assert/is-configurable-property/test/test.js
index 9d60e1dc91bd..effc239bc8ce 100644
--- a/lib/node_modules/@stdlib/assert/is-configurable-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-configurable-property/test/test.js
@@ -46,16 +46,16 @@ tape( 'the function returns `true` if an object property is configurable', funct
 		'a': 'b'
 	};
 	bool = isConfigurableProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isConfigurableProperty( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isConfigurableProperty( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isConfigurableProperty( new Foo(), 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -66,7 +66,7 @@ tape( 'the function returns `true` if an object property is configurable', funct
 	});
 
 	bool = isConfigurableProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -99,13 +99,13 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isConfigurableProperty( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isConfigurableProperty( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isConfigurableProperty( [ 'a' ], 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -114,13 +114,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isConfigurableProperty( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isConfigurableProperty( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isConfigurableProperty( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -129,7 +129,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isConfigurableProperty( 'beep', 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.main.js
index feb8533ec6b5..9f800f7825d4 100644
--- a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a cube number', function test( t ) {
-	t.strictEqual( isCubeNumber( 8.0 ), true, 'returns true' );
-	t.strictEqual( isCubeNumber( new Number( 8.0 ) ), true, 'returns true' );
+	t.strictEqual( isCubeNumber( 8.0 ), true, 'returns expected value' );
+	t.strictEqual( isCubeNumber( new Number( 8.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.object.js
index ec03dfbbd595..05e4dc8886ac 100644
--- a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a cube number', function test( t ) {
-	t.strictEqual( isCubeNumber( new Number( 8.0 ) ), true, 'returns true' );
+	t.strictEqual( isCubeNumber( new Number( 8.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive cube number', function test( t ) {
-	t.strictEqual( isCubeNumber( 8.0 ), false, 'returns false' );
+	t.strictEqual( isCubeNumber( 8.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.primitive.js
index 154b87a65b44..948091901fe3 100644
--- a/lib/node_modules/@stdlib/assert/is-cube-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-cube-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive cube number', function test( t ) {
-	t.strictEqual( isCubeNumber( 8.0 ), true, 'returns true' );
+	t.strictEqual( isCubeNumber( 8.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object', function test( t ) {
-	t.strictEqual( isCubeNumber( new Number( 8.0 ) ), false, 'returns false' );
+	t.strictEqual( isCubeNumber( new Number( 8.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-data-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-data-property-in/test/test.js
index 98e3e635adb9..f43cc45a0e56 100644
--- a/lib/node_modules/@stdlib/assert/is-data-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-data-property-in/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property has a data descriptor',
 		'a': 'b'
 	};
 	bool = isDataPropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDataPropertyIn( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDataPropertyIn( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDataPropertyIn( new Foo(), 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDataPropertyIn( [ 'a' ], 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property has a data descriptor',
 	});
 
 	bool = isDataPropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isDataPropertyIn( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -106,7 +106,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isDataPropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -123,13 +123,13 @@ tape( 'the function returns `true` if provided an inherited property having a da
 	var bool;
 
 	bool = isDataPropertyIn( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDataPropertyIn( {}, 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDataPropertyIn( {}, 'constructor' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -152,7 +152,7 @@ tape( 'the function returns `false` if provided an inherited property not having
 	obj = new Foo();
 
 	bool = isDataPropertyIn( obj, 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -169,7 +169,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isDataPropertyIn( 'beep', 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-data-property/test/test.js b/lib/node_modules/@stdlib/assert/is-data-property/test/test.js
index acb62aefb0a2..28c30bd37723 100644
--- a/lib/node_modules/@stdlib/assert/is-data-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-data-property/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property has a data descriptor',
 		'a': 'b'
 	};
 	bool = isDataProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDataProperty( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDataProperty( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDataProperty( new Foo(), 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDataProperty( [ 'a' ], 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property has a data descriptor',
 	});
 
 	bool = isDataProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isDataProperty( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -106,7 +106,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isDataProperty( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -123,13 +123,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isDataProperty( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isDataProperty( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isDataProperty( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -138,7 +138,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isDataProperty( 'beep', 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-dataview/test/test.js b/lib/node_modules/@stdlib/assert/is-dataview/test/test.js
index 6c8854db9281..6079bb7f4b45 100644
--- a/lib/node_modules/@stdlib/assert/is-dataview/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-dataview/test/test.js
@@ -32,6 +32,7 @@ var Uint16Array = require( '@stdlib/array/uint16' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var ArrayBuffer = require( '@stdlib/array/buffer' );
 var DataView = require( '@stdlib/array/dataview' );
+var zeros = require( '@stdlib/array/zeros' );
 var isDataView = require( './../lib' );
 
 
@@ -44,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a DataView', function test( t ) {
-	t.strictEqual( isDataView( new DataView( new ArrayBuffer( 10 ) ) ), true, 'returns true' );
+	t.strictEqual( isDataView( new DataView( new ArrayBuffer( 10 ) ) ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -62,7 +63,7 @@ tape( 'the function returns `false` if not provided a DataView', function test(
 		[],
 		{},
 		function noop() {},
-		new Array( 10 ),
+		zeros( 10, 'generic' ),
 		new Float64Array( 10 ),
 		new Float32Array( 10 ),
 		new Uint32Array( 10 ),
diff --git a/lib/node_modules/@stdlib/assert/is-date-object-array/test/test.js b/lib/node_modules/@stdlib/assert/is-date-object-array/test/test.js
index fd253bf41ea0..ec0b902afef6 100644
--- a/lib/node_modules/@stdlib/assert/is-date-object-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-date-object-array/test/test.js
@@ -36,7 +36,7 @@ tape( 'the function tests for an array-like object containing only `Date` object
 	var arr;
 
 	arr = [ new Date(), new Date(), new Date() ];
-	t.strictEqual( isDateObjectArray( arr ), true, 'returns true' );
+	t.strictEqual( isDateObjectArray( arr ), true, 'returns expected value' );
 
 	arr = [
 		{
@@ -45,17 +45,17 @@ tape( 'the function tests for an array-like object containing only `Date` object
 		/.*/,
 		{}
 	];
-	t.strictEqual( isDateObjectArray( arr ), false, 'returns false' );
+	t.strictEqual( isDateObjectArray( arr ), false, 'returns expected value' );
 
 	arr = [ 5.0, {}, new Date() ];
-	t.strictEqual( isDateObjectArray( arr ), false, 'returns false' );
+	t.strictEqual( isDateObjectArray( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Date(),
 		'1': new Date()
 	};
-	t.strictEqual( isDateObjectArray( arr ), true, 'returns true' );
+	t.strictEqual( isDateObjectArray( arr ), true, 'returns expected value' );
 
 	arr = [];
 	t.strictEqual( isDateObjectArray( arr ), false, 'returns false when provided an empty array' );
diff --git a/lib/node_modules/@stdlib/assert/is-date-object/test/test.js b/lib/node_modules/@stdlib/assert/is-date-object/test/test.js
index 2a0b9e47db56..2d7024669b72 100644
--- a/lib/node_modules/@stdlib/assert/is-date-object/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-date-object/test/test.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a `Date` object', function test( t ) {
-	t.strictEqual( isDateObject( new Date() ), true, 'returns true' );
+	t.strictEqual( isDateObject( new Date() ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -64,7 +64,7 @@ tape( 'if `Symbol.toStringTag` is supported, the function guards against objects
 	if ( hasToStringTag() ) {
 		mock[ Symbol.toStringTag ] = 'Date';
 	}
-	t.strictEqual( isDateObject( mock ), false, 'returns false' );
+	t.strictEqual( isDateObject( mock ), false, 'returns expected value' );
 
 	t.end();
 
@@ -84,7 +84,7 @@ tape( 'if `Symbol.toStringTag` is supported, the function returns `true` if prov
 		'@stdlib/assert/has-tostringtag-support': detect
 	});
 
-	t.strictEqual( isDateObject( new Date() ), true, 'returns true' );
+	t.strictEqual( isDateObject( new Date() ), true, 'returns expected value' );
 
 	t.end();
 
@@ -98,8 +98,8 @@ tape( 'if `Symbol.toStringTag` is not supported, the function attempts to determ
 		'@stdlib/assert/has-tostringtag-support': detect
 	});
 
-	t.strictEqual( isDateObject( new Date() ), true, 'returns true' );
-	t.strictEqual( isDateObject( {} ), false, 'returns false' );
+	t.strictEqual( isDateObject( new Date() ), true, 'returns expected value' );
+	t.strictEqual( isDateObject( {} ), false, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/assert/is-digit-string/test/test.js b/lib/node_modules/@stdlib/assert/is-digit-string/test/test.js
index a697fabf039b..6b15cb54afe2 100644
--- a/lib/node_modules/@stdlib/assert/is-digit-string/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-digit-string/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a string containing all numeric digits', function test( t ) {
-	t.strictEqual( isDigitString( '0123456789' ), true, 'returns true' );
+	t.strictEqual( isDigitString( '0123456789' ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-docker/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-docker/test/test.browser.js
index 32c68b3931a2..cd82ccc35cda 100644
--- a/lib/node_modules/@stdlib/assert/is-docker/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-docker/test/test.browser.js
@@ -33,6 +33,6 @@ tape( 'main export is a boolean', function test( t ) {
 });
 
 tape( 'the exported value is always `false`', function test( t ) {
-	t.strictEqual( IS_DOCKER, false, 'returns false' );
+	t.strictEqual( IS_DOCKER, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-docker/test/test.main.js b/lib/node_modules/@stdlib/assert/is-docker/test/test.main.js
index f22a0ebc6499..d553a94ed69d 100644
--- a/lib/node_modules/@stdlib/assert/is-docker/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-docker/test/test.main.js
@@ -45,7 +45,7 @@ tape( 'the function returns `true` if the process is running in a Docker contain
 	});
 
 	bool = isDocker();
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -61,7 +61,7 @@ tape( 'the function returns `true` if the process is running in a Docker contain
 	});
 
 	bool = isDocker();
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'the function returns `false` if the process is not running in a Docker co
 	});
 
 	bool = isDocker();
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-domain-name/test/test.js b/lib/node_modules/@stdlib/assert/is-domain-name/test/test.js
index 50563791e3ee..d47293668a20 100644
--- a/lib/node_modules/@stdlib/assert/is-domain-name/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-domain-name/test/test.js
@@ -37,22 +37,22 @@ tape( 'the function returns `true` if provided a valid domain name', function te
 	var bool;
 
 	bool = isDomainName( 'example.com' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDomainName( 'foo.example.com' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDomainName( 'foo.bar.example.com' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDomainName( 'foo.bar.baz.example.com' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDomainName( 'foo.bar.baz.qux.example.com' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isDomainName( 'foo.bar.baz.qux.quux.example.com' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-electron-main/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-electron-main/test/test.browser.js
index 058b06f03a7b..2f4fcfa99164 100644
--- a/lib/node_modules/@stdlib/assert/is-electron-main/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-electron-main/test/test.browser.js
@@ -33,6 +33,6 @@ tape( 'main export is a boolean', function test( t ) {
 });
 
 tape( 'the exported value is always `false`', function test( t ) {
-	t.strictEqual( IS_ELECTRON_MAIN, false, 'returns false' );
+	t.strictEqual( IS_ELECTRON_MAIN, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-electron-main/test/test.main.js b/lib/node_modules/@stdlib/assert/is-electron-main/test/test.main.js
index 32b64ff58c9c..6aed7818cb9b 100644
--- a/lib/node_modules/@stdlib/assert/is-electron-main/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-electron-main/test/test.main.js
@@ -60,7 +60,7 @@ tape( 'the function returns `true` if runtime is the main Electron process', fun
 	});
 
 	bool = isElectronMain();
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,7 +78,7 @@ tape( 'the function returns `false` if runtime is not the main Electron process
 	});
 
 	bool = isElectronMain();
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns `false` if runtime is not the main Electron process
 	});
 
 	bool = isElectronMain();
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-electron-renderer/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-electron-renderer/test/test.browser.js
index ce8d643a3266..f00d9781298d 100644
--- a/lib/node_modules/@stdlib/assert/is-electron-renderer/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-electron-renderer/test/test.browser.js
@@ -33,6 +33,6 @@ tape( 'main export is a boolean', function test( t ) {
 });
 
 tape( 'the exported value is always `false`', function test( t ) {
-	t.strictEqual( IS_ELECTRON_RENDERER, false, 'returns false' );
+	t.strictEqual( IS_ELECTRON_RENDERER, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-electron-renderer/test/test.main.js b/lib/node_modules/@stdlib/assert/is-electron-renderer/test/test.main.js
index 1c7866d658c9..f45466feef87 100644
--- a/lib/node_modules/@stdlib/assert/is-electron-renderer/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-electron-renderer/test/test.main.js
@@ -60,7 +60,7 @@ tape( 'the function returns `true` if runtime is the Electron renderer process',
 	});
 
 	bool = isElectronRenderer();
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,7 +78,7 @@ tape( 'the function returns `false` if runtime is not the Electron renderer proc
 	});
 
 	bool = isElectronRenderer();
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'the function returns `false` if runtime is not the Electron renderer proc
 	});
 
 	bool = isElectronRenderer();
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-electron/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-electron/test/test.browser.js
index 4155bdd96611..e045613d31f3 100644
--- a/lib/node_modules/@stdlib/assert/is-electron/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-electron/test/test.browser.js
@@ -33,6 +33,6 @@ tape( 'main export is a boolean', function test( t ) {
 });
 
 tape( 'the exported value is always `false`', function test( t ) {
-	t.strictEqual( IS_ELECTRON, false, 'returns false' );
+	t.strictEqual( IS_ELECTRON, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-electron/test/test.main.js b/lib/node_modules/@stdlib/assert/is-electron/test/test.main.js
index 11a9e60b660a..295519bf3e2f 100644
--- a/lib/node_modules/@stdlib/assert/is-electron/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-electron/test/test.main.js
@@ -61,7 +61,7 @@ tape( 'the function returns `true` if runtime is Electron (browser/main)', funct
 	});
 
 	bool = isElectron();
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -84,7 +84,7 @@ tape( 'the function returns `true` if runtime is Electron (renderer)', function
 	});
 
 	bool = isElectron();
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -111,7 +111,7 @@ tape( 'the function returns `false` if runtime is not Electron (`process` variab
 	});
 
 	bool = isElectron();
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function returns `false` if runtime is not Electron (`process.version
 	});
 
 	bool = isElectron();
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -153,7 +153,7 @@ tape( 'the function returns `false` if runtime is not Electron (`process.version
 	});
 
 	bool = isElectron();
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -176,7 +176,7 @@ tape( 'the function returns `false` if runtime is not Electron (`process.version
 	});
 
 	bool = isElectron();
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -199,7 +199,7 @@ tape( 'the function returns `false` if runtime is not Electron (`process.type` i
 	});
 
 	bool = isElectron();
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/assert/is-email-address/test/test.js b/lib/node_modules/@stdlib/assert/is-email-address/test/test.js
index ba174dca5cd0..a53e7bd43144 100644
--- a/lib/node_modules/@stdlib/assert/is-email-address/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-email-address/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` when provided an email address (equals a string including the `@` character)', function test( t ) {
-	t.strictEqual( isEmail( 'beep@boop.com' ), true, 'returns true' );
+	t.strictEqual( isEmail( 'beep@boop.com' ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -56,7 +56,7 @@ tape( 'the function returns `false` when not provided an email address', functio
 		function noop() {}
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isEmail( values[ i ] ), false, 'returns false' );
+		t.strictEqual( isEmail( values[ i ] ), false, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-empty-array/test/test.js b/lib/node_modules/@stdlib/assert/is-empty-array/test/test.js
index 4f9ca2ca0ccb..78f4ecc19b38 100644
--- a/lib/node_modules/@stdlib/assert/is-empty-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-empty-array/test/test.js
@@ -16,13 +16,12 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-array-constructor */
-
 'use strict';
 
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/zeros' );
 var isEmptyArray = require( './../lib' );
 
 
@@ -35,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an empty array', function test( t ) {
-	t.strictEqual( isEmptyArray( [] ), true, 'returns true' );
-	t.strictEqual( isEmptyArray( new Array() ), true, 'returns true' );
+	t.strictEqual( isEmptyArray( [] ), true, 'returns expected value' );
+	t.strictEqual( isEmptyArray( [] ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -53,7 +52,7 @@ tape( 'the function returns `false` if not provided an empty array', function te
 		null,
 		void 0,
 		[ 1, 2, 3 ],
-		new Array( 10 ),
+		zeros( 10, 'generic' ),
 		{},
 		function noop() {}
 	];
diff --git a/lib/node_modules/@stdlib/assert/is-empty-object/test/test.js b/lib/node_modules/@stdlib/assert/is-empty-object/test/test.js
index ea90b4fcf986..1a90f45b5134 100644
--- a/lib/node_modules/@stdlib/assert/is-empty-object/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-empty-object/test/test.js
@@ -16,13 +16,14 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-object, object-curly-newline  */
+/* eslint-disable object-curly-newline  */
 
 'use strict';
 
 // MODULES //
 
 var tape = require( 'tape' );
+var Object = require( '@stdlib/object/ctor' );
 var Symbol = require( '@stdlib/symbol/ctor' );
 var hasSymbolSupport = require( '@stdlib/assert/has-symbol-support' );
 var isEmptyObject = require( './../lib' );
@@ -44,8 +45,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an empty object', function test( t ) {
-	t.strictEqual( isEmptyObject( {} ), true, 'returns true' );
-	t.strictEqual( isEmptyObject( new Object() ), true, 'returns true' );
+	t.strictEqual( isEmptyObject( {} ), true, 'returns expected value' );
+	t.strictEqual( isEmptyObject( new Object() ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -77,7 +78,7 @@ tape( 'the function returns `false` if provided an object with symbol property k
 	var obj = {};
 
 	obj[ sym ] = true;
-	t.strictEqual( isEmptyObject( obj ), false, 'returns false' );
+	t.strictEqual( isEmptyObject( obj ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-empty-string/test/test.main.js b/lib/node_modules/@stdlib/assert/is-empty-string/test/test.main.js
index 3c5a1be8d00e..544a1523b6b9 100644
--- a/lib/node_modules/@stdlib/assert/is-empty-string/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-empty-string/test/test.main.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an empty string', function test( t ) {
-	t.strictEqual( isEmptyString( '' ), true, 'returns true' );
-	t.strictEqual( isEmptyString( new String( '' ) ), true, 'returns true' );
+	t.strictEqual( isEmptyString( '' ), true, 'returns expected value' );
+	t.strictEqual( isEmptyString( new String( '' ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-empty-string/test/test.object.js b/lib/node_modules/@stdlib/assert/is-empty-string/test/test.object.js
index 9e94c49c7728..8e1153d55b48 100644
--- a/lib/node_modules/@stdlib/assert/is-empty-string/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-empty-string/test/test.object.js
@@ -44,12 +44,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an empty string object', function test( t ) {
-	t.strictEqual( isEmptyString( new String( '' ) ), true, 'returns true' );
+	t.strictEqual( isEmptyString( new String( '' ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive string', function test( t ) {
-	t.strictEqual( isEmptyString( '' ), false, 'returns false' );
+	t.strictEqual( isEmptyString( '' ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'if `Symbol.toStringTag` is supported, the function guards against objects
 	if ( hasToStringTag() ) {
 		mock[ Symbol.toStringTag ] = 'String';
 	}
-	t.strictEqual( isEmptyString( mock ), false, 'returns false' );
+	t.strictEqual( isEmptyString( mock ), false, 'returns expected value' );
 	t.end();
 
 	function toString() {
@@ -88,7 +88,7 @@ tape( 'the function returns `false` if not provided an empty string', function t
 		{},
 		new Date(),
 		/./,
-		new RegExp( '.' ),
+		/./,
 		function noop() {}
 	];
 
diff --git a/lib/node_modules/@stdlib/assert/is-empty-string/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-empty-string/test/test.primitive.js
index aa77afd4eb9c..22a49f137d13 100644
--- a/lib/node_modules/@stdlib/assert/is-empty-string/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-empty-string/test/test.primitive.js
@@ -35,12 +35,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an empty primitive string', function test( t ) {
-	t.strictEqual( isEmptyString( '' ), true, 'returns true' );
+	t.strictEqual( isEmptyString( '' ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a string object', function test( t ) {
-	t.strictEqual( isEmptyString( new String( '' ) ), false, 'returns false' );
+	t.strictEqual( isEmptyString( new String( '' ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-enumerable-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-enumerable-property-in/test/test.js
index dfa256514066..dddbe5b7ec7d 100644
--- a/lib/node_modules/@stdlib/assert/is-enumerable-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-enumerable-property-in/test/test.js
@@ -46,16 +46,16 @@ tape( 'the function returns `true` if an object property is enumerable', functio
 		'a': 'b'
 	};
 	bool = isEnumerablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isEnumerablePropertyIn( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isEnumerablePropertyIn( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isEnumerablePropertyIn( new Foo(), 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -66,7 +66,7 @@ tape( 'the function returns `true` if an object property is enumerable', functio
 	});
 
 	bool = isEnumerablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function returns `true` if provided an enumerable inherited property'
 	obj = new Foo();
 
 	bool = isEnumerablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -122,13 +122,13 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isEnumerablePropertyIn( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isEnumerablePropertyIn( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isEnumerablePropertyIn( [ 'a' ], 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -151,16 +151,16 @@ tape( 'the function returns `false` if provided a non-enumerable inherited prope
 	obj = new Foo();
 
 	bool = isEnumerablePropertyIn( obj, 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isEnumerablePropertyIn( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isEnumerablePropertyIn( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isEnumerablePropertyIn( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -169,10 +169,10 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isEnumerablePropertyIn( 'beep', 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isEnumerablePropertyIn( 'beep', 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-enumerable-property/test/test.js b/lib/node_modules/@stdlib/assert/is-enumerable-property/test/test.js
index 057e7932ffef..2433d2b298e7 100644
--- a/lib/node_modules/@stdlib/assert/is-enumerable-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-enumerable-property/test/test.js
@@ -56,16 +56,16 @@ tape( 'the function returns `true` if an object property is enumerable', functio
 	bool = isEnumerableProperty({
 		'a': 'b'
 	}, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isEnumerableProperty( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isEnumerableProperty( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isEnumerableProperty( new Foo(), 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,10 +79,10 @@ tape( 'the function returns `false` if an object property is not enumerable', fu
 	};
 
 	bool = isEnumerableProperty( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isEnumerableProperty( [ 'a' ], 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -91,13 +91,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isEnumerableProperty( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isEnumerableProperty( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isEnumerableProperty( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isEnumerableProperty( 'beep', '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -120,19 +120,19 @@ tape( 'addresses `propertyIsEnumerable` bug in Node v0.10 when provided a `strin
 	});
 
 	bool = isEnumerableProperty( 'beep', '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isEnumerableProperty( 'beep', 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isEnumerableProperty( 'beep', 'boop' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isEnumerableProperty( 'beep', '10' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isEnumerableProperty( 'beep', 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -145,13 +145,13 @@ tape( 'property values are coerced to strings', function test( t ) {
 		'null': false
 	};
 	bool = isEnumerableProperty( obj, null );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {
 		'[object Object]': false
 	};
 	bool = isEnumerableProperty( obj, {} );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-error/test/test.js b/lib/node_modules/@stdlib/assert/is-error/test/test.js
index ea95b87019fd..dc3fd59896b5 100644
--- a/lib/node_modules/@stdlib/assert/is-error/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-error/test/test.js
@@ -78,13 +78,13 @@ tape( 'the function returns `true` if provided an object inheriting from `Error`
 
 tape( 'the function returns `true` if provided an `Error` object from a different realm', opts, function test( t ) {
 	var error = vm.runInNewContext( 'new Error()' );
-	t.strictEqual( isError( error ), true, 'returns true' );
+	t.strictEqual( isError( error ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an object from a different realm which inherits from an `Error` object', opts, function test( t ) {
 	var error = vm.runInNewContext( 'function Err() { return this; }; Err.prototype = new Error(); new Err();' );
-	t.strictEqual( isError( error ), true, 'returns true' );
+	t.strictEqual( isError( error ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-eval-error/test/test.js b/lib/node_modules/@stdlib/assert/is-eval-error/test/test.js
index 5bdcd35957ce..27e091d6d09a 100644
--- a/lib/node_modules/@stdlib/assert/is-eval-error/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-eval-error/test/test.js
@@ -72,13 +72,13 @@ tape( 'the function returns `true` if provided an object inheriting from `EvalEr
 
 tape( 'the function returns `true` if provided an `EvalError` object from a different realm', opts, function test( t ) {
 	var error = vm.runInNewContext( 'new EvalError()' );
-	t.strictEqual( isEvalError( error ), true, 'returns true' );
+	t.strictEqual( isEvalError( error ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an object from a different realm which inherits from an `EvalError` object', opts, function test( t ) {
 	var error = vm.runInNewContext( 'function Err() { return this; }; Err.prototype = new EvalError(); new Err();' );
-	t.strictEqual( isEvalError( error ), true, 'returns true' );
+	t.strictEqual( isEvalError( error ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-even/test/test.main.js b/lib/node_modules/@stdlib/assert/is-even/test/test.main.js
index 3ceba1cefdfb..d3a2af463c78 100644
--- a/lib/node_modules/@stdlib/assert/is-even/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-even/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an even number', function test( t ) {
-	t.strictEqual( isEven( 4 ), true, 'returns true' );
-	t.strictEqual( isEven( new Number( 4 ) ), true, 'returns true' );
+	t.strictEqual( isEven( 4 ), true, 'returns expected value' );
+	t.strictEqual( isEven( new Number( 4 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-even/test/test.object.js b/lib/node_modules/@stdlib/assert/is-even/test/test.object.js
index 486868bd657c..557cbf4096f0 100644
--- a/lib/node_modules/@stdlib/assert/is-even/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-even/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an even number object', function test( t ) {
-	t.strictEqual( isEven( new Number( 4 ) ), true, 'returns true' );
+	t.strictEqual( isEven( new Number( 4 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is even', function test( t ) {
-	t.strictEqual( isEven( 4 ), false, 'returns false' );
+	t.strictEqual( isEven( 4 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-even/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-even/test/test.primitive.js
index b527a31d20d7..3cac1aab12a6 100644
--- a/lib/node_modules/@stdlib/assert/is-even/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-even/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive even number', function test( t ) {
-	t.strictEqual( isEven( -4.0 ), true, 'returns true' );
+	t.strictEqual( isEven( -4.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number is even', function test( t ) {
-	t.strictEqual( isEven( new Number( 4.0 ) ), false, 'returns false' );
+	t.strictEqual( isEven( new Number( 4.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-falsy-array/test/test.js b/lib/node_modules/@stdlib/assert/is-falsy-array/test/test.js
index 0c54186a53bb..14c4312acaa1 100644
--- a/lib/node_modules/@stdlib/assert/is-falsy-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-falsy-array/test/test.js
@@ -38,7 +38,7 @@ tape( 'the function returns `true` if provided an array-like object containing o
 
 	arr = [ false, null, void 0, '', 0, NaN ];
 	bool = isFalsyArray( arr );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided an array-like object containing o
 		'5': NaN
 	};
 	bool = isFalsyArray( arr );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-falsy/test/test.js b/lib/node_modules/@stdlib/assert/is-falsy/test/test.js
index ac5254392d56..92dd771a18c4 100644
--- a/lib/node_modules/@stdlib/assert/is-falsy/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-falsy/test/test.js
@@ -33,12 +33,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a "falsy" value', function test( t ) {
-	t.strictEqual( isFalsy( false ), true, 'returns true' );
-	t.strictEqual( isFalsy( '' ), true, 'returns true' );
-	t.strictEqual( isFalsy( 0 ), true, 'returns true' );
-	t.strictEqual( isFalsy( NaN ), true, 'returns true' );
-	t.strictEqual( isFalsy( null ), true, 'returns true' );
-	t.strictEqual( isFalsy( void 0 ), true, 'returns true' );
+	t.strictEqual( isFalsy( false ), true, 'returns expected value' );
+	t.strictEqual( isFalsy( '' ), true, 'returns expected value' );
+	t.strictEqual( isFalsy( 0 ), true, 'returns expected value' );
+	t.strictEqual( isFalsy( NaN ), true, 'returns expected value' );
+	t.strictEqual( isFalsy( null ), true, 'returns expected value' );
+	t.strictEqual( isFalsy( void 0 ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-finite-array/test/test.js b/lib/node_modules/@stdlib/assert/is-finite-array/test/test.js
index 31c78e3c65df..9aa755aa4c0c 100644
--- a/lib/node_modules/@stdlib/assert/is-finite-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-finite-array/test/test.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -39,20 +37,20 @@ tape( 'the function tests for an array-like object containing only finite number
 	var arr;
 
 	arr = [ 5.0, new Number( 5.0 ), -3.14 ];
-	t.strictEqual( isFiniteArray( arr ), true, 'returns true' );
+	t.strictEqual( isFiniteArray( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 2.0,
 		'1': 1.0
 	};
-	t.strictEqual( isFiniteArray( arr ), true, 'returns true' );
+	t.strictEqual( isFiniteArray( arr ), true, 'returns expected value' );
 
 	arr = [ 5.0, 2.3, 11.1, 1.0/0.0 ];
-	t.strictEqual( isFiniteArray( arr ), false, 'returns false' );
+	t.strictEqual( isFiniteArray( arr ), false, 'returns expected value' );
 
 	arr = [ 5.0, '3', null ];
-	t.strictEqual( isFiniteArray( arr ), false, 'returns false' );
+	t.strictEqual( isFiniteArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -61,20 +59,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ 5.0, -0.0, 0.0, 3.14 ];
-	t.strictEqual( isFiniteArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isFiniteArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 1.0,
 		'1': -3.0
 	};
-	t.strictEqual( isFiniteArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isFiniteArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ 5.0, -0.0, 0.0, 1.0/0.0 ];
-	t.strictEqual( isFiniteArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isFiniteArray.primitives( arr ), false, 'returns expected value' );
 
 	arr = [ new Number( 5.0 ), 1.0, 1.0 ];
-	t.strictEqual( isFiniteArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isFiniteArray.primitives( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -83,23 +81,23 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( 5.0 ), new Number( -0.0 ), new Number( 0.0 ) ];
-	t.strictEqual( isFiniteArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isFiniteArray.objects( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 2.0 ),
 		'1': new Number( -3.0 )
 	};
-	t.strictEqual( isFiniteArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isFiniteArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( 5.0 ), new Number( -0.0 ), new Number( 1.0/0.0 ) ];
-	t.strictEqual( isFiniteArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isFiniteArray.objects( arr ), false, 'returns expected value' );
 
 	arr = [ new Number( 5.0 ), 1.0, 1.0 ];
-	t.strictEqual( isFiniteArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isFiniteArray.objects( arr ), false, 'returns expected value' );
 
 	arr = [ -5.0, 1.0, 1.0 ];
-	t.strictEqual( isFiniteArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isFiniteArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-finite/test/test.main.js b/lib/node_modules/@stdlib/assert/is-finite/test/test.main.js
index 1269c7f8f243..12490a5b0f06 100644
--- a/lib/node_modules/@stdlib/assert/is-finite/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-finite/test/test.main.js
@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-/* eslint-disable stdlib/no-redeclare, no-new-wrappers */
+/* eslint-disable stdlib/no-redeclare */
 
 'use strict';
 
@@ -36,8 +36,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a finite value', function test( t ) {
-	t.strictEqual( isFinite( 5.0 ), true, 'returns true' );
-	t.strictEqual( isFinite( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isFinite( 5.0 ), true, 'returns expected value' );
+	t.strictEqual( isFinite( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-finite/test/test.object.js b/lib/node_modules/@stdlib/assert/is-finite/test/test.object.js
index 3d9e803804b0..90d8fcc7e6d8 100644
--- a/lib/node_modules/@stdlib/assert/is-finite/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-finite/test/test.object.js
@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-/* eslint-disable stdlib/no-redeclare, no-new-wrappers */
+/* eslint-disable stdlib/no-redeclare */
 
 'use strict';
 
@@ -36,12 +36,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a finite value', function test( t ) {
-	t.strictEqual( isFinite( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isFinite( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a finite value', function test( t ) {
-	t.strictEqual( isFinite( 3.0 ), false, 'returns false' );
+	t.strictEqual( isFinite( 3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-finite/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-finite/test/test.primitive.js
index 902a4d88e3cd..151c3191ef79 100644
--- a/lib/node_modules/@stdlib/assert/is-finite/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-finite/test/test.primitive.js
@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-/* eslint-disable stdlib/no-redeclare, no-new-wrappers */
+/* eslint-disable stdlib/no-redeclare */
 
 'use strict';
 
@@ -36,12 +36,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a finite value', function test( t ) {
-	t.strictEqual( isFinite( -3.0 ), true, 'returns true' );
+	t.strictEqual( isFinite( -3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a finite value', function test( t ) {
-	t.strictEqual( isFinite( new Number( 5.0 ) ), false, 'returns false' );
+	t.strictEqual( isFinite( new Number( 5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-float32array/test/test.js b/lib/node_modules/@stdlib/assert/is-float32array/test/test.js
index 07503f55e18f..abedb6b50e1e 100644
--- a/lib/node_modules/@stdlib/assert/is-float32array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float32array/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a Float32Array', function test( t ) {
-	t.strictEqual( isFloat32Array( new Float32Array( 10 ) ), true, 'returns true' );
+	t.strictEqual( isFloat32Array( new Float32Array( 10 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-float32matrix-like/test/test.js b/lib/node_modules/@stdlib/assert/is-float32matrix-like/test/test.js
index 20c191de3004..bc44455a0c7f 100644
--- a/lib/node_modules/@stdlib/assert/is-float32matrix-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float32matrix-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 2-dimensional ndarray containing single-precision floating-point numbers', function test( t ) {
 	var arr = ndarray( 'float32', new Float32Array( [ 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isFloat32MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat32MatrixLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isFloat32MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat32MatrixLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-float32ndarray-like/test/test.js b/lib/node_modules/@stdlib/assert/is-float32ndarray-like/test/test.js
index 2c2374a5b9de..e656dc8ad8b4 100644
--- a/lib/node_modules/@stdlib/assert/is-float32ndarray-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float32ndarray-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided an ndarray containing single-precision floating-point numbers', function test( t ) {
 	var arr = ndarray( 'float32', new Float32Array( [ 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isFloat32ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat32ndarrayLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided an ndarray-like object containing
 		'set': noop
 	};
 
-	t.strictEqual( isFloat32ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat32ndarrayLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-float32vector-like/test/test.js b/lib/node_modules/@stdlib/assert/is-float32vector-like/test/test.js
index 53d0701c1761..eaf14f4b52be 100644
--- a/lib/node_modules/@stdlib/assert/is-float32vector-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float32vector-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 1-dimensional ndarray containing single-precision floating-point numbers', function test( t ) {
 	var arr = ndarray( 'float32', new Float32Array( [ 0, 0, 0, 0 ] ), [ 4 ], [ 1 ], 0, 'row-major' );
 
-	t.strictEqual( isFloat32VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat32VectorLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 1-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isFloat32VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat32VectorLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-float64array/test/test.js b/lib/node_modules/@stdlib/assert/is-float64array/test/test.js
index 30dd66cd68b2..5b9f4ca506b8 100644
--- a/lib/node_modules/@stdlib/assert/is-float64array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float64array/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a Float64Array', function test( t ) {
-	t.strictEqual( isFloat64Array( new Float64Array( 10 ) ), true, 'returns true' );
+	t.strictEqual( isFloat64Array( new Float64Array( 10 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-float64matrix-like/test/test.js b/lib/node_modules/@stdlib/assert/is-float64matrix-like/test/test.js
index 57249128186e..16b744fc47af 100644
--- a/lib/node_modules/@stdlib/assert/is-float64matrix-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float64matrix-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 2-dimensional ndarray containing double-precision floating-point numbers', function test( t ) {
 	var arr = ndarray( 'float64', new Float64Array( [ 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isFloat64MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat64MatrixLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isFloat64MatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat64MatrixLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-float64ndarray-like/test/test.js b/lib/node_modules/@stdlib/assert/is-float64ndarray-like/test/test.js
index 47c8ad216a4a..bffab34b733f 100644
--- a/lib/node_modules/@stdlib/assert/is-float64ndarray-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float64ndarray-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided an ndarray containing double-precision floating-point numbers', function test( t ) {
 	var arr = ndarray( 'float64', new Float64Array( [ 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isFloat64ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat64ndarrayLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided an ndarray-like object containing
 		'set': noop
 	};
 
-	t.strictEqual( isFloat64ndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat64ndarrayLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-float64vector-like/test/test.js b/lib/node_modules/@stdlib/assert/is-float64vector-like/test/test.js
index 41ac98d5a8a8..f552371dbb59 100644
--- a/lib/node_modules/@stdlib/assert/is-float64vector-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-float64vector-like/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `true` if provided a 1-dimensional ndarray containing double-precision floating-point numbers', function test( t ) {
 	var arr = ndarray( 'float64', new Float64Array( [ 0, 0, 0, 0 ] ), [ 4 ], [ 1 ], 0, 'row-major' );
 
-	t.strictEqual( isFloat64VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat64VectorLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 1-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isFloat64VectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isFloat64VectorLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-function-array/test/test.js b/lib/node_modules/@stdlib/assert/is-function-array/test/test.js
index 3ef79df8b1c7..5a4814faf2c9 100644
--- a/lib/node_modules/@stdlib/assert/is-function-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-function-array/test/test.js
@@ -41,11 +41,11 @@ tape( 'the function tests if a value is an array of functions', function test( t
 
 	arr = [ beep, boop ];
 	bool = isFunctionArray( arr );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	arr = [ beep, null ];
 	bool = isFunctionArray( arr );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	arr = [];
 	bool = isFunctionArray( arr );
diff --git a/lib/node_modules/@stdlib/assert/is-function/test/test.js b/lib/node_modules/@stdlib/assert/is-function/test/test.js
index cb002e9676de..0420ce585597 100644
--- a/lib/node_modules/@stdlib/assert/is-function/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-function/test/test.js
@@ -36,7 +36,7 @@ tape( 'the function returns `true` if provided a function', function test( t ) {
 	function beep() {
 		return 'boop';
 	}
-	t.strictEqual( isFunction( beep ), true, 'returns true' );
+	t.strictEqual( isFunction( beep ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-generator-object-like/test/es2015-generator/index.js b/lib/node_modules/@stdlib/assert/is-generator-object-like/test/es2015-generator/index.js
index 743e42fedfb0..bb78fba052e9 100644
--- a/lib/node_modules/@stdlib/assert/is-generator-object-like/test/es2015-generator/index.js
+++ b/lib/node_modules/@stdlib/assert/is-generator-object-like/test/es2015-generator/index.js
@@ -46,9 +46,9 @@ function* generateID() {
 
 tape( 'the function returns `true` if provided a generator object', function test( t ) {
 	var gen = generateID();
-	t.strictEqual( isGeneratorObject( gen ), true, 'returns true' );
+	t.strictEqual( isGeneratorObject( gen ), true, 'returns expected value' );
 
 	gen = new GeneratorFunction( 'idx', 'yield idx' )();
-	t.strictEqual( isGeneratorObject( gen ), true, 'returns true' );
+	t.strictEqual( isGeneratorObject( gen ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-generator-object-like/test/test.js b/lib/node_modules/@stdlib/assert/is-generator-object-like/test/test.js
index 264fad06dba9..b5b53a935fa0 100644
--- a/lib/node_modules/@stdlib/assert/is-generator-object-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-generator-object-like/test/test.js
@@ -55,7 +55,7 @@ tape( 'the function returns `false` if not provided a generator object-like valu
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isGeneratorObject( values[i] ), false, 'returns false' );
+		t.strictEqual( isGeneratorObject( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -66,7 +66,7 @@ tape( 'the function returns `true` if provided a generator object-like value', f
 		'return': noop,
 		'throw': noop
 	};
-	t.strictEqual( isGeneratorObject( gen ), true, 'returns true' );
+	t.strictEqual( isGeneratorObject( gen ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-generator-object/test/es2015-generator/index.js b/lib/node_modules/@stdlib/assert/is-generator-object/test/es2015-generator/index.js
index 743e42fedfb0..bb78fba052e9 100644
--- a/lib/node_modules/@stdlib/assert/is-generator-object/test/es2015-generator/index.js
+++ b/lib/node_modules/@stdlib/assert/is-generator-object/test/es2015-generator/index.js
@@ -46,9 +46,9 @@ function* generateID() {
 
 tape( 'the function returns `true` if provided a generator object', function test( t ) {
 	var gen = generateID();
-	t.strictEqual( isGeneratorObject( gen ), true, 'returns true' );
+	t.strictEqual( isGeneratorObject( gen ), true, 'returns expected value' );
 
 	gen = new GeneratorFunction( 'idx', 'yield idx' )();
-	t.strictEqual( isGeneratorObject( gen ), true, 'returns true' );
+	t.strictEqual( isGeneratorObject( gen ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-generator-object/test/test.js b/lib/node_modules/@stdlib/assert/is-generator-object/test/test.js
index 41708047e531..f629d2891468 100644
--- a/lib/node_modules/@stdlib/assert/is-generator-object/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-generator-object/test/test.js
@@ -54,7 +54,7 @@ tape( 'the function returns `false` if not provided a generator object', functio
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isGeneratorObject( values[i] ), false, 'returns false' );
+		t.strictEqual( isGeneratorObject( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-hex-string/test/test.js b/lib/node_modules/@stdlib/assert/is-hex-string/test/test.js
index 673886293a2c..acd7309f8fbf 100644
--- a/lib/node_modules/@stdlib/assert/is-hex-string/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-hex-string/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a string containing all hexadecimal digits', function test( t ) {
-	t.strictEqual( isHexString( '0123456789abcdefABCDEF' ), true, 'returns true' );
+	t.strictEqual( isHexString( '0123456789abcdefABCDEF' ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-infinite/test/test.main.js b/lib/node_modules/@stdlib/assert/is-infinite/test/test.main.js
index 7fd210581300..79388928c5cf 100644
--- a/lib/node_modules/@stdlib/assert/is-infinite/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-infinite/test/test.main.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -36,10 +34,10 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having an infinite value', function test( t ) {
-	t.strictEqual( isInfinite( 1.0/0.0 ), true, 'returns true' );
-	t.strictEqual( isInfinite( new Number( 1.0/0.0 ) ), true, 'returns true' );
-	t.strictEqual( isInfinite( -1.0/0.0 ), true, 'returns true' );
-	t.strictEqual( isInfinite( new Number( -1.0/0.0 ) ), true, 'returns true' );
+	t.strictEqual( isInfinite( 1.0/0.0 ), true, 'returns expected value' );
+	t.strictEqual( isInfinite( new Number( 1.0/0.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isInfinite( -1.0/0.0 ), true, 'returns expected value' );
+	t.strictEqual( isInfinite( new Number( -1.0/0.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-infinite/test/test.object.js b/lib/node_modules/@stdlib/assert/is-infinite/test/test.object.js
index 8afb06e7456f..4284fb597ea5 100644
--- a/lib/node_modules/@stdlib/assert/is-infinite/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-infinite/test/test.object.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -36,14 +34,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having an infinite value', function test( t ) {
-	t.strictEqual( isInfinite( new Number( 1.0/0.0 ) ), true, 'returns true' );
-	t.strictEqual( isInfinite( new Number( -1.0/0.0 ) ), true, 'returns true' );
+	t.strictEqual( isInfinite( new Number( 1.0/0.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isInfinite( new Number( -1.0/0.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is an infinite value', function test( t ) {
-	t.strictEqual( isInfinite( 1.0/0.0 ), false, 'returns false' );
-	t.strictEqual( isInfinite( -1.0/0.0 ), false, 'returns false' );
+	t.strictEqual( isInfinite( 1.0/0.0 ), false, 'returns expected value' );
+	t.strictEqual( isInfinite( -1.0/0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-infinite/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-infinite/test/test.primitive.js
index e3c28ae5359f..1d5ff732e875 100644
--- a/lib/node_modules/@stdlib/assert/is-infinite/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-infinite/test/test.primitive.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -36,14 +34,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having an infinite value', function test( t ) {
-	t.strictEqual( isInfinite( -1.0/0.0 ), true, 'returns true' );
-	t.strictEqual( isInfinite( 1.0/0.0 ), true, 'returns true' );
+	t.strictEqual( isInfinite( -1.0/0.0 ), true, 'returns expected value' );
+	t.strictEqual( isInfinite( 1.0/0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has an infinite value', function test( t ) {
-	t.strictEqual( isInfinite( new Number( 1.0/0.0 ) ), false, 'returns false' );
-	t.strictEqual( isInfinite( new Number( -1.0/0.0 ) ), false, 'returns false' );
+	t.strictEqual( isInfinite( new Number( 1.0/0.0 ) ), false, 'returns expected value' );
+	t.strictEqual( isInfinite( new Number( -1.0/0.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-inherited-property/test/test.js b/lib/node_modules/@stdlib/assert/is-inherited-property/test/test.js
index d2e572a88e76..a5a3867cb8ed 100644
--- a/lib/node_modules/@stdlib/assert/is-inherited-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-inherited-property/test/test.js
@@ -61,16 +61,16 @@ tape( 'the function returns `true` if an object has an inherited property', func
 	obj = new Foo();
 
 	bool = isInheritedProperty( obj, 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isInheritedProperty( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isInheritedProperty( {}, 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isInheritedProperty( {}, 'constructor' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,14 +78,14 @@ tape( 'the function returns `true` if an object has an inherited property', func
 tape( 'the function returns `false` if an object has an own property', function test( t ) {
 	var bool;
 
-	bool = isInheritedProperty( { 'a': 'b' }, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	bool = isInheritedProperty({ 'a': 'b' }, 'a' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isInheritedProperty( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isInheritedProperty( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -93,11 +93,11 @@ tape( 'the function returns `false` if an object has an own property', function
 tape( 'the function returns `false` if an object does not have a specified property', function test( t ) {
 	var bool;
 
-	bool = isInheritedProperty( { 'a': 'b' }, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	bool = isInheritedProperty({ 'a': 'b' }, 'c' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
-	bool = isInheritedProperty( { 'a': 'b' }, null );
-	t.strictEqual( bool, false, 'returns false' );
+	bool = isInheritedProperty({ 'a': 'b' }, null );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isInheritedProperty( 'beep', 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -125,10 +125,10 @@ tape( 'non-symbol property values are coerced to strings', function test( t ) {
 	obj = new Foo();
 
 	bool = isInheritedProperty( obj, null );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isInheritedProperty( obj, {} );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function supports symbols', function test( t ) {
 		Foo.prototype[ s ] = true;
 		obj = new Foo();
 		bool = isInheritedProperty( obj, s );
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 	} else {
 		t.pass( 'environment does not support symbols' );
 	}
diff --git a/lib/node_modules/@stdlib/assert/is-int16array/test/test.js b/lib/node_modules/@stdlib/assert/is-int16array/test/test.js
index 9f874b8005d8..f857aa78ad40 100644
--- a/lib/node_modules/@stdlib/assert/is-int16array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-int16array/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an Int16Array', function test( t ) {
-	t.strictEqual( isInt16Array( new Int16Array( 10 ) ), true, 'returns true' );
+	t.strictEqual( isInt16Array( new Int16Array( 10 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-int32array/test/test.js b/lib/node_modules/@stdlib/assert/is-int32array/test/test.js
index 3ba5dfff6224..6c0c221d18bf 100644
--- a/lib/node_modules/@stdlib/assert/is-int32array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-int32array/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an Int32Array', function test( t ) {
-	t.strictEqual( isInt32Array( new Int32Array( 10 ) ), true, 'returns true' );
+	t.strictEqual( isInt32Array( new Int32Array( 10 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-int8array/test/test.js b/lib/node_modules/@stdlib/assert/is-int8array/test/test.js
index 999d56b72605..ba1c83ec42ac 100644
--- a/lib/node_modules/@stdlib/assert/is-int8array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-int8array/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an Int8Array', function test( t ) {
-	t.strictEqual( isInt8Array( new Int8Array( 10 ) ), true, 'returns true' );
+	t.strictEqual( isInt8Array( new Int8Array( 10 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-integer-array/test/test.js b/lib/node_modules/@stdlib/assert/is-integer-array/test/test.js
index d387d92dd876..4b2a7fa901a8 100644
--- a/lib/node_modules/@stdlib/assert/is-integer-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-integer-array/test/test.js
@@ -37,20 +37,20 @@ tape( 'the function tests for an array-like object containing only integer value
 	var arr;
 
 	arr = [ 5, new Number( 5 ), -3 ];
-	t.strictEqual( isIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 2,
 		'1': 1
 	};
-	t.strictEqual( isIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = [ 5.0, 2.3, 11.1 ];
-	t.strictEqual( isIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isIntegerArray( arr ), false, 'returns expected value' );
 
 	arr = [ 5.0, '3', null ];
-	t.strictEqual( isIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isIntegerArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -59,17 +59,17 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ 5, -0, 0 ];
-	t.strictEqual( isIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 1,
 		'1': -3
 	};
-	t.strictEqual( isIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( 5 ), 1, 1 ];
-	t.strictEqual( isIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isIntegerArray.primitives( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -78,20 +78,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( 5 ), new Number( -0 ), new Number( 0 ) ];
-	t.strictEqual( isIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isIntegerArray.objects( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 2 ),
 		'1': new Number( -3 )
 	};
-	t.strictEqual( isIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isIntegerArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( 5 ), 1, 1 ];
-	t.strictEqual( isIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isIntegerArray.objects( arr ), false, 'returns expected value' );
 
 	arr = [ -5, 1, 1 ];
-	t.strictEqual( isIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isIntegerArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-integer/test/test.main.js b/lib/node_modules/@stdlib/assert/is-integer/test/test.main.js
index c274106f580e..6b857806f381 100644
--- a/lib/node_modules/@stdlib/assert/is-integer/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-integer/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having an integer value', function test( t ) {
-	t.strictEqual( isInteger( 5 ), true, 'returns true' );
-	t.strictEqual( isInteger( new Number( 5 ) ), true, 'returns true' );
+	t.strictEqual( isInteger( 5 ), true, 'returns expected value' );
+	t.strictEqual( isInteger( new Number( 5 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-integer/test/test.object.js b/lib/node_modules/@stdlib/assert/is-integer/test/test.object.js
index f5281844f50c..151a92488463 100644
--- a/lib/node_modules/@stdlib/assert/is-integer/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-integer/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having an integer value', function test( t ) {
-	t.strictEqual( isInteger( new Number( 5 ) ), true, 'returns true' );
+	t.strictEqual( isInteger( new Number( 5 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is an integer value', function test( t ) {
-	t.strictEqual( isInteger( 3.0 ), false, 'returns false' );
+	t.strictEqual( isInteger( 3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-integer/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-integer/test/test.primitive.js
index 91e381a8755d..39620046a28f 100644
--- a/lib/node_modules/@stdlib/assert/is-integer/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-integer/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having an integer value', function test( t ) {
-	t.strictEqual( isInteger( -3.0 ), true, 'returns true' );
+	t.strictEqual( isInteger( -3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has an integer value', function test( t ) {
-	t.strictEqual( isInteger( new Number( 5.0 ) ), false, 'returns false' );
+	t.strictEqual( isInteger( new Number( 5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-kebabcase/test/test.js b/lib/node_modules/@stdlib/assert/is-kebabcase/test/test.js
index 9c91bd33c79a..cb32aac3d762 100644
--- a/lib/node_modules/@stdlib/assert/is-kebabcase/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-kebabcase/test/test.js
@@ -49,7 +49,7 @@ tape( 'the function returns `true` if provided a string in kebab case', function
 });
 
 tape( 'the function returns `true` if provided an empty string', function test( t ) {
-	t.strictEqual( isKebabcase( '' ), true, 'returns true' );
+	t.strictEqual( isKebabcase( '' ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-leap-year/test/test.js b/lib/node_modules/@stdlib/assert/is-leap-year/test/test.js
index e99842f0bb46..34e4fa59366f 100644
--- a/lib/node_modules/@stdlib/assert/is-leap-year/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-leap-year/test/test.js
@@ -60,7 +60,7 @@ tape( 'the function returns `false` if provided a value which is neither an inte
 
 tape( 'the function returns a `boolean`', function test( t ) {
 	var bool = isLeapYear();
-	t.strictEqual( typeof bool, 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof bool, 'boolean', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-localhost/test/test.js b/lib/node_modules/@stdlib/assert/is-localhost/test/test.js
index fcf302c36c5c..067bc78e4a83 100644
--- a/lib/node_modules/@stdlib/assert/is-localhost/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-localhost/test/test.js
@@ -50,7 +50,7 @@ tape( 'the function returns `true` if provided a localhost hostname', function t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isLocalhost( values[ i ] ), true, 'returns true' );
+		t.strictEqual( isLocalhost( values[ i ] ), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function returns `false` if not provided a localhost hostname', funct
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isLocalhost( values[ i ] ), false, 'returns false' );
+		t.strictEqual( isLocalhost( values[ i ] ), false, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-matrix-like/test/test.js b/lib/node_modules/@stdlib/assert/is-matrix-like/test/test.js
index 80f8c3435504..6219c2d8cb98 100644
--- a/lib/node_modules/@stdlib/assert/is-matrix-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-matrix-like/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided a 2-dimensional ndarray', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isMatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isMatrixLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isMatrixLike( arr ), true, 'returns true' );
+	t.strictEqual( isMatrixLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-method-in/test/test.js b/lib/node_modules/@stdlib/assert/is-method-in/test/test.js
index 43c588038ca1..0a8a95554a60 100644
--- a/lib/node_modules/@stdlib/assert/is-method-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-method-in/test/test.js
@@ -52,14 +52,14 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 tape( 'the function returns `true` if an object has a specified method name (either own or inherited)', function test( t ) {
 	var bool;
 
-	bool = isMethodIn( { 'a': noop }, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	bool = isMethodIn({ 'a': noop }, 'a' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isMethodIn( [ 1, 2, 3 ], 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isMethodIn( {}, 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -67,14 +67,14 @@ tape( 'the function returns `true` if an object has a specified method name (eit
 tape( 'the function returns `false` if an object does not have a specified method name (either own or inherited)', function test( t ) {
 	var bool;
 
-	bool = isMethodIn( { 'a': 'b' }, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	bool = isMethodIn({ 'a': 'b' }, 'a' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
-	bool = isMethodIn( { 'a': 'b' }, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	bool = isMethodIn({ 'a': 'b' }, 'c' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
-	bool = isMethodIn( { 'a': 'b' }, null );
-	t.strictEqual( bool, false, 'returns false' );
+	bool = isMethodIn({ 'a': 'b' }, null );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isMethodIn( 'beep', 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -91,11 +91,11 @@ tape( 'values are coerced to objects', function test( t ) {
 tape( 'non-symbol property values are coerced to strings', function test( t ) {
 	var bool;
 
-	bool = isMethodIn( { 'null': noop }, null );
-	t.strictEqual( bool, true, 'returns true' );
+	bool = isMethodIn({ 'null': noop }, null );
+	t.strictEqual( bool, true, 'returns expected value' );
 
-	bool = isMethodIn( { '[object Object]': noop }, {} );
-	t.strictEqual( bool, true, 'returns true' );
+	bool = isMethodIn({ '[object Object]': noop }, {} );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function supports symbols', function test( t ) {
 		s = Symbol( 'foo' );
 		obj[ s ] = noop;
 		bool = isMethodIn( obj, s );
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 	} else {
 		t.pass( 'environment does not support symbols' );
 	}
diff --git a/lib/node_modules/@stdlib/assert/is-method/test/test.js b/lib/node_modules/@stdlib/assert/is-method/test/test.js
index 48407305ba04..45c70af7d678 100644
--- a/lib/node_modules/@stdlib/assert/is-method/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-method/test/test.js
@@ -50,8 +50,8 @@ tape( 'the function returns `false` if provided `null` or `undefined` for the fi
 tape( 'the function returns `true` if an object has a specified method name', function test( t ) {
 	var bool;
 
-	bool = isMethod( { 'a': noop }, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	bool = isMethod({ 'a': noop }, 'a' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -59,11 +59,11 @@ tape( 'the function returns `true` if an object has a specified method name', fu
 tape( 'the function returns `false` if an object does not have a specified own method name', function test( t ) {
 	var bool;
 
-	bool = isMethod( { 'a': 'b' }, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	bool = isMethod({ 'a': 'b' }, 'a' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
-	bool = isMethod( { 'a': 'b' }, null );
-	t.strictEqual( bool, false, 'returns false' );
+	bool = isMethod({ 'a': 'b' }, null );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isMethod( 'beep', 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -89,11 +89,11 @@ tape( 'values are coerced to objects', function test( t ) {
 tape( 'property values are coerced to strings', function test( t ) {
 	var bool;
 
-	bool = isMethod( { 'null': noop }, null );
-	t.strictEqual( bool, true, 'returns true' );
+	bool = isMethod({ 'null': noop }, null );
+	t.strictEqual( bool, true, 'returns expected value' );
 
-	bool = isMethod( { '[object Object]': noop }, {} );
-	t.strictEqual( bool, true, 'returns true' );
+	bool = isMethod({ '[object Object]': noop }, {} );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-mobile/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-mobile/test/test.browser.js
index f977b4c05304..6a6a5873f131 100644
--- a/lib/node_modules/@stdlib/assert/is-mobile/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-mobile/test/test.browser.js
@@ -48,7 +48,7 @@ tape( 'the function returns `true` if the current environment is a mobile device
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.strictEqual( isMobile(), true, 'returns true' );
+	t.strictEqual( isMobile(), true, 'returns expected value' );
 	t.end();
 
 	function getGlobal() {
@@ -71,7 +71,7 @@ tape( 'the function returns `false` if the current environment is not a mobile d
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.strictEqual( isMobile(), false, 'returns false' );
+	t.strictEqual( isMobile(), false, 'returns expected value' );
 	t.end();
 
 	function getGlobal() {
@@ -84,6 +84,6 @@ tape( 'the function returns `false` if the current environment is not a browser'
 		'@stdlib/assert/is-browser': false
 	});
 
-	t.strictEqual( isMobile(), false, 'returns false' );
+	t.strictEqual( isMobile(), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-mobile/test/test.main.js b/lib/node_modules/@stdlib/assert/is-mobile/test/test.main.js
index 55b7b73e033f..c14cbfa5eca6 100644
--- a/lib/node_modules/@stdlib/assert/is-mobile/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-mobile/test/test.main.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `false`', function test( t ) {
-	t.strictEqual( isMobile(), false, 'returns false' );
+	t.strictEqual( isMobile(), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-multi-slice/test/test.js b/lib/node_modules/@stdlib/assert/is-multi-slice/test/test.js
index 6508b63f5b76..941d16e5f234 100644
--- a/lib/node_modules/@stdlib/assert/is-multi-slice/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-multi-slice/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a MultiSlice instance', function test( t ) {
-	t.strictEqual( isMultiSlice( new MultiSlice( new Slice( 0, 10, 1 ), null, 1 ) ), true, 'returns true' );
+	t.strictEqual( isMultiSlice( new MultiSlice( new Slice( 0, 10, 1 ), null, 1 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nan-array/test/test.js b/lib/node_modules/@stdlib/assert/is-nan-array/test/test.js
index c51b6d07c58b..941ecb72e021 100644
--- a/lib/node_modules/@stdlib/assert/is-nan-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nan-array/test/test.js
@@ -38,23 +38,23 @@ tape( 'the function tests for an array-like object containing only `NaN` values'
 	var arr;
 
 	arr = [ NaN, new Number( NaN ), NaN ];
-	t.strictEqual( isNaNArray( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray( arr ), true, 'returns expected value' );
 
 	arr = new Float64Array( [ NaN, NaN ] );
-	t.strictEqual( isNaNArray( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': NaN,
 		'1': NaN
 	};
-	t.strictEqual( isNaNArray( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray( arr ), true, 'returns expected value' );
 
 	arr = [ NaN, 3, NaN ];
-	t.strictEqual( isNaNArray( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray( arr ), false, 'returns expected value' );
 
 	arr = [ NaN, null, NaN ];
-	t.strictEqual( isNaNArray( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -63,23 +63,23 @@ tape( 'attached to the main export is a method to test for an array-like object
 	var arr;
 
 	arr = [ NaN, NaN, NaN ];
-	t.strictEqual( isNaNArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = new Float64Array( [ NaN, NaN ] );
-	t.strictEqual( isNaNArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': NaN,
 		'1': NaN
 	};
-	t.strictEqual( isNaNArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( NaN ), NaN, NaN ];
-	t.strictEqual( isNaNArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray.primitives( arr ), false, 'returns expected value' );
 
 	arr = new Float64Array( [ 2.3, NaN ] );
-	t.strictEqual( isNaNArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray.primitives( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -88,23 +88,23 @@ tape( 'attached to the main export is a method to test for an array-like object
 	var arr;
 
 	arr = [ NaN, NaN, NaN ];
-	t.strictEqual( isNaNArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray.objects( arr ), false, 'returns expected value' );
 
 	arr = [ new Number( NaN ), NaN, NaN ];
-	t.strictEqual( isNaNArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray.objects( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( NaN ),
 		'1': new Number( NaN )
 	};
-	t.strictEqual( isNaNArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( NaN ), new Number( NaN ), new Number( NaN ) ];
-	t.strictEqual( isNaNArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNaNArray.objects( arr ), true, 'returns expected value' );
 
 	arr = new Float64Array( [ NaN, NaN, NaN ] );
-	t.strictEqual( isNaNArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNaNArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nan/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nan/test/test.main.js
index 530d155cb56a..63d2ed5c3317 100644
--- a/lib/node_modules/@stdlib/assert/is-nan/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nan/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `NaN`', function test( t ) {
-	t.strictEqual( isnan( NaN ), true, 'returns true' );
-	t.strictEqual( isnan( new Number( NaN ) ), true, 'returns true' );
+	t.strictEqual( isnan( NaN ), true, 'returns expected value' );
+	t.strictEqual( isnan( new Number( NaN ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nan/test/test.object.js b/lib/node_modules/@stdlib/assert/is-nan/test/test.object.js
index f2a7ec958851..799c9d1677c0 100644
--- a/lib/node_modules/@stdlib/assert/is-nan/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-nan/test/test.object.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a value of `NaN`', function test( t ) {
-	t.strictEqual( isnan( new Number( NaN ) ), true, 'returns true' );
+	t.strictEqual( isnan( new Number( NaN ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number', function test( t ) {
-	t.strictEqual( isnan( 3.14 ), false, 'returns false' );
-	t.strictEqual( isnan( NaN ), false, 'returns false' );
+	t.strictEqual( isnan( 3.14 ), false, 'returns expected value' );
+	t.strictEqual( isnan( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -78,6 +78,6 @@ tape( 'the function returns `false` if not provided `NaN`', function test( t ) {
 
 tape( 'the function returns `false` when provided a symbol (symbols are unique)', opts, function test( t ) {
 	var s = Symbol( 'foo' );
-	t.strictEqual( isnan( s ), false, 'returns false' );
+	t.strictEqual( isnan( s ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nan/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-nan/test/test.primitive.js
index 4d82ae46541c..eae75e007e69 100644
--- a/lib/node_modules/@stdlib/assert/is-nan/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-nan/test/test.primitive.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a `NaN` primitive number', function test( t ) {
-	t.strictEqual( isnan( NaN ), true, 'returns true' );
+	t.strictEqual( isnan( NaN ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the value of the object is `NaN`', function test( t ) {
-	t.strictEqual( isnan( new Number( 5 ) ), false, 'returns false' );
-	t.strictEqual( isnan( new Number( NaN ) ), false, 'returns false' );
+	t.strictEqual( isnan( new Number( 5 ) ), false, 'returns expected value' );
+	t.strictEqual( isnan( new Number( NaN ) ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -78,6 +78,6 @@ tape( 'the function returns `false` if not provided `NaN`', function test( t ) {
 
 tape( 'the function returns `false` when provided a symbol (symbols are unique)', opts, function test( t ) {
 	var s = Symbol( 'foo' );
-	t.strictEqual( isnan( s ), false, 'returns false' );
+	t.strictEqual( isnan( s ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-native-function/test/test.js b/lib/node_modules/@stdlib/assert/is-native-function/test/test.js
index 80e781a21f9e..7a34e95478df 100644
--- a/lib/node_modules/@stdlib/assert/is-native-function/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-native-function/test/test.js
@@ -33,9 +33,9 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a native function', function test( t ) {
-	t.strictEqual( isNativeFunction( Date ), true, 'returns true' );
-	t.strictEqual( isNativeFunction( Math.sqrt ), true, 'returns true' ); // eslint-disable-line stdlib/no-builtin-math
-	t.strictEqual( isNativeFunction( RegExp ), true, 'returns true' );
+	t.strictEqual( isNativeFunction( Date ), true, 'returns expected value' );
+	t.strictEqual( isNativeFunction( Math.sqrt ), true, 'returns expected value' ); // eslint-disable-line stdlib/no-builtin-math
+	t.strictEqual( isNativeFunction( RegExp ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -43,9 +43,9 @@ tape( 'the function returns `false` if provided a non-native function', function
 	function beep() {
 		return 'boop';
 	}
-	t.strictEqual( isNativeFunction( beep ), false, 'returns false' );
-	t.strictEqual( isNativeFunction( test ), false, 'returns false' );
-	t.strictEqual( isNativeFunction( tape ), false, 'returns false' );
+	t.strictEqual( isNativeFunction( beep ), false, 'returns expected value' );
+	t.strictEqual( isNativeFunction( test ), false, 'returns expected value' );
+	t.strictEqual( isNativeFunction( tape ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-ndarray-like/test/test.js b/lib/node_modules/@stdlib/assert/is-ndarray-like/test/test.js
index b8680bfb4bea..121471ccf22c 100644
--- a/lib/node_modules/@stdlib/assert/is-ndarray-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-ndarray-like/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided an ndarray', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isndarrayLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided an ndarray-like object', function
 		'set': noop
 	};
 
-	t.strictEqual( isndarrayLike( arr ), true, 'returns true' );
+	t.strictEqual( isndarrayLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.main.js b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.main.js
index aaa2807d6cfd..11a5a6cc9e8b 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a finite negative number value', function test( t ) {
-	t.strictEqual( isNegativeFinite( -5.0 ), true, 'returns true' );
-	t.strictEqual( isNegativeFinite( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNegativeFinite( -5.0 ), true, 'returns expected value' );
+	t.strictEqual( isNegativeFinite( new Number( -5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.object.js b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.object.js
index 1043d22503ac..1add911ceaf8 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a finite negative value', function test( t ) {
-	t.strictEqual( isNegativeFinite( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNegativeFinite( new Number( -5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a finite negative value', function test( t ) {
-	t.strictEqual( isNegativeFinite( -3.0 ), false, 'returns false' );
+	t.strictEqual( isNegativeFinite( -3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.primitive.js
index 160214c11169..3cf178cec97e 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-finite/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a finite negative value', function test( t ) {
-	t.strictEqual( isNegativeFinite( -3.0 ), true, 'returns true' );
+	t.strictEqual( isNegativeFinite( -3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a finite negative value', function test( t ) {
-	t.strictEqual( isNegativeFinite( new Number( -5.0 ) ), false, 'returns false' );
+	t.strictEqual( isNegativeFinite( new Number( -5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-negative-integer-array/test/test.js b/lib/node_modules/@stdlib/assert/is-negative-integer-array/test/test.js
index 955048606746..e889b76ce724 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-integer-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-integer-array/test/test.js
@@ -38,20 +38,20 @@ tape( 'the function tests for an array-like object containing only negative inte
 	var arr;
 
 	arr = [ -5.0, new Number( -5 ), -1.0 ];
-	t.strictEqual( isNegativeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = new Int32Array( [ -2, -9, -4 ] );
-	t.strictEqual( isNegativeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -5 ),
 		'1': new Number( -2 )
 	};
-	t.strictEqual( isNegativeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = [ -5.0, '3', null ];
-	t.strictEqual( isNegativeIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeIntegerArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -60,20 +60,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ -5.0, -1.0 ];
-	t.strictEqual( isNegativeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = new Int32Array( [ -2, -9, -4 ] );
-	t.strictEqual( isNegativeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -5 ),
 		'1': new Number( -2 )
 	};
-	t.strictEqual( isNegativeIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeIntegerArray.primitives( arr ), false, 'returns expected value' );
 
 	arr = [ new Number( -5 ), -1.0, -1.0 ];
-	t.strictEqual( isNegativeIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeIntegerArray.primitives( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -82,20 +82,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( -5 ), new Number( -5 ) ];
-	t.strictEqual( isNegativeIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ -5, -3 ];
-	t.strictEqual( isNegativeIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeIntegerArray.objects( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -5 ),
 		'1': new Number( -2 )
 	};
-	t.strictEqual( isNegativeIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeIntegerArray.objects( arr ), true, 'returns expected value' );
 
 	arr = new Int32Array( [ -2, -9, -4 ] );
-	t.strictEqual( isNegativeIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeIntegerArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.main.js b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.main.js
index 5c23361ddf22..5d949af40ef5 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a negative integer value', function test( t ) {
-	t.strictEqual( isNegativeInteger( -5.0 ), true, 'returns true' );
-	t.strictEqual( isNegativeInteger( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNegativeInteger( -5.0 ), true, 'returns expected value' );
+	t.strictEqual( isNegativeInteger( new Number( -5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.object.js b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.object.js
index 7ea1d42dfdc4..f6e4bf0c7545 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a negative integer value', function test( t ) {
-	t.strictEqual( isNegativeInteger( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNegativeInteger( new Number( -5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a negative integer value', function test( t ) {
-	t.strictEqual( isNegativeInteger( -3.0 ), false, 'returns false' );
+	t.strictEqual( isNegativeInteger( -3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.primitive.js
index dba56a9b0a1b..c796dc24d856 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-integer/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a negative integer value', function test( t ) {
-	t.strictEqual( isNegativeInteger( -3.0 ), true, 'returns true' );
+	t.strictEqual( isNegativeInteger( -3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a negative integer value', function test( t ) {
-	t.strictEqual( isNegativeInteger( new Number( -5.0 ) ), false, 'returns false' );
+	t.strictEqual( isNegativeInteger( new Number( -5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-negative-number-array/test/test.js b/lib/node_modules/@stdlib/assert/is-negative-number-array/test/test.js
index 24cc5bba6374..d39f9ca00f2c 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-number-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-number-array/test/test.js
@@ -38,20 +38,20 @@ tape( 'the function tests for an array-like object containing only negative numb
 	var arr;
 
 	arr = [ -5.0, new Number( -5 ), -1.0 ];
-	t.strictEqual( isNegativeNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray( arr ), true, 'returns expected value' );
 
 	arr = [ -5.0, '-3', null ];
-	t.strictEqual( isNegativeNumberArray( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeNumberArray( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': -3.14,
 		'1': -2.0
 	};
-	t.strictEqual( isNegativeNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray( arr ), true, 'returns expected value' );
 
 	arr = new Float32Array( [ -5.0, -1.5 ] );
-	t.strictEqual( isNegativeNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray( arr ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -60,20 +60,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ -5.0, -2.0 ];
-	t.strictEqual( isNegativeNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( -5 ), -1.0, -1.0 ];
-	t.strictEqual( isNegativeNumberArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeNumberArray.primitives( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': -3.14,
 		'1': -1.0
 	};
-	t.strictEqual( isNegativeNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = new Float32Array( [ -5.0, -1.5 ] );
-	t.strictEqual( isNegativeNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,20 +82,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ new Number( -5 ), new Number( -5 ) ];
-	t.strictEqual( isNegativeNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ -5.0, -1.0 ];
-	t.strictEqual( isNegativeNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeNumberArray.objects( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -3.14 ),
 		'1': new Number( -2.0 )
 	};
-	t.strictEqual( isNegativeNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNegativeNumberArray.objects( arr ), true, 'returns expected value' );
 
 	arr = new Float32Array( [ -5.0, -1.5 ] );
-	t.strictEqual( isNegativeNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNegativeNumberArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.main.js
index c51882e494cb..b385834ab29c 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a negative number value', function test( t ) {
-	t.strictEqual( isNegativeNumber( -5.0 ), true, 'returns true' );
-	t.strictEqual( isNegativeNumber( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNegativeNumber( -5.0 ), true, 'returns expected value' );
+	t.strictEqual( isNegativeNumber( new Number( -5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.object.js
index 2d303051327e..e061a1910b11 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a negative value', function test( t ) {
-	t.strictEqual( isNegativeNumber( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNegativeNumber( new Number( -5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a negative value', function test( t ) {
-	t.strictEqual( isNegativeNumber( -3.0 ), false, 'returns false' );
+	t.strictEqual( isNegativeNumber( -3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.primitive.js
index 8886697156e1..eaadcecbecd3 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a negative value', function test( t ) {
-	t.strictEqual( isNegativeNumber( -3.0 ), true, 'returns true' );
+	t.strictEqual( isNegativeNumber( -3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a negative value', function test( t ) {
-	t.strictEqual( isNegativeNumber( new Number( -5.0 ) ), false, 'returns false' );
+	t.strictEqual( isNegativeNumber( new Number( -5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-negative-zero/test/test.main.js b/lib/node_modules/@stdlib/assert/is-negative-zero/test/test.main.js
index f3da66a48644..acf8dd168aea 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-zero/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-zero/test/test.main.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -36,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number equal to negative zero', function test( t ) {
-	t.strictEqual( isNegativeZero( -0.0 ), true, 'returns true' );
-	t.strictEqual( isNegativeZero( new Number( -0.0 ) ), true, 'returns true' );
+	t.strictEqual( isNegativeZero( -0.0 ), true, 'returns expected value' );
+	t.strictEqual( isNegativeZero( new Number( -0.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-negative-zero/test/test.object.js b/lib/node_modules/@stdlib/assert/is-negative-zero/test/test.object.js
index 6b9cc983817b..9dac3e2a3e2e 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-zero/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-zero/test/test.object.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -36,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a value equal to negative zero', function test( t ) {
-	t.strictEqual( isNegativeZero( new Number( -0.0 ) ), true, 'returns true' );
+	t.strictEqual( isNegativeZero( new Number( -0.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is equal to negative zero', function test( t ) {
-	t.strictEqual( isNegativeZero( -0.0 ), false, 'returns false' );
+	t.strictEqual( isNegativeZero( -0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-negative-zero/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-negative-zero/test/test.primitive.js
index 7818021ab72d..711cccbfc753 100644
--- a/lib/node_modules/@stdlib/assert/is-negative-zero/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-negative-zero/test/test.primitive.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -36,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number equal to negative zero', function test( t ) {
-	t.strictEqual( isNegativeZero( -0.0 ), true, 'returns true' );
+	t.strictEqual( isNegativeZero( -0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a value equal to negative zero', function test( t ) {
-	t.strictEqual( isNegativeZero( new Number( -0.0 ) ), false, 'returns false' );
+	t.strictEqual( isNegativeZero( new Number( -0.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-node-builtin/test/test.js b/lib/node_modules/@stdlib/assert/is-node-builtin/test/test.js
index 56e6c902702c..a3790010420f 100644
--- a/lib/node_modules/@stdlib/assert/is-node-builtin/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-node-builtin/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a string primitive matching a Node.js built-in module name', function test( t ) {
-	t.strictEqual( isNodeBuiltin( 'fs' ), true, 'returns true' );
+	t.strictEqual( isNodeBuiltin( 'fs' ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-node-repl/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-node-repl/test/test.browser.js
index 4d36544fd997..e1fa63ad3608 100644
--- a/lib/node_modules/@stdlib/assert/is-node-repl/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-node-repl/test/test.browser.js
@@ -33,13 +33,13 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function always returns `false`', function test( t ) {
-	t.strictEqual( isNodeREPL(), false, 'returns false' );
-	t.strictEqual( isNodeREPL(), false, 'returns false' );
-	t.strictEqual( isNodeREPL(), false, 'returns false' );
-	t.strictEqual( isNodeREPL(), false, 'returns false' );
-	t.strictEqual( isNodeREPL(), false, 'returns false' );
-	t.strictEqual( isNodeREPL(), false, 'returns false' );
-	t.strictEqual( isNodeREPL(), false, 'returns false' );
-	t.strictEqual( isNodeREPL(), false, 'returns false' );
+	t.strictEqual( isNodeREPL(), false, 'returns expected value' );
+	t.strictEqual( isNodeREPL(), false, 'returns expected value' );
+	t.strictEqual( isNodeREPL(), false, 'returns expected value' );
+	t.strictEqual( isNodeREPL(), false, 'returns expected value' );
+	t.strictEqual( isNodeREPL(), false, 'returns expected value' );
+	t.strictEqual( isNodeREPL(), false, 'returns expected value' );
+	t.strictEqual( isNodeREPL(), false, 'returns expected value' );
+	t.strictEqual( isNodeREPL(), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-node-repl/test/test.js b/lib/node_modules/@stdlib/assert/is-node-repl/test/test.js
index 963f64832d80..d46efb413c98 100644
--- a/lib/node_modules/@stdlib/assert/is-node-repl/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-node-repl/test/test.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a boolean', function test( t ) {
-	t.strictEqual( typeof isNodeREPL(), 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof isNodeREPL(), 'boolean', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-node-repl/test/test.main.js b/lib/node_modules/@stdlib/assert/is-node-repl/test/test.main.js
index 32103acda6e2..f721dfccf85a 100644
--- a/lib/node_modules/@stdlib/assert/is-node-repl/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-node-repl/test/test.main.js
@@ -38,7 +38,7 @@ tape( 'the function returns `false` if the runtime environment is not Node.js',
 		'@stdlib/assert/is-node': false
 	});
 
-	t.strictEqual( isNodeREPL(), false, 'returns false' );
+	t.strictEqual( isNodeREPL(), false, 'returns expected value' );
 	t.end();
 });
 
@@ -48,7 +48,7 @@ tape( 'the function returns `true` if a parent module is the Node.js `repl` buil
 		'./parent.js': mock
 	});
 
-	t.strictEqual( isNodeREPL(), true, 'returns true' );
+	t.strictEqual( isNodeREPL(), true, 'returns expected value' );
 	t.end();
 
 	function mock() {
@@ -77,7 +77,7 @@ tape( 'the function returns `true` if a parent module is the Node.js `repl` buil
 		'./parent.js': mock
 	});
 
-	t.strictEqual( isNodeREPL(), true, 'returns true' );
+	t.strictEqual( isNodeREPL(), true, 'returns expected value' );
 	t.end();
 
 	function mock() {
@@ -106,7 +106,7 @@ tape( 'the function returns `true` if a parent module is the Node.js `repl` buil
 		'./parent.js': mock
 	});
 
-	t.strictEqual( isNodeREPL(), true, 'returns true' );
+	t.strictEqual( isNodeREPL(), true, 'returns expected value' );
 	t.end();
 
 	function mock() {
@@ -135,7 +135,7 @@ tape( 'the function returns `true` if a parent module is the Node.js `repl` buil
 		'./parent.js': mock
 	});
 
-	t.strictEqual( isNodeREPL(), true, 'returns true' );
+	t.strictEqual( isNodeREPL(), true, 'returns expected value' );
 	t.end();
 
 	function mock() {
@@ -165,7 +165,7 @@ tape( 'the function returns `false` if the function is not either required or ca
 		'./stacktrace.js': stacktrace
 	});
 
-	t.strictEqual( isNodeREPL(), false, 'returns false' );
+	t.strictEqual( isNodeREPL(), false, 'returns expected value' );
 	t.end();
 
 	function mock() {
@@ -187,7 +187,7 @@ tape( 'the function returns `false` if the function is not either required or ca
 		'./stacktrace.js': stacktrace
 	});
 
-	t.strictEqual( isNodeREPL(), false, 'returns false' );
+	t.strictEqual( isNodeREPL(), false, 'returns expected value' );
 	t.end();
 
 	function mock() {
@@ -221,7 +221,7 @@ tape( 'the function returns `true` if the function is called from a Node.js REPL
 		'./stacktrace.js': stacktrace
 	});
 
-	t.strictEqual( isNodeREPL(), true, 'returns true' );
+	t.strictEqual( isNodeREPL(), true, 'returns expected value' );
 	t.end();
 
 	function mock() {
diff --git a/lib/node_modules/@stdlib/assert/is-node/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-node/test/test.browser.js
index 69232abe69ee..88b97dbeca8b 100644
--- a/lib/node_modules/@stdlib/assert/is-node/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-node/test/test.browser.js
@@ -33,6 +33,6 @@ tape( 'main export is a boolean', function test( t ) {
 });
 
 tape( 'the exported value is always `false`', function test( t ) {
-	t.strictEqual( IS_NODE, false, 'returns false' );
+	t.strictEqual( IS_NODE, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-node/test/test.main.js b/lib/node_modules/@stdlib/assert/is-node/test/test.main.js
index a82633280a89..8c67dc375d22 100644
--- a/lib/node_modules/@stdlib/assert/is-node/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-node/test/test.main.js
@@ -61,7 +61,7 @@ tape( 'the function returns `true` if runtime is Node.js (Node.js < v7)', functi
 		'./global_scope.js': true
 	});
 
-	t.strictEqual( isNode(), true, 'returns true' );
+	t.strictEqual( isNode(), true, 'returns expected value' );
 	t.end();
 });
 
@@ -90,7 +90,7 @@ tape( 'the function returns `true` if runtime is Node.js (Node.js >= v7)', funct
 		'./global_scope.js': true
 	});
 
-	t.strictEqual( isNode(), true, 'returns true' );
+	t.strictEqual( isNode(), true, 'returns expected value' );
 	t.end();
 });
 
@@ -123,7 +123,7 @@ tape( 'the function returns `false` if runtime is not Node.js (`global` variable
 		'@stdlib/assert/is-string': isString,
 		'./global_scope.js': true
 	});
-	t.strictEqual( isNode(), false, 'returns false' );
+	t.strictEqual( isNode(), false, 'returns expected value' );
 	t.end();
 });
 
@@ -147,7 +147,7 @@ tape( 'the function returns `false` if runtime is not Node.js (`global` variable
 		'@stdlib/assert/is-string': isString,
 		'./global_scope.js': true
 	});
-	t.strictEqual( isNode(), false, 'returns false' );
+	t.strictEqual( isNode(), false, 'returns expected value' );
 	t.end();
 });
 
@@ -175,7 +175,7 @@ tape( 'the function returns `false` if runtime is not Node.js (`global` variable
 		'@stdlib/assert/is-string': isString,
 		'./global_scope.js': false
 	});
-	t.strictEqual( isNode(), false, 'returns false' );
+	t.strictEqual( isNode(), false, 'returns expected value' );
 	t.end();
 });
 
@@ -208,7 +208,7 @@ tape( 'the function returns `false` if runtime is not Node.js (`process` variabl
 		'./global_scope.js': true,
 		'./to_string.js': toStr
 	});
-	t.strictEqual( isNode(), false, 'returns false' );
+	t.strictEqual( isNode(), false, 'returns expected value' );
 	t.end();
 });
 
@@ -243,7 +243,7 @@ tape( 'the function returns `false` if runtime is not Node.js (`process.versions
 		'@stdlib/assert/is-string': isString,
 		'./global_scope.js': true
 	});
-	t.strictEqual( isNode(), false, 'returns false' );
+	t.strictEqual( isNode(), false, 'returns expected value' );
 	t.end();
 });
 
@@ -278,7 +278,7 @@ tape( 'the function returns `false` if runtime is not Node.js (`process.versions
 		'@stdlib/assert/is-string': isString,
 		'./global_scope.js': true
 	});
-	t.strictEqual( isNode(), false, 'returns false' );
+	t.strictEqual( isNode(), false, 'returns expected value' );
 	t.end();
 });
 
@@ -316,9 +316,9 @@ tape( 'the function returns `false` if runtime is not Node.js (`process.release`
 
 	// `process.release` was added in Node v3.0.0
 	if ( proc.release ) {
-		t.strictEqual( isNode(), false, 'returns false' );
+		t.strictEqual( isNode(), false, 'returns expected value' );
 	} else {
-		t.strictEqual( isNode(), true, 'returns true' );
+		t.strictEqual( isNode(), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -357,9 +357,9 @@ tape( 'the function returns `false` if runtime is not Node.js (`process.release.
 
 	// `process.release` was added in Node v3.0.0
 	if ( proc.release ) {
-		t.strictEqual( isNode(), false, 'returns false' );
+		t.strictEqual( isNode(), false, 'returns expected value' );
 	} else {
-		t.strictEqual( isNode(), true, 'returns true' );
+		t.strictEqual( isNode(), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonconfigurable-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-nonconfigurable-property-in/test/test.js
index 9dcc78642265..2e0dd16adcd7 100644
--- a/lib/node_modules/@stdlib/assert/is-nonconfigurable-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonconfigurable-property-in/test/test.js
@@ -47,10 +47,10 @@ tape( 'the function returns `true` if provided a non-configurable property', fun
 	});
 
 	bool = isNonConfigurablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isNonConfigurablePropertyIn( [ 'a' ], 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'the function returns `true` if provided a non-configurable inherited prop
 	obj = new Foo();
 
 	bool = isNonConfigurablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -91,16 +91,16 @@ tape( 'the function returns `false` if an object property is configurable', func
 		'a': 'b'
 	};
 	bool = isNonConfigurablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonConfigurablePropertyIn( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonConfigurablePropertyIn( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonConfigurablePropertyIn( new Foo(), 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -111,7 +111,7 @@ tape( 'the function returns `false` if an object property is configurable', func
 	});
 
 	bool = isNonConfigurablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -134,16 +134,16 @@ tape( 'the function returns `false` if provided a configurable inherited propert
 	obj = new Foo();
 
 	bool = isNonConfigurablePropertyIn( obj, 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonConfigurablePropertyIn( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonConfigurablePropertyIn( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonConfigurablePropertyIn( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -176,10 +176,10 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isNonConfigurablePropertyIn( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonConfigurablePropertyIn( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -188,10 +188,10 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isNonConfigurablePropertyIn( 'beep', 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isNonConfigurablePropertyIn( 'beep', 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonconfigurable-property/test/test.js b/lib/node_modules/@stdlib/assert/is-nonconfigurable-property/test/test.js
index b7e203e2b1bf..5aebefcd5771 100644
--- a/lib/node_modules/@stdlib/assert/is-nonconfigurable-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonconfigurable-property/test/test.js
@@ -58,16 +58,16 @@ tape( 'the function returns `false` if an object property is configurable', func
 		'a': 'b'
 	};
 	bool = isNonConfigurableProperty( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonConfigurableProperty( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonConfigurableProperty( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonConfigurableProperty( new Foo(), 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isNonConfigurableProperty( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -99,10 +99,10 @@ tape( 'the function returns `true` if an object property is non-configurable', f
 	});
 
 	bool = isNonConfigurableProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isNonConfigurableProperty( [ 'a' ], 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -111,13 +111,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isNonConfigurableProperty( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonConfigurableProperty( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonConfigurableProperty( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -126,7 +126,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isNonConfigurableProperty( 'beep', 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonenumerable-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-nonenumerable-property-in/test/test.js
index 8d9b11cf0b94..747b8707657c 100644
--- a/lib/node_modules/@stdlib/assert/is-nonenumerable-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonenumerable-property-in/test/test.js
@@ -47,10 +47,10 @@ tape( 'the function returns `true` if provided a non-enumerable property', funct
 	});
 
 	bool = isNonEnumerablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isNonEnumerablePropertyIn( [ 'a' ], 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -73,16 +73,16 @@ tape( 'the function returns `true` if provided a non-enumerable inherited proper
 	obj = new Foo();
 
 	bool = isNonEnumerablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isNonEnumerablePropertyIn( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isNonEnumerablePropertyIn( {}, 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isNonEnumerablePropertyIn( {}, 'constructor' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -100,16 +100,16 @@ tape( 'the function returns `false` if an object property is enumerable', functi
 		'a': 'b'
 	};
 	bool = isNonEnumerablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonEnumerablePropertyIn( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonEnumerablePropertyIn( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonEnumerablePropertyIn( new Foo(), 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -120,7 +120,7 @@ tape( 'the function returns `false` if an object property is enumerable', functi
 	});
 
 	bool = isNonEnumerablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'the function returns `false` if provided an enumerable inherited property
 	obj = new Foo();
 
 	bool = isNonEnumerablePropertyIn( obj, 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -176,10 +176,10 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isNonEnumerablePropertyIn( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonEnumerablePropertyIn( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -188,10 +188,10 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isNonEnumerablePropertyIn( 'beep', 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isNonEnumerablePropertyIn( 'beep', 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonenumerable-property/test/test.js b/lib/node_modules/@stdlib/assert/is-nonenumerable-property/test/test.js
index 1ae4792f773b..61847843a174 100644
--- a/lib/node_modules/@stdlib/assert/is-nonenumerable-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonenumerable-property/test/test.js
@@ -58,16 +58,16 @@ tape( 'the function returns `false` if an object property is enumerable', functi
 		'a': 'b'
 	};
 	bool = isNonEnumerableProperty( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonEnumerableProperty( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonEnumerableProperty( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonEnumerableProperty( new Foo(), 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isNonEnumerableProperty( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -99,10 +99,10 @@ tape( 'the function returns `true` if an object property is non-enumerable', fun
 	});
 
 	bool = isNonEnumerableProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isNonEnumerableProperty( [ 'a' ], 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -111,13 +111,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isNonEnumerableProperty( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonEnumerableProperty( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isNonEnumerableProperty( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -126,7 +126,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isNonEnumerableProperty( 'beep', 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-integer-array/test/test.js b/lib/node_modules/@stdlib/assert/is-nonnegative-integer-array/test/test.js
index d9298452b0ef..27e1c8e370dc 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-integer-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-integer-array/test/test.js
@@ -40,20 +40,20 @@ tape( 'the function tests for an array-like object containing only nonnegative i
 	var arr;
 
 	arr = [ 5.0, new Number( 5 ), 0 ];
-	t.strictEqual( isNonNegativeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = [ 5.0, '3', null ];
-	t.strictEqual( isNonNegativeIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeIntegerArray( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 5,
 		'1': 0
 	};
-	t.strictEqual( isNonNegativeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = new Int32Array( [ 5, 0 ] );
-	t.strictEqual( isNonNegativeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray( arr ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -62,20 +62,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ 5.0, 0.0 ];
-	t.strictEqual( isNonNegativeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( 5 ), 1.0, 1.0 ];
-	t.strictEqual( isNonNegativeIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeIntegerArray.primitives( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 5,
 		'1': 0
 	};
-	t.strictEqual( isNonNegativeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = new Int16Array( [ 5, 0 ] );
-	t.strictEqual( isNonNegativeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,20 +84,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( 5 ), new Number( 5 ) ];
-	t.strictEqual( isNonNegativeIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ 5.0, 0.0 ];
-	t.strictEqual( isNonNegativeIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeIntegerArray.objects( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 5 ),
 		'1': new Number( 0 )
 	};
-	t.strictEqual( isNonNegativeIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeIntegerArray.objects( arr ), true, 'returns expected value' );
 
 	arr = new Uint32Array( [ 5, 0 ] );
-	t.strictEqual( isNonNegativeIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeIntegerArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.main.js
index 184e1d376445..0a56a54f7a6c 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a nonnegative integer value', function test( t ) {
-	t.strictEqual( isNonNegativeInteger( 5.0 ), true, 'returns true' );
-	t.strictEqual( isNonNegativeInteger( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNonNegativeInteger( 5.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeInteger( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.object.js b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.object.js
index 7765efad5af7..ade505a3d14b 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a nonnegative integer value', function test( t ) {
-	t.strictEqual( isNonNegativeInteger( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNonNegativeInteger( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a nonnegative integer value', function test( t ) {
-	t.strictEqual( isNonNegativeInteger( 3.0 ), false, 'returns false' );
+	t.strictEqual( isNonNegativeInteger( 3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.primitive.js
index b0387f876b37..38da19e2aa21 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-integer/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a nonnegative integer value', function test( t ) {
-	t.strictEqual( isNonNegativeInteger( 3.0 ), true, 'returns true' );
+	t.strictEqual( isNonNegativeInteger( 3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a nonnegative integer value', function test( t ) {
-	t.strictEqual( isNonNegativeInteger( new Number( 5.0 ) ), false, 'returns false' );
+	t.strictEqual( isNonNegativeInteger( new Number( 5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-number-array/test/test.js b/lib/node_modules/@stdlib/assert/is-nonnegative-number-array/test/test.js
index cf59d14ab274..f1162520da51 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-number-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-number-array/test/test.js
@@ -38,20 +38,20 @@ tape( 'the function tests for an array-like object containing only nonnegative n
 	var arr;
 
 	arr = [ 5.0, new Number( 5 ), 0 ];
-	t.strictEqual( isNonNegativeNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray( arr ), true, 'returns expected value' );
 
 	arr = [ 5.0, '3', null ];
-	t.strictEqual( isNonNegativeNumberArray( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeNumberArray( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 3.14,
 		'1': 0.0
 	};
-	t.strictEqual( isNonNegativeNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray( arr ), true, 'returns expected value' );
 
 	arr = new Float32Array( [ 5.0, 1.5 ] );
-	t.strictEqual( isNonNegativeNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray( arr ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -60,20 +60,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ 5.0, 0.0 ];
-	t.strictEqual( isNonNegativeNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( 5 ), 1.0, 1.0 ];
-	t.strictEqual( isNonNegativeNumberArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeNumberArray.primitives( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 3.14,
 		'1': 0.0
 	};
-	t.strictEqual( isNonNegativeNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = new Float32Array( [ 5.0, 1.5 ] );
-	t.strictEqual( isNonNegativeNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,20 +82,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ new Number( 5 ), new Number( 5 ) ];
-	t.strictEqual( isNonNegativeNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ 5.0, 0.0 ];
-	t.strictEqual( isNonNegativeNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeNumberArray.objects( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 3.14 ),
 		'1': new Number( 0.0 )
 	};
-	t.strictEqual( isNonNegativeNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumberArray.objects( arr ), true, 'returns expected value' );
 
 	arr = new Float32Array( [ 5.0, 1.5 ] );
-	t.strictEqual( isNonNegativeNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonNegativeNumberArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.main.js
index 66c57c383e53..a2b81c526002 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a nonnegative number value', function test( t ) {
-	t.strictEqual( isNonNegativeNumber( 5.0 ), true, 'returns true' );
-	t.strictEqual( isNonNegativeNumber( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumber( 5.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonNegativeNumber( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.object.js
index c0e07c1c9667..f29cc8fd3348 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a nonnegative number value', function test( t ) {
-	t.strictEqual( isNonNegativeNumber( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumber( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a nonnegative number value', function test( t ) {
-	t.strictEqual( isNonNegativeNumber( 3.0 ), false, 'returns false' );
+	t.strictEqual( isNonNegativeNumber( 3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.primitive.js
index 039239b94a77..f4e32ccda6ff 100644
--- a/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-nonnegative-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a nonnegative number value', function test( t ) {
-	t.strictEqual( isNonNegativeNumber( 3.0 ), true, 'returns true' );
+	t.strictEqual( isNonNegativeNumber( 3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a nonnegative number value', function test( t ) {
-	t.strictEqual( isNonNegativeNumber( new Number( 5.0 ) ), false, 'returns false' );
+	t.strictEqual( isNonNegativeNumber( new Number( 5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.main.js
index 0d7cdb588d02..fbb2323512b4 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.main.js
@@ -35,8 +35,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a nonpositive finite number value', function test( t ) {
-	t.strictEqual( isNonPositiveFinite( -5.0 ), true, 'returns true' );
-	t.strictEqual( isNonPositiveFinite( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNonPositiveFinite( -5.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonPositiveFinite( new Number( -5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.object.js b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.object.js
index de946ea133a7..41880a4e65d0 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a nonpositive finite number value', function test( t ) {
-	t.strictEqual( isNonPositiveFinite( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNonPositiveFinite( new Number( -5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a nonpositive finite number value', function test( t ) {
-	t.strictEqual( isNonPositiveFinite( -3.0 ), false, 'returns false' );
+	t.strictEqual( isNonPositiveFinite( -3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.primitive.js
index 3c2dc8dd2a59..97667db51944 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a nonpositive finite number value', function test( t ) {
-	t.strictEqual( isNonPositiveFinite( -3.0 ), true, 'returns true' );
+	t.strictEqual( isNonPositiveFinite( -3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a nonpositive finite number value', function test( t ) {
-	t.strictEqual( isNonPositiveFinite( new Number( -5.0 ) ), false, 'returns false' );
+	t.strictEqual( isNonPositiveFinite( new Number( -5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-integer-array/test/test.js b/lib/node_modules/@stdlib/assert/is-nonpositive-integer-array/test/test.js
index f86ea934d6d4..c3caa97da8a7 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-integer-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-integer-array/test/test.js
@@ -38,20 +38,20 @@ tape( 'the function tests for an array-like object containing only nonpositive i
 	var arr;
 
 	arr = [ -5.0, new Number( -5 ), -1.0 ];
-	t.strictEqual( isNonPositiveIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = new Int32Array( [ -2, -9, -4, 0 ] );
-	t.strictEqual( isNonPositiveIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -5 ),
 		'1': new Number( -2 )
 	};
-	t.strictEqual( isNonPositiveIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = [ -5.0, '3', null ];
-	t.strictEqual( isNonPositiveIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveIntegerArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -60,20 +60,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ -5.0, -1.0, 0 ];
-	t.strictEqual( isNonPositiveIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = new Int32Array( [ -2, -9, -4 ] );
-	t.strictEqual( isNonPositiveIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -5 ),
 		'1': new Number( -2 )
 	};
-	t.strictEqual( isNonPositiveIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveIntegerArray.primitives( arr ), false, 'returns expected value' );
 
 	arr = [ new Number( -5 ), -1.0, -1.0 ];
-	t.strictEqual( isNonPositiveIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveIntegerArray.primitives( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -82,20 +82,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( -5 ), new Number( -5 ) ];
-	t.strictEqual( isNonPositiveIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ -5, -3, 0 ];
-	t.strictEqual( isNonPositiveIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveIntegerArray.objects( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -5 ),
 		'1': new Number( -2 )
 	};
-	t.strictEqual( isNonPositiveIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveIntegerArray.objects( arr ), true, 'returns expected value' );
 
 	arr = new Int32Array( [ -2, -9, -4 ] );
-	t.strictEqual( isNonPositiveIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveIntegerArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.main.js
index 6a21a11d3bb5..04b3401111a2 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a nonpositive integer value', function test( t ) {
-	t.strictEqual( isNonPositiveInteger( -5.0 ), true, 'returns true' );
-	t.strictEqual( isNonPositiveInteger( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNonPositiveInteger( -5.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonPositiveInteger( new Number( -5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.object.js b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.object.js
index cc0142f5e3dd..6ced85c0a756 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a nonpositive integer value', function test( t ) {
-	t.strictEqual( isNonPositiveInteger( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNonPositiveInteger( new Number( -5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a nonpositive integer value', function test( t ) {
-	t.strictEqual( isNonPositiveInteger( -3.0 ), false, 'returns false' );
+	t.strictEqual( isNonPositiveInteger( -3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.primitive.js
index 6a794c404596..bf1fc3c0af34 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-integer/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a nonpositive integer value', function test( t ) {
-	t.strictEqual( isNonPositiveInteger( -3.0 ), true, 'returns true' );
+	t.strictEqual( isNonPositiveInteger( -3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a nonpositive integer value', function test( t ) {
-	t.strictEqual( isNonPositiveInteger( new Number( -5.0 ) ), false, 'returns false' );
+	t.strictEqual( isNonPositiveInteger( new Number( -5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-number-array/test/test.js b/lib/node_modules/@stdlib/assert/is-nonpositive-number-array/test/test.js
index 660410a441cd..510ee2a2b088 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-number-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-number-array/test/test.js
@@ -38,20 +38,20 @@ tape( 'the function tests for an array-like object containing only nonpositive n
 	var arr;
 
 	arr = [ -5.0, new Number( -5 ), 0 ];
-	t.strictEqual( isNonPositiveNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray( arr ), true, 'returns expected value' );
 
 	arr = [ -5.0, '-3', null ];
-	t.strictEqual( isNonPositiveNumberArray( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveNumberArray( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': -3.14,
 		'1': 0.0
 	};
-	t.strictEqual( isNonPositiveNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray( arr ), true, 'returns expected value' );
 
 	arr = new Float32Array( [-5.0, -1.5] );
-	t.strictEqual( isNonPositiveNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray( arr ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -60,20 +60,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ -5.0, 0.0 ];
-	t.strictEqual( isNonPositiveNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( -5 ), -1.0, -1.0 ];
-	t.strictEqual( isNonPositiveNumberArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveNumberArray.primitives( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': -3.14,
 		'1': 0.0
 	};
-	t.strictEqual( isNonPositiveNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = new Float32Array( [-5.0, -1.5] );
-	t.strictEqual( isNonPositiveNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,20 +82,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ new Number( -5 ), new Number( -5 ) ];
-	t.strictEqual( isNonPositiveNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ -5.0, 0.0 ];
-	t.strictEqual( isNonPositiveNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveNumberArray.objects( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( -3.14 ),
 		'1': new Number( 0.0 )
 	};
-	t.strictEqual( isNonPositiveNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumberArray.objects( arr ), true, 'returns expected value' );
 
 	arr = new Float32Array( [-5.0, -1.5] );
-	t.strictEqual( isNonPositiveNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNonPositiveNumberArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.main.js
index 5d035c6846d4..5c9cd1af13e3 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a nonpositive number value', function test( t ) {
-	t.strictEqual( isNonPositiveNumber( -5.0 ), true, 'returns true' );
-	t.strictEqual( isNonPositiveNumber( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumber( -5.0 ), true, 'returns expected value' );
+	t.strictEqual( isNonPositiveNumber( new Number( -5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.object.js
index e3d543d4464f..d438e377a3a4 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a nonpositive number value', function test( t ) {
-	t.strictEqual( isNonPositiveNumber( new Number( -5.0 ) ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumber( new Number( -5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a nonpositive number value', function test( t ) {
-	t.strictEqual( isNonPositiveNumber( -3.0 ), false, 'returns false' );
+	t.strictEqual( isNonPositiveNumber( -3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.primitive.js
index 520bae6d7c9e..488aa58b9348 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a nonpositive number value', function test( t ) {
-	t.strictEqual( isNonPositiveNumber( -3.0 ), true, 'returns true' );
+	t.strictEqual( isNonPositiveNumber( -3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a nonpositive number value', function test( t ) {
-	t.strictEqual( isNonPositiveNumber( new Number( -5.0 ) ), false, 'returns false' );
+	t.strictEqual( isNonPositiveNumber( new Number( -5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonsymmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-nonsymmetric-matrix/test/test.js
index 18c9eb1fe7e5..d5c2253dc822 100644
--- a/lib/node_modules/@stdlib/assert/is-nonsymmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-nonsymmetric-matrix/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided a non-symmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 3, 4 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isNonSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isNonSymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isNonSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isNonSymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
@@ -67,13 +67,13 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 
 tape( 'the function returns `true` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isNonSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isNonSymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a non-symmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 2, 3 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isNonSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isNonSymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -92,7 +92,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isNonSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isNonSymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.strictEqual( isNonSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isNonSymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
diff --git a/lib/node_modules/@stdlib/assert/is-null-array/test/test.js b/lib/node_modules/@stdlib/assert/is-null-array/test/test.js
index a422aa8a40be..6c2f86094ce1 100644
--- a/lib/node_modules/@stdlib/assert/is-null-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-null-array/test/test.js
@@ -36,20 +36,20 @@ tape( 'the function tests for an array-like object having only `null` values', f
 	var arr;
 
 	arr = [ null, null ];
-	t.strictEqual( isNullArray( arr ), true, 'returns true' );
+	t.strictEqual( isNullArray( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': null,
 		'1': null
 	};
-	t.strictEqual( isNullArray( arr ), true, 'returns true' );
+	t.strictEqual( isNullArray( arr ), true, 'returns expected value' );
 
 	arr = [ null, 3, null ];
-	t.strictEqual( isNullArray( arr ), false, 'returns false' );
+	t.strictEqual( isNullArray( arr ), false, 'returns expected value' );
 
 	arr = [ null, void 0, false, null ];
-	t.strictEqual( isNullArray( arr ), false, 'returns false' );
+	t.strictEqual( isNullArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-null/test/test.js b/lib/node_modules/@stdlib/assert/is-null/test/test.js
index 24b711cd03ab..807d782d863e 100644
--- a/lib/node_modules/@stdlib/assert/is-null/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-null/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided `null`', function test( t ) {
-	t.strictEqual( isNull( null ), true, 'returns true' );
+	t.strictEqual( isNull( null ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-number-array/test/test.js b/lib/node_modules/@stdlib/assert/is-number-array/test/test.js
index adf2a32aed8d..c0c759f99c05 100644
--- a/lib/node_modules/@stdlib/assert/is-number-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-number-array/test/test.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -39,17 +37,17 @@ tape( 'the function tests for an array-like object containing only numbers', fun
 	var arr;
 
 	arr = [ 1, new Number( 2 ), 3, new Number( 4 ) ];
-	t.strictEqual( isNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNumberArray( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 1,
 		'1': 2
 	};
-	t.strictEqual( isNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isNumberArray( arr ), true, 'returns expected value' );
 
 	arr = [ 1, '2', 3 ];
-	t.strictEqual( isNumberArray( arr ), false, 'returns false' );
+	t.strictEqual( isNumberArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -58,17 +56,17 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ 1, 2, 3, 4 ];
-	t.strictEqual( isNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 1,
 		'1': 2
 	};
-	t.strictEqual( isNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( 1 ), 2, 3 ];
-	t.strictEqual( isNumberArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isNumberArray.primitives( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -77,17 +75,17 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( 1 ), new Number( 2 ), new Number( 3 ) ];
-	t.strictEqual( isNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNumberArray.objects( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 1 ),
 		'1': new Number( 2 )
 	};
-	t.strictEqual( isNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isNumberArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( 1 ), 2, 3 ];
-	t.strictEqual( isNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isNumberArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-number/test/test.main.js
index 830e78cc1c1e..ac5cb8b30790 100644
--- a/lib/node_modules/@stdlib/assert/is-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-number/test/test.main.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -36,10 +34,10 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number', function test( t ) {
-	t.strictEqual( isNumber( 5 ), true, 'returns true' );
-	t.strictEqual( isNumber( new Number( 5 ) ), true, 'returns true' );
-	t.strictEqual( isNumber( NaN ), true, 'returns true' );
-	t.strictEqual( isNumber( new Number( NaN ) ), true, 'returns true' );
+	t.strictEqual( isNumber( 5 ), true, 'returns expected value' );
+	t.strictEqual( isNumber( new Number( 5 ) ), true, 'returns expected value' );
+	t.strictEqual( isNumber( NaN ), true, 'returns expected value' );
+	t.strictEqual( isNumber( new Number( NaN ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-number/test/test.object.js
index 45347c9520e5..5b4df1ba6155 100644
--- a/lib/node_modules/@stdlib/assert/is-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-number/test/test.object.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -46,14 +44,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object', function test( t ) {
-	t.strictEqual( isNumber( new Number( 5 ) ), true, 'returns true' );
-	t.strictEqual( isNumber( new Number( NaN ) ), true, 'returns true' );
+	t.strictEqual( isNumber( new Number( 5 ) ), true, 'returns expected value' );
+	t.strictEqual( isNumber( new Number( NaN ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number', function test( t ) {
-	t.strictEqual( isNumber( 3.14 ), false, 'returns false' );
-	t.strictEqual( isNumber( NaN ), false, 'returns false' );
+	t.strictEqual( isNumber( 3.14 ), false, 'returns expected value' );
+	t.strictEqual( isNumber( NaN ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -72,7 +70,7 @@ tape( 'if `Symbol.toStringTag` is supported, the function guards against objects
 	if ( hasToStringTag() ) {
 		mock[ Symbol.toStringTag ] = 'Number';
 	}
-	t.strictEqual( isNumber( mock ), false, 'returns false' );
+	t.strictEqual( isNumber( mock ), false, 'returns expected value' );
 	t.end();
 
 	function detect() {
@@ -91,8 +89,8 @@ tape( 'if `Symbol.toStringTag` is not supported, the function attempts to determ
 		'@stdlib/assert/has-tostringtag-support': detect
 	});
 
-	t.strictEqual( isNumber( new Number( 5 ) ), true, 'returns true' );
-	t.strictEqual( isNumber( {} ), false, 'returns false' );
+	t.strictEqual( isNumber( new Number( 5 ) ), true, 'returns expected value' );
+	t.strictEqual( isNumber( {} ), false, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/assert/is-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-number/test/test.primitive.js
index 2c48a91224af..dfc3f5211e2a 100644
--- a/lib/node_modules/@stdlib/assert/is-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-number/test/test.primitive.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -36,14 +34,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number', function test( t ) {
-	t.strictEqual( isNumber( 3.14 ), true, 'returns true' );
-	t.strictEqual( isNumber( NaN ), true, 'returns true' );
+	t.strictEqual( isNumber( 3.14 ), true, 'returns expected value' );
+	t.strictEqual( isNumber( NaN ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object', function test( t ) {
-	t.strictEqual( isNumber( new Number( 5 ) ), false, 'returns false' );
-	t.strictEqual( isNumber( new Number( NaN ) ), false, 'returns false' );
+	t.strictEqual( isNumber( new Number( 5 ) ), false, 'returns expected value' );
+	t.strictEqual( isNumber( new Number( NaN ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-number/test/test.try2serialize.js b/lib/node_modules/@stdlib/assert/is-number/test/test.try2serialize.js
index e665066517be..b276d3b85c42 100644
--- a/lib/node_modules/@stdlib/assert/is-number/test/test.try2serialize.js
+++ b/lib/node_modules/@stdlib/assert/is-number/test/test.try2serialize.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -36,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if able to serialize', function test( t ) {
-	t.strictEqual( serialize( 5 ), true, 'returns true' );
-	t.strictEqual( serialize( new Number( 5 ) ), true, 'returns true' );
+	t.strictEqual( serialize( 5 ), true, 'returns expected value' );
+	t.strictEqual( serialize( new Number( 5 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if unable to serialize', function test( t ) {
-	t.strictEqual( serialize( {} ), false, 'returns false' );
+	t.strictEqual( serialize( {} ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-object-array/test/test.js b/lib/node_modules/@stdlib/assert/is-object-array/test/test.js
index 1c13e0a5ea07..912d613ca3bc 100644
--- a/lib/node_modules/@stdlib/assert/is-object-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-object-array/test/test.js
@@ -40,17 +40,17 @@ tape( 'the function tests for an array-like object containing only objects', fun
 		'type': 'object'
 	};
 	arr = [ obj, /.*/, {} ];
-	t.strictEqual( isObjectArray( arr ), true, 'returns true' );
+	t.strictEqual( isObjectArray( arr ), true, 'returns expected value' );
 
 	arr = [ 5.0, {}, new Date() ];
-	t.strictEqual( isObjectArray( arr ), false, 'returns false' );
+	t.strictEqual( isObjectArray( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': {},
 		'1': new Date()
 	};
-	t.strictEqual( isObjectArray( arr ), true, 'returns true' );
+	t.strictEqual( isObjectArray( arr ), true, 'returns expected value' );
 
 	arr = [];
 	t.strictEqual( isObjectArray( arr ), false, 'returns false when provided an empty array' );
diff --git a/lib/node_modules/@stdlib/assert/is-object-like/test/test.array.js b/lib/node_modules/@stdlib/assert/is-object-like/test/test.array.js
index d78fc4d06e43..50df66071ec2 100644
--- a/lib/node_modules/@stdlib/assert/is-object-like/test/test.array.js
+++ b/lib/node_modules/@stdlib/assert/is-object-like/test/test.array.js
@@ -41,10 +41,10 @@ tape( 'the function provides a method to test for an array of object-like elemen
 	};
 
 	arr = [ obj, [], {} ];
-	t.strictEqual( isObjectLike.isObjectLikeArray( arr ), true, 'returns true' );
+	t.strictEqual( isObjectLike.isObjectLikeArray( arr ), true, 'returns expected value' );
 
 	arr = [ 2, {}, [] ];
-	t.strictEqual( isObjectLike.isObjectLikeArray( arr ), false, 'returns false' );
+	t.strictEqual( isObjectLike.isObjectLikeArray( arr ), false, 'returns expected value' );
 
 	arr = [];
 	t.strictEqual( isObjectLike.isObjectLikeArray( arr ), false, 'returns false when provided an empty array' );
diff --git a/lib/node_modules/@stdlib/assert/is-object-like/test/test.js b/lib/node_modules/@stdlib/assert/is-object-like/test/test.js
index 2799dcbb6461..160af75b3458 100644
--- a/lib/node_modules/@stdlib/assert/is-object-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-object-like/test/test.js
@@ -154,7 +154,7 @@ opts = {
 };
 tape( 'the function supports Map objects', opts, function test( t ) {
 	var bool = isObjectLike( new Map() );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -163,7 +163,7 @@ opts = {
 };
 tape( 'the function supports WeakMap objects', opts, function test( t ) {
 	var bool = isObjectLike( new WeakMap() );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -172,7 +172,7 @@ opts = {
 };
 tape( 'the function supports Set objects', opts, function test( t ) {
 	var bool = isObjectLike( new Set() );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -181,7 +181,7 @@ opts = {
 };
 tape( 'the function supports WeakSet objects', opts, function test( t ) {
 	var bool = isObjectLike( new WeakSet() );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -190,7 +190,7 @@ opts = {
 };
 tape( 'the function supports Symbol objects', opts, function test( t ) {
 	var bool = isObjectLike( Symbol( 'beep' ) );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -198,7 +198,7 @@ tape( 'the function supports custom objects', function test( t ) {
 	var bool;
 	function Person() {}
 	bool = isObjectLike( new Person() );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-object/test/test.js b/lib/node_modules/@stdlib/assert/is-object/test/test.js
index 99ea1cdaa606..94cd2f7f1e87 100644
--- a/lib/node_modules/@stdlib/assert/is-object/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-object/test/test.js
@@ -33,8 +33,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an object', function test( t ) {
-	t.strictEqual( isObject( {} ), true, 'returns true' );
-	t.strictEqual( isObject( Object.create( null ) ), true, 'returns true' );
+	t.strictEqual( isObject( {} ), true, 'returns expected value' );
+	t.strictEqual( isObject( Object.create( null ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-odd/test/test.main.js b/lib/node_modules/@stdlib/assert/is-odd/test/test.main.js
index 7f9a91204169..fde64608a103 100644
--- a/lib/node_modules/@stdlib/assert/is-odd/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-odd/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an odd number', function test( t ) {
-	t.strictEqual( isOdd( 5.0 ), true, 'returns true' );
-	t.strictEqual( isOdd( new Number( 5 ) ), true, 'returns true' );
+	t.strictEqual( isOdd( 5.0 ), true, 'returns expected value' );
+	t.strictEqual( isOdd( new Number( 5 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-odd/test/test.object.js b/lib/node_modules/@stdlib/assert/is-odd/test/test.object.js
index 8250e540b712..07f9d137f043 100644
--- a/lib/node_modules/@stdlib/assert/is-odd/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-odd/test/test.object.js
@@ -34,14 +34,14 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided an odd number object', function test( t ) {
-	t.strictEqual( isOdd( new Number( 5 ) ), true, 'returns true' );
-	t.strictEqual( isOdd( new Number( -3 ) ), true, 'returns true' );
+	t.strictEqual( isOdd( new Number( 5 ) ), true, 'returns expected value' );
+	t.strictEqual( isOdd( new Number( -3 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is odd', function test( t ) {
-	t.strictEqual( isOdd( 5.0 ), false, 'returns false' );
-	t.strictEqual( isOdd( -1.0 ), false, 'returns false' );
+	t.strictEqual( isOdd( 5.0 ), false, 'returns expected value' );
+	t.strictEqual( isOdd( -1.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-odd/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-odd/test/test.primitive.js
index 01f0e1099183..cbbf807b7b2a 100644
--- a/lib/node_modules/@stdlib/assert/is-odd/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-odd/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive odd number', function test( t ) {
-	t.strictEqual( isOdd( -5.0 ), true, 'returns true' );
+	t.strictEqual( isOdd( -5.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number is odd', function test( t ) {
-	t.strictEqual( isOdd( new Number( 5.0 ) ), false, 'returns false' );
+	t.strictEqual( isOdd( new Number( 5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-pascalcase/test/test.js b/lib/node_modules/@stdlib/assert/is-pascalcase/test/test.js
index bdcaeedabd04..79ada9aec28e 100644
--- a/lib/node_modules/@stdlib/assert/is-pascalcase/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-pascalcase/test/test.js
@@ -43,13 +43,13 @@ tape( 'the function returns `true` if provided a string in Pascal case', functio
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isPascalcase( values[i] ), true, 'returns true' );
+		t.strictEqual( isPascalcase( values[i] ), true, 'returns expected value' );
 	}
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an empty string', function test( t ) {
-	t.strictEqual( isPascalcase( '' ), true, 'returns true' );
+	t.strictEqual( isPascalcase( '' ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-persymmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-persymmetric-matrix/test/test.js
index c7308b982541..b7777c8492c5 100644
--- a/lib/node_modules/@stdlib/assert/is-persymmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-persymmetric-matrix/test/test.js
@@ -48,7 +48,7 @@ tape( 'the function returns `true` if provided a persymmetric matrix', function
 	];
 	arr = ndarray( 'generic', buffer, [ 4, 4 ], [ 4, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isPersymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isPersymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isPersymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isPersymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
@@ -77,13 +77,13 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 
 tape( 'the function returns `false` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isPersymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a persymmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 2, 3 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isPersymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -102,7 +102,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.strictEqual( isPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isPersymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -121,7 +121,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.strictEqual( isPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isPersymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
diff --git a/lib/node_modules/@stdlib/assert/is-plain-object-array/test/test.js b/lib/node_modules/@stdlib/assert/is-plain-object-array/test/test.js
index 5fa15bd2fe5e..fb429b3c341a 100644
--- a/lib/node_modules/@stdlib/assert/is-plain-object-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-plain-object-array/test/test.js
@@ -41,20 +41,20 @@ tape( 'the function tests for an array-like object containing only plain objects
 	};
 
 	arr = [ obj, {}, {} ];
-	t.strictEqual( isPlainObjectArray( arr ), true, 'returns true' );
+	t.strictEqual( isPlainObjectArray( arr ), true, 'returns expected value' );
 
 	arr = [ obj, /.*/, {} ];
-	t.strictEqual( isPlainObjectArray( arr ), false, 'returns false' );
+	t.strictEqual( isPlainObjectArray( arr ), false, 'returns expected value' );
 
 	arr = [ 5.0, {}, new Date() ];
-	t.strictEqual( isPlainObjectArray( arr ), false, 'returns false' );
+	t.strictEqual( isPlainObjectArray( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': {},
 		'1': {}
 	};
-	t.strictEqual( isPlainObjectArray( arr ), true, 'returns true' );
+	t.strictEqual( isPlainObjectArray( arr ), true, 'returns expected value' );
 
 	arr = [];
 	t.strictEqual( isPlainObjectArray( arr ), false, 'returns false when provided an empty array' );
diff --git a/lib/node_modules/@stdlib/assert/is-plain-object/test/test.js b/lib/node_modules/@stdlib/assert/is-plain-object/test/test.js
index 47679b42abe0..16a602c134c8 100644
--- a/lib/node_modules/@stdlib/assert/is-plain-object/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-plain-object/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a plain object', function test( t ) {
-	t.strictEqual( isPlainObject( {} ), true, 'returns true' );
+	t.strictEqual( isPlainObject( {} ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -45,7 +45,7 @@ tape( 'the function returns `true` if provided an object with no prototype', fun
 	var bool;
 
 	bool = isPlainObject( Object.create( null ) );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -64,7 +64,7 @@ tape( 'the function returns `false` if not provided an object', function test( t
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isPlainObject( values[i] ), false, 'returns false' );
+		t.strictEqual( isPlainObject( values[i] ), false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns `false` if provided a value having an own `construct
 		'constructor': Object
 	};
 
-	t.strictEqual( isPlainObject( obj ), false, 'returns false' );
+	t.strictEqual( isPlainObject( obj ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -86,7 +86,7 @@ tape( 'the function returns `false` if provided a value whose prototype lacks a
 	Foo.prototype.constructor = Foo;
 	delete Foo.prototype.isPrototypeOf;
 
-	t.strictEqual( isPlainObject( new Foo() ), false, 'returns false' );
+	t.strictEqual( isPlainObject( new Foo() ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -98,7 +98,7 @@ tape( 'the function returns `false` if provided a value whose prototype has a `i
 	Foo.prototype.constructor = Foo;
 	Foo.prototype.isPrototypeOf = 'beep';
 
-	t.strictEqual( isPlainObject( new Foo() ), false, 'returns false' );
+	t.strictEqual( isPlainObject( new Foo() ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -108,7 +108,7 @@ tape( 'the function returns `false` if provided a value whose prototype lacks a
 	}
 	Foo.prototype = {};
 
-	t.strictEqual( isPlainObject( new Foo() ), false, 'returns false' );
+	t.strictEqual( isPlainObject( new Foo() ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -119,7 +119,7 @@ tape( 'the function returns `false` if provided a value whose prototype has a co
 	Foo.prototype = Object.create( {} );
 	Foo.prototype.constructor = 'beep';
 
-	t.strictEqual( isPlainObject( new Foo() ), false, 'returns false' );
+	t.strictEqual( isPlainObject( new Foo() ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -135,7 +135,7 @@ tape( 'the function returns `false` if provided a value whose prototype has a co
 	isPlainObject = proxyquire( './../lib/main.js', {
 		'@stdlib/utils/native-class': nativeClass
 	});
-	t.strictEqual( isPlainObject( new Foo() ), false, 'returns false' );
+	t.strictEqual( isPlainObject( new Foo() ), false, 'returns expected value' );
 	t.end();
 
 	function nativeClass() {
@@ -150,7 +150,7 @@ tape( 'the function returns `true` if provided a value whose prototype equals th
 	Foo.prototype = Object.prototype;
 	Foo.prototype.constructor = Foo;
 
-	t.strictEqual( isPlainObject( new Foo() ), true, 'returns true' );
+	t.strictEqual( isPlainObject( new Foo() ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -166,7 +166,7 @@ tape( 'the function returns `false` if provided a value whose prototype does not
 	Foo.prototype.isPrototypeOf = function beep() {};
 	Foo.prototype.boop = 'boop';
 
-	t.strictEqual( isPlainObject( new Foo() ), false, 'returns false' );
+	t.strictEqual( isPlainObject( new Foo() ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -190,6 +190,6 @@ tape( 'the function returns `true` if provided a value whose prototype does not
 		'value': function foo() {}
 	});
 
-	t.strictEqual( isPlainObject( new Foo() ), true, 'returns true' );
+	t.strictEqual( isPlainObject( new Foo() ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.main.js b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.main.js
index 82c6d6417010..93da8c0f3ccf 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a positive finite number value', function test( t ) {
-	t.strictEqual( isPositiveFinite( 5.0 ), true, 'returns true' );
-	t.strictEqual( isPositiveFinite( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isPositiveFinite( 5.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveFinite( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.object.js b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.object.js
index 73b74baf9c11..fb634ef516c9 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.object.js
@@ -34,17 +34,17 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a finite positive value', function test( t ) {
-	t.strictEqual( isPositiveFinite( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isPositiveFinite( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a finite positive value', function test( t ) {
-	t.strictEqual( isPositiveFinite( 3.0 ), false, 'returns false' );
+	t.strictEqual( isPositiveFinite( 3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided positive infinity', function test( t ) {
-	t.strictEqual( isPositiveFinite( new Number( 5.0/0.0 ) ), false, 'returns false' );
+	t.strictEqual( isPositiveFinite( new Number( 5.0/0.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.primitive.js
index 727de3a64bf1..2e09066b94f7 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-finite/test/test.primitive.js
@@ -34,17 +34,17 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a finite positive value', function test( t ) {
-	t.strictEqual( isPositiveFinite( 3.0 ), true, 'returns true' );
+	t.strictEqual( isPositiveFinite( 3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided positive infinity', function test( t ) {
-	t.strictEqual( isPositiveFinite( 1.0/0.0 ), false, 'returns false' );
+	t.strictEqual( isPositiveFinite( 1.0/0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a finite positive value', function test( t ) {
-	t.strictEqual( isPositiveFinite( new Number( 5.0 ) ), false, 'returns false' );
+	t.strictEqual( isPositiveFinite( new Number( 5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-positive-integer-array/test/test.js b/lib/node_modules/@stdlib/assert/is-positive-integer-array/test/test.js
index 1ac9592d49ab..8c99bd22a412 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-integer-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-integer-array/test/test.js
@@ -40,20 +40,20 @@ tape( 'the function tests for a generic number array having only positive intege
 	var arr;
 
 	arr = [ 5.0, new Number( 5 ), 1.0 ];
-	t.strictEqual( isPositiveIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = [ 5.0, '3', null ];
-	t.strictEqual( isPositiveIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveIntegerArray( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 5,
 		'1': 1
 	};
-	t.strictEqual( isPositiveIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = new Int32Array( [ 5, 2, 0 ] );
-	t.strictEqual( isPositiveIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveIntegerArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -62,20 +62,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ 5.0, 1.0 ];
-	t.strictEqual( isPositiveIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( 5 ), 1.0, 1.0 ];
-	t.strictEqual( isPositiveIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveIntegerArray.primitives( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 5,
 		'1': 1
 	};
-	t.strictEqual( isPositiveIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = new Int16Array( [ 5, 2, 1 ] );
-	t.strictEqual( isPositiveIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,20 +84,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( 5 ), new Number( 2 ) ];
-	t.strictEqual( isPositiveIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ 5.0, 1.0, 1.0 ];
-	t.strictEqual( isPositiveIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveIntegerArray.objects( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 5 ),
 		'1': new Number( 1 )
 	};
-	t.strictEqual( isPositiveIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveIntegerArray.objects( arr ), true, 'returns expected value' );
 
 	arr = new Uint32Array( [ 5, 1 ] );
-	t.strictEqual( isPositiveIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveIntegerArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.main.js b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.main.js
index 43af9d38ecb5..4a81c3ed8244 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a positive integer value', function test( t ) {
-	t.strictEqual( isPositiveInteger( 5.0 ), true, 'returns true' );
-	t.strictEqual( isPositiveInteger( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isPositiveInteger( 5.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveInteger( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.object.js b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.object.js
index 58dd32a0454d..0b5018be9fae 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a positive integer value', function test( t ) {
-	t.strictEqual( isPositiveInteger( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isPositiveInteger( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a positive integer value', function test( t ) {
-	t.strictEqual( isPositiveInteger( 3.0 ), false, 'returns false' );
+	t.strictEqual( isPositiveInteger( 3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.primitive.js
index 63d1997d752e..cd402e45d49e 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-integer/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a positive integer value', function test( t ) {
-	t.strictEqual( isPositiveInteger( 3.0 ), true, 'returns true' );
+	t.strictEqual( isPositiveInteger( 3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a positive integer value', function test( t ) {
-	t.strictEqual( isPositiveInteger( new Number( 5.0 ) ), false, 'returns false' );
+	t.strictEqual( isPositiveInteger( new Number( 5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-positive-number-array/test/test.js b/lib/node_modules/@stdlib/assert/is-positive-number-array/test/test.js
index 630abe7d66b2..2e110eedb405 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-number-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-number-array/test/test.js
@@ -38,20 +38,20 @@ tape( 'the function tests for an array-like object containing only positive numb
 	var arr;
 
 	arr = [ 5.0, new Number( 5 ), 1.0 ];
-	t.strictEqual( isPositiveNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray( arr ), true, 'returns expected value' );
 
 	arr = [ 5.0, '3', null ];
-	t.strictEqual( isPositiveNumberArray( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveNumberArray( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 3.14,
 		'1': 2.0
 	};
-	t.strictEqual( isPositiveNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray( arr ), true, 'returns expected value' );
 
 	arr = new Float32Array( [ 5.0, 1.5 ] );
-	t.strictEqual( isPositiveNumberArray( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray( arr ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -60,20 +60,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ 5.0, 2.0 ];
-	t.strictEqual( isPositiveNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( 5 ), 1.0, 1.0 ];
-	t.strictEqual( isPositiveNumberArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveNumberArray.primitives( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 3.14,
 		'1': 1.0
 	};
-	t.strictEqual( isPositiveNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = new Float32Array( [ 5.0, 1.5 ] );
-	t.strictEqual( isPositiveNumberArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray.primitives( arr ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,20 +82,20 @@ tape( 'the function provides a method to test for an array-like object having on
 	var arr;
 
 	arr = [ new Number( 5 ), new Number( 5 ) ];
-	t.strictEqual( isPositiveNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ 5.0, 1.0 ];
-	t.strictEqual( isPositiveNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveNumberArray.objects( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 3.14 ),
 		'1': new Number( 2.0 )
 	};
-	t.strictEqual( isPositiveNumberArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isPositiveNumberArray.objects( arr ), true, 'returns expected value' );
 
 	arr = new Float32Array( [ 5.0, 1.5 ] );
-	t.strictEqual( isPositiveNumberArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isPositiveNumberArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.main.js
index 8a60ce976470..af5331abe59e 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a positive number value', function test( t ) {
-	t.strictEqual( isPositiveNumber( 5.0 ), true, 'returns true' );
-	t.strictEqual( isPositiveNumber( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isPositiveNumber( 5.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveNumber( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.object.js
index 9845d6e244ad..b2e2cc526f13 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a positive value', function test( t ) {
-	t.strictEqual( isPositiveNumber( new Number( 5.0 ) ), true, 'returns true' );
+	t.strictEqual( isPositiveNumber( new Number( 5.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a positive value', function test( t ) {
-	t.strictEqual( isPositiveNumber( 3.0 ), false, 'returns false' );
+	t.strictEqual( isPositiveNumber( 3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.primitive.js
index 233a383162fc..256ace521ce0 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a positive value', function test( t ) {
-	t.strictEqual( isPositiveNumber( 3.0 ), true, 'returns true' );
+	t.strictEqual( isPositiveNumber( 3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a positive value', function test( t ) {
-	t.strictEqual( isPositiveNumber( new Number( 5.0 ) ), false, 'returns false' );
+	t.strictEqual( isPositiveNumber( new Number( 5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-positive-zero/test/test.main.js b/lib/node_modules/@stdlib/assert/is-positive-zero/test/test.main.js
index ccc26de6eea5..06ad4b3e4f07 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-zero/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-zero/test/test.main.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -36,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number equal to positive zero', function test( t ) {
-	t.strictEqual( isPositiveZero( 0.0 ), true, 'returns true' );
-	t.strictEqual( isPositiveZero( new Number( 0.0 ) ), true, 'returns true' );
+	t.strictEqual( isPositiveZero( 0.0 ), true, 'returns expected value' );
+	t.strictEqual( isPositiveZero( new Number( 0.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-positive-zero/test/test.object.js b/lib/node_modules/@stdlib/assert/is-positive-zero/test/test.object.js
index e80691cbb7da..291d9912135b 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-zero/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-zero/test/test.object.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -36,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a value equal to positive zero', function test( t ) {
-	t.strictEqual( isPositiveZero( new Number( 0.0 ) ), true, 'returns true' );
+	t.strictEqual( isPositiveZero( new Number( 0.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is equal to positive zero', function test( t ) {
-	t.strictEqual( isPositiveZero( 0.0 ), false, 'returns false' );
+	t.strictEqual( isPositiveZero( 0.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-positive-zero/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-positive-zero/test/test.primitive.js
index ad0a9bfb2c93..dd132dfaf349 100644
--- a/lib/node_modules/@stdlib/assert/is-positive-zero/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-positive-zero/test/test.primitive.js
@@ -16,8 +16,6 @@
 * limitations under the License.
 */
 
-/* eslint-disable no-new-wrappers */
-
 'use strict';
 
 // MODULES //
@@ -36,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number equal to positive zero', function test( t ) {
-	t.strictEqual( isPositiveZero( 0.0 ), true, 'returns true' );
+	t.strictEqual( isPositiveZero( 0.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a value equal to positive zero', function test( t ) {
-	t.strictEqual( isPositiveZero( new Number( 0.0 ) ), false, 'returns false' );
+	t.strictEqual( isPositiveZero( new Number( 0.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-prime/test/test.object.js b/lib/node_modules/@stdlib/assert/is-prime/test/test.object.js
index 986ab02dae92..9971af2a5907 100644
--- a/lib/node_modules/@stdlib/assert/is-prime/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-prime/test/test.object.js
@@ -56,9 +56,9 @@ tape( 'the function returns `true` if provided a number object having a prime nu
 });
 
 tape( 'the function returns `false` if provided a primitive prime number', function test( t ) {
-	t.strictEqual( isPrime( 5.0 ), false, 'returns false' );
-	t.strictEqual( isPrime( 7.0 ), false, 'returns false' );
-	t.strictEqual( isPrime( 11.0 ), false, 'returns false' );
+	t.strictEqual( isPrime( 5.0 ), false, 'returns expected value' );
+	t.strictEqual( isPrime( 7.0 ), false, 'returns expected value' );
+	t.strictEqual( isPrime( 11.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-prime/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-prime/test/test.primitive.js
index 966c7c21de49..0216cfe3d19d 100644
--- a/lib/node_modules/@stdlib/assert/is-prime/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-prime/test/test.primitive.js
@@ -56,9 +56,9 @@ tape( 'the function returns `true` if provided a primitive prime number', functi
 });
 
 tape( 'the function returns `false` if provided a number object', function test( t ) {
-	t.strictEqual( isPrime( new Number( 5.0 ) ), false, 'returns false' );
-	t.strictEqual( isPrime( new Number( 7.0 ) ), false, 'returns false' );
-	t.strictEqual( isPrime( new Number( 11.0 ) ), false, 'returns false' );
+	t.strictEqual( isPrime( new Number( 5.0 ) ), false, 'returns expected value' );
+	t.strictEqual( isPrime( new Number( 7.0 ) ), false, 'returns expected value' );
+	t.strictEqual( isPrime( new Number( 11.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-primitive-array/test/test.js b/lib/node_modules/@stdlib/assert/is-primitive-array/test/test.js
index e694520c13e7..5558f40155be 100644
--- a/lib/node_modules/@stdlib/assert/is-primitive-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-primitive-array/test/test.js
@@ -38,10 +38,10 @@ tape( 'the function tests for an array-like object containing only primitives',
 	var arr;
 
 	arr = [ 'abc', 123, null, NaN, undefined ];
-	t.strictEqual( isPrimitiveArray( arr ), true, 'returns true' );
+	t.strictEqual( isPrimitiveArray( arr ), true, 'returns expected value' );
 
 	arr = [ 5.0, '5.0', new Number( 2 ) ];
-	t.strictEqual( isPrimitiveArray( arr ), false, 'returns false' );
+	t.strictEqual( isPrimitiveArray( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 3,
@@ -49,13 +49,13 @@ tape( 'the function tests for an array-like object containing only primitives',
 		'1': '5.0',
 		'2': false
 	};
-	t.strictEqual( isPrimitiveArray( arr ), true, 'returns true' );
+	t.strictEqual( isPrimitiveArray( arr ), true, 'returns expected value' );
 
 	arr = new Uint8Array( [ 1, 2, 3, 4, 5 ] );
-	t.strictEqual( isPrimitiveArray( arr ), true, 'returns true' );
+	t.strictEqual( isPrimitiveArray( arr ), true, 'returns expected value' );
 
 	arr = [ {}, new String( 'abc' ) ];
-	t.strictEqual( isPrimitiveArray( arr ), false, 'returns false' );
+	t.strictEqual( isPrimitiveArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-primitive/test/test.js b/lib/node_modules/@stdlib/assert/is-primitive/test/test.js
index ecc02bc5afbd..5182847b5167 100644
--- a/lib/node_modules/@stdlib/assert/is-primitive/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-primitive/test/test.js
@@ -59,7 +59,7 @@ tape( 'the function returns `true` if provided a primitive (ES5)', function test
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( isPrimitive( values[i] ), true, 'returns true' );
+		t.strictEqual( isPrimitive( values[i] ), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -68,7 +68,7 @@ opts = {
 	'skip': !hasSymbols
 };
 tape( 'the function returns `true` if provided a `Symbol` (ES6/ES2015)', opts, function test( t ) {
-	t.strictEqual( isPrimitive( Symbol( 'symbol' ) ), true, 'returns true' );
+	t.strictEqual( isPrimitive( Symbol( 'symbol' ) ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -76,7 +76,7 @@ opts = {
 	'skip': !hasBigInts
 };
 tape( 'the function returns `true` if provided a `BigInt` (ES2020)', opts, function test( t ) {
-	t.strictEqual( isPrimitive( BigInt( '1' ) ), true, 'returns true' );
+	t.strictEqual( isPrimitive( BigInt( '1' ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-probability-array/test/test.js b/lib/node_modules/@stdlib/assert/is-probability-array/test/test.js
index a3b0127e9692..bed7b592b7ad 100644
--- a/lib/node_modules/@stdlib/assert/is-probability-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-probability-array/test/test.js
@@ -38,23 +38,23 @@ tape( 'the function tests for an array-like object containing only probabilities
 	var arr;
 
 	arr = [ 0.9, new Number( 0.8 ), 0.0 ];
-	t.strictEqual( isProbabilityArray( arr ), true, 'returns true' );
+	t.strictEqual( isProbabilityArray( arr ), true, 'returns expected value' );
 
 	arr = new Float64Array( [ 0.9, 0.5, 0.3 ] );
-	t.strictEqual( isProbabilityArray( arr ), true, 'returns true' );
+	t.strictEqual( isProbabilityArray( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 0.3,
 		'1': 0.8
 	};
-	t.strictEqual( isProbabilityArray( arr ), true, 'returns true' );
+	t.strictEqual( isProbabilityArray( arr ), true, 'returns expected value' );
 
 	arr = [ 0.9, '3', null ];
-	t.strictEqual( isProbabilityArray( arr ), false, 'returns false' );
+	t.strictEqual( isProbabilityArray( arr ), false, 'returns expected value' );
 
 	arr = new Float64Array( [ 0.9, NaN, 0.3 ] );
-	t.strictEqual( isProbabilityArray( arr ), false, 'returns false' );
+	t.strictEqual( isProbabilityArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -63,13 +63,13 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ 1.0, 0.0 ];
-	t.strictEqual( isProbabilityArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isProbabilityArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = new Float64Array( [ 0.9, 0.5, 0.3 ] );
-	t.strictEqual( isProbabilityArray( arr ), true, 'returns true' );
+	t.strictEqual( isProbabilityArray( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( 5 ), 1.0, 1.0 ];
-	t.strictEqual( isProbabilityArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isProbabilityArray.primitives( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -78,17 +78,17 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( 0.5 ), new Number( 0.5 ) ];
-	t.strictEqual( isProbabilityArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isProbabilityArray.objects( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 0.3 ),
 		'1': new Number( 0.8 )
 	};
-	t.strictEqual( isProbabilityArray( arr ), true, 'returns true' );
+	t.strictEqual( isProbabilityArray( arr ), true, 'returns expected value' );
 
 	arr = [ 0.5, 0.0 ];
-	t.strictEqual( isProbabilityArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isProbabilityArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-probability/test/test.main.js b/lib/node_modules/@stdlib/assert/is-probability/test/test.main.js
index 69029d9a6883..5050db55cd4d 100644
--- a/lib/node_modules/@stdlib/assert/is-probability/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-probability/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a probability', function test( t ) {
-	t.strictEqual( isProbability( 0.5 ), true, 'returns true' );
-	t.strictEqual( isProbability( new Number( 0.5 ) ), true, 'returns true' );
+	t.strictEqual( isProbability( 0.5 ), true, 'returns expected value' );
+	t.strictEqual( isProbability( new Number( 0.5 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-probability/test/test.object.js b/lib/node_modules/@stdlib/assert/is-probability/test/test.object.js
index d8009080d335..3204b006a4ff 100644
--- a/lib/node_modules/@stdlib/assert/is-probability/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-probability/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a probability value', function test( t ) {
-	t.strictEqual( isProbability( new Number( 0.33 ) ), true, 'returns true' );
+	t.strictEqual( isProbability( new Number( 0.33 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive probability', function test( t ) {
-	t.strictEqual( isProbability( 0.33 ), false, 'returns false' );
+	t.strictEqual( isProbability( 0.33 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-probability/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-probability/test/test.primitive.js
index da0194ea520a..4977fecf4cd1 100644
--- a/lib/node_modules/@stdlib/assert/is-probability/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-probability/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive probability', function test( t ) {
-	t.strictEqual( isProbability( 0.11 ), true, 'returns true' );
+	t.strictEqual( isProbability( 0.11 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object', function test( t ) {
-	t.strictEqual( isProbability( new Number( 0.11 ) ), false, 'returns false' );
+	t.strictEqual( isProbability( new Number( 0.11 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-property-key/test/test.js b/lib/node_modules/@stdlib/assert/is-property-key/test/test.js
index 172e80697f74..49bd8c4c7aa3 100644
--- a/lib/node_modules/@stdlib/assert/is-property-key/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-property-key/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a string primitive', function test( t ) {
-	t.strictEqual( isPropertyKey( 'beep' ), true, 'returns true' );
+	t.strictEqual( isPropertyKey( 'beep' ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided a symbol primitive', opts, function test( t ) {
-	t.strictEqual( isPropertyKey( Symbol( 'beep' ) ), true, 'returns true' );
-	t.strictEqual( isPropertyKey( SymbolIterator ), true, 'returns true' );
+	t.strictEqual( isPropertyKey( Symbol( 'beep' ) ), true, 'returns expected value' );
+	t.strictEqual( isPropertyKey( SymbolIterator ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided a nonnegative integer primitive', function test( t ) {
-	t.strictEqual( isPropertyKey( 0 ), true, 'returns true' );
-	t.strictEqual( isPropertyKey( 1 ), true, 'returns true' );
-	t.strictEqual( isPropertyKey( 139 ), true, 'returns true' );
+	t.strictEqual( isPropertyKey( 0 ), true, 'returns expected value' );
+	t.strictEqual( isPropertyKey( 1 ), true, 'returns expected value' );
+	t.strictEqual( isPropertyKey( 139 ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-prototype-of/test/test.js b/lib/node_modules/@stdlib/assert/is-prototype-of/test/test.js
index db9c5920304c..56c2b9a913ec 100644
--- a/lib/node_modules/@stdlib/assert/is-prototype-of/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-prototype-of/test/test.js
@@ -96,7 +96,7 @@ tape( 'the function returns `true` if a provided prototype is part of a value\'s
 	bar = new Bar();
 	bool = isPrototypeOf( bar, Foo.prototype );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( bar instanceof Bar, true, 'is instance of Bar' );
 	t.strictEqual( bar instanceof Foo, true, 'is instance of Foo' );
 	t.end();
@@ -117,7 +117,7 @@ tape( 'the function returns `false` if a provided prototype is not part of a val
 	bar = new Bar();
 	bool = isPrototypeOf( bar, Foo.prototype );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.strictEqual( bar instanceof Bar, true, 'is instance of Bar' );
 	t.strictEqual( bar instanceof Foo, false, 'is not instance of Foo' );
 	t.end();
@@ -146,7 +146,7 @@ tape( 'the function supports situations where constructors are never used', func
 	t.throws( isInstance, TypeError, 'throws type error if using `instanceof`' );
 
 	bool = isPrototypeOf( v, superProto );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -160,13 +160,13 @@ tape( 'the function returns `false` if provided primitives and their correspondi
 	var bool;
 
 	bool = isPrototypeOf( true, Boolean.prototype );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isPrototypeOf( 'beep', String.prototype );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isPrototypeOf( 5, Number.prototype );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-range-error/test/test.js b/lib/node_modules/@stdlib/assert/is-range-error/test/test.js
index 87b00389c347..1ba63baca2d0 100644
--- a/lib/node_modules/@stdlib/assert/is-range-error/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-range-error/test/test.js
@@ -72,13 +72,13 @@ tape( 'the function returns `true` if provided an object inheriting from `RangeE
 
 tape( 'the function returns `true` if provided a `RangeError` object from a different realm', opts, function test( t ) {
 	var error = vm.runInNewContext( 'new RangeError()' );
-	t.strictEqual( isRangeError( error ), true, 'returns true' );
+	t.strictEqual( isRangeError( error ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an object from a different realm which inherits from a `RangeError` object', opts, function test( t ) {
 	var error = vm.runInNewContext( 'function Err() { return this; }; Err.prototype = new RangeError(); new Err();' );
-	t.strictEqual( isRangeError( error ), true, 'returns true' );
+	t.strictEqual( isRangeError( error ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-read-only-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-read-only-property-in/test/test.js
index 707cc669cebb..4e720daeb8ca 100644
--- a/lib/node_modules/@stdlib/assert/is-read-only-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-read-only-property-in/test/test.js
@@ -66,16 +66,16 @@ tape( 'the function returns `true` if an object property is read-only', function
 	});
 
 	bool = isReadOnlyPropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( obj, 'b' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( obj, 'c' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( obj, 'd' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -108,10 +108,10 @@ tape( 'the function returns `true` if provided an inherited property which is re
 	obj = new Foo();
 
 	bool = isReadOnlyPropertyIn( obj, 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( obj, 'beep' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -133,19 +133,19 @@ tape( 'the function returns `false` if an object property is not read-only', fun
 		'a': 'b'
 	};
 	bool = isReadOnlyPropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( new Foo(), 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( [ 'a' ], 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -156,7 +156,7 @@ tape( 'the function returns `false` if an object property is not read-only', fun
 	});
 
 	bool = isReadOnlyPropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 
@@ -174,10 +174,10 @@ tape( 'the function returns `false` if an object property is not read-only', fun
 	});
 
 	bool = isReadOnlyPropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( obj, 'b' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -231,16 +231,16 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isReadOnlyPropertyIn( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( obj, 'e' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( obj, 'f' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -257,13 +257,13 @@ tape( 'the function returns `false` if provided an inherited property which is n
 	var bool;
 
 	bool = isReadOnlyPropertyIn( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyPropertyIn( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -272,7 +272,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isReadOnlyPropertyIn( 'beep', 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-read-only-property/test/test.js b/lib/node_modules/@stdlib/assert/is-read-only-property/test/test.js
index 5fc0976ff9d1..cc667396897b 100644
--- a/lib/node_modules/@stdlib/assert/is-read-only-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-read-only-property/test/test.js
@@ -66,16 +66,16 @@ tape( 'the function returns `true` if an object property is read-only', function
 	});
 
 	bool = isReadOnlyProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadOnlyProperty( obj, 'b' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadOnlyProperty( obj, 'c' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadOnlyProperty( obj, 'd' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -97,19 +97,19 @@ tape( 'the function returns `false` if an object property is not read-only', fun
 		'a': 'b'
 	};
 	bool = isReadOnlyProperty( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyProperty( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyProperty( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyProperty( new Foo(), 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyProperty( [ 'a' ], 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -120,7 +120,7 @@ tape( 'the function returns `false` if an object property is not read-only', fun
 	});
 
 	bool = isReadOnlyProperty( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -131,7 +131,7 @@ tape( 'the function returns `false` if an object property is not read-only', fun
 	});
 
 	bool = isReadOnlyProperty( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -185,16 +185,16 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isReadOnlyProperty( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyProperty( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyProperty( obj, 'e' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyProperty( obj, 'f' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -211,13 +211,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isReadOnlyProperty( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyProperty( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadOnlyProperty( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -226,7 +226,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isReadOnlyProperty( 'beep', 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-read-write-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-read-write-property-in/test/test.js
index 550c1de39574..a0809d01f7b7 100644
--- a/lib/node_modules/@stdlib/assert/is-read-write-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-read-write-property-in/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property is readable and writabl
 		'a': 'b'
 	};
 	bool = isReadWritePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadWritePropertyIn( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadWritePropertyIn( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadWritePropertyIn( new Foo(), 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadWritePropertyIn( [ 'a' ], 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property is readable and writabl
 	});
 
 	bool = isReadWritePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -80,7 +80,7 @@ tape( 'the function returns `true` if an object property is readable and writabl
 	});
 
 	bool = isReadWritePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -100,10 +100,10 @@ tape( 'the function returns `true` if provided an inherited readable and writabl
 	t.strictEqual( bool, true, 'returns true ' );
 
 	bool = isReadWritePropertyIn( {}, 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadWritePropertyIn( {}, 'constructor' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -148,16 +148,16 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isReadWritePropertyIn( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadWritePropertyIn( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadWritePropertyIn( obj, 'e' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadWritePropertyIn( obj, 'f' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -174,7 +174,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isReadWritePropertyIn( 'beep', 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-read-write-property/test/test.js b/lib/node_modules/@stdlib/assert/is-read-write-property/test/test.js
index b0730327ae67..f59bf201f093 100644
--- a/lib/node_modules/@stdlib/assert/is-read-write-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-read-write-property/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property is readable and writabl
 		'a': 'b'
 	};
 	bool = isReadWriteProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadWriteProperty( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadWriteProperty( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadWriteProperty( new Foo(), 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadWriteProperty( [ 'a' ], 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property is readable and writabl
 	});
 
 	bool = isReadWriteProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -80,7 +80,7 @@ tape( 'the function returns `true` if an object property is readable and writabl
 	});
 
 	bool = isReadWriteProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -133,16 +133,16 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isReadWriteProperty( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadWriteProperty( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadWriteProperty( obj, 'e' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadWriteProperty( obj, 'f' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -159,13 +159,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isReadWriteProperty( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadWriteProperty( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadWriteProperty( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -174,7 +174,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isReadWriteProperty( 'beep', 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-readable-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-readable-property-in/test/test.js
index d9a67a7b7c28..c026aec2b0e8 100644
--- a/lib/node_modules/@stdlib/assert/is-readable-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-readable-property-in/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property is readable', function
 		'a': 'b'
 	};
 	bool = isReadablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadablePropertyIn( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadablePropertyIn( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadablePropertyIn( new Foo(), 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadablePropertyIn( [ 'a' ], 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property is readable', function
 	});
 
 	bool = isReadablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -79,7 +79,7 @@ tape( 'the function returns `true` if an object property is readable', function
 	});
 
 	bool = isReadablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -92,13 +92,13 @@ tape( 'the function returns `true` if provided a readable inherited property', f
 	var bool;
 
 	bool = isReadablePropertyIn( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadablePropertyIn( {}, 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadablePropertyIn( {}, 'constructor' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -130,10 +130,10 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isReadablePropertyIn( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadablePropertyIn( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 
 	function setter() {
@@ -145,7 +145,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isReadablePropertyIn( 'beep', 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-readable-property/test/test.js b/lib/node_modules/@stdlib/assert/is-readable-property/test/test.js
index f0aeda7a4f96..d1f9cc565d3a 100644
--- a/lib/node_modules/@stdlib/assert/is-readable-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-readable-property/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property is readable', function
 		'a': 'b'
 	};
 	bool = isReadableProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadableProperty( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadableProperty( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadableProperty( new Foo(), 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isReadableProperty( [ 'a' ], 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property is readable', function
 	});
 
 	bool = isReadableProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -79,7 +79,7 @@ tape( 'the function returns `true` if an object property is readable', function
 	});
 
 	bool = isReadableProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -115,10 +115,10 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isReadableProperty( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadableProperty( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 
 	function setter() {
@@ -130,13 +130,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isReadableProperty( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadableProperty( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isReadableProperty( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -145,7 +145,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isReadableProperty( 'beep', 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-reference-error/test/test.js b/lib/node_modules/@stdlib/assert/is-reference-error/test/test.js
index b0ea2d59194a..db5566460ec5 100644
--- a/lib/node_modules/@stdlib/assert/is-reference-error/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-reference-error/test/test.js
@@ -72,13 +72,13 @@ tape( 'the function returns `true` if provided an object inheriting from `Refere
 
 tape( 'the function returns `true` if provided a `ReferenceError` object from a different realm', opts, function test( t ) {
 	var error = vm.runInNewContext( 'new ReferenceError()' );
-	t.strictEqual( isReferenceError( error ), true, 'returns true' );
+	t.strictEqual( isReferenceError( error ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an object from a different realm which inherits from a `ReferenceError` object', opts, function test( t ) {
 	var error = vm.runInNewContext( 'function Err() { return this; }; Err.prototype = new ReferenceError(); new Err();' );
-	t.strictEqual( isReferenceError( error ), true, 'returns true' );
+	t.strictEqual( isReferenceError( error ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-regexp-string/test/test.js b/lib/node_modules/@stdlib/assert/is-regexp-string/test/test.js
index bb98de729c9e..8c3f4b0caac2 100644
--- a/lib/node_modules/@stdlib/assert/is-regexp-string/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-regexp-string/test/test.js
@@ -33,8 +33,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a regular expression string', function test( t ) {
-	t.strictEqual( isRegExpString( '/beep/' ), true, 'returns true' );
-	t.strictEqual( isRegExpString( '/beep/gim' ), true, 'returns true' );
+	t.strictEqual( isRegExpString( '/beep/' ), true, 'returns expected value' );
+	t.strictEqual( isRegExpString( '/beep/gim' ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-regexp/test/test.js b/lib/node_modules/@stdlib/assert/is-regexp/test/test.js
index d510ea4383f0..c9a0377010df 100644
--- a/lib/node_modules/@stdlib/assert/is-regexp/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-regexp/test/test.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a regular expression', function test( t ) {
-	t.strictEqual( isRegExp( /\.+/ ), true, 'returns true' );
-	t.strictEqual( isRegExp( new RegExp( '\\.+' ) ), true, 'returns true' ); // eslint-disable-line prefer-regex-literals
+	t.strictEqual( isRegExp( /\.+/ ), true, 'returns expected value' );
+	t.strictEqual( isRegExp( new RegExp( '\\.+' ) ), true, 'returns expected value' ); // eslint-disable-line prefer-regex-literals
 	t.end();
 });
 
@@ -63,7 +63,7 @@ tape( 'if `Symbol.toStringTag` is supported, the function guards against objects
 	if ( hasToStringTag() ) {
 		mock[ Symbol.toStringTag ] = 'RegExp';
 	}
-	t.strictEqual( isRegExp( mock ), false, 'returns false' );
+	t.strictEqual( isRegExp( mock ), false, 'returns expected value' );
 
 	t.end();
 
@@ -83,7 +83,7 @@ tape( 'if `Symbol.toStringTag` is supported, the function returns `true` if prov
 		'@stdlib/assert/has-tostringtag-support': detect
 	});
 
-	t.strictEqual( isRegExp( /beep/ ), true, 'returns true' );
+	t.strictEqual( isRegExp( /beep/ ), true, 'returns expected value' );
 
 	t.end();
 
@@ -97,8 +97,8 @@ tape( 'if `Symbol.toStringTag` is not supported, the function attempts to determ
 		'@stdlib/assert/has-tostringtag-support': detect
 	});
 
-	t.strictEqual( isRegExp( /beep/ ), true, 'returns true' );
-	t.strictEqual( isRegExp( {} ), false, 'returns false' );
+	t.strictEqual( isRegExp( /beep/ ), true, 'returns expected value' );
+	t.strictEqual( isRegExp( {} ), false, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/assert/is-relative-path/test/test.posix.js b/lib/node_modules/@stdlib/assert/is-relative-path/test/test.posix.js
index 1f94e18144f6..21af9afbb211 100644
--- a/lib/node_modules/@stdlib/assert/is-relative-path/test/test.posix.js
+++ b/lib/node_modules/@stdlib/assert/is-relative-path/test/test.posix.js
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 
 tape( 'the function returns `true` if provided an empty string', function test( t ) {
 	var bool = isRelativePath( '' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-relative-path/test/test.win32.js b/lib/node_modules/@stdlib/assert/is-relative-path/test/test.win32.js
index d9e6fe16ec18..beff3954e8ed 100644
--- a/lib/node_modules/@stdlib/assert/is-relative-path/test/test.win32.js
+++ b/lib/node_modules/@stdlib/assert/is-relative-path/test/test.win32.js
@@ -56,7 +56,7 @@ tape( 'the function returns `false` if not provided a string', function test( t
 
 tape( 'the function returns `true` if provided an empty string', function test( t ) {
 	var bool = isRelativePath( '' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-safe-integer-array/test/test.js b/lib/node_modules/@stdlib/assert/is-safe-integer-array/test/test.js
index a39f2d6632a4..cd6bf62453ee 100644
--- a/lib/node_modules/@stdlib/assert/is-safe-integer-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-safe-integer-array/test/test.js
@@ -37,23 +37,23 @@ tape( 'the function tests for an array-like object containing only safe integer
 	var arr;
 
 	arr = [ 5, new Number( 5 ), -3 ];
-	t.strictEqual( isSafeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isSafeIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 2,
 		'1': 1
 	};
-	t.strictEqual( isSafeIntegerArray( arr ), true, 'returns true' );
+	t.strictEqual( isSafeIntegerArray( arr ), true, 'returns expected value' );
 
 	arr = [ 1e100, 2e200, 3e300 ];
-	t.strictEqual( isSafeIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isSafeIntegerArray( arr ), false, 'returns expected value' );
 
 	arr = [ 5.0, 2.3, 11.1 ];
-	t.strictEqual( isSafeIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isSafeIntegerArray( arr ), false, 'returns expected value' );
 
 	arr = [ 5.0, '3', null ];
-	t.strictEqual( isSafeIntegerArray( arr ), false, 'returns false' );
+	t.strictEqual( isSafeIntegerArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -62,20 +62,20 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ 5, -0, 0 ];
-	t.strictEqual( isSafeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isSafeIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ 1e100, 2e200, 3e300 ];
-	t.strictEqual( isSafeIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isSafeIntegerArray.primitives( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': 1,
 		'1': -3
 	};
-	t.strictEqual( isSafeIntegerArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isSafeIntegerArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( 5 ), 1, 1 ];
-	t.strictEqual( isSafeIntegerArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isSafeIntegerArray.primitives( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -84,23 +84,23 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ new Number( 5 ), new Number( -0 ), new Number( 0 ) ];
-	t.strictEqual( isSafeIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isSafeIntegerArray.objects( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': new Number( 2 ),
 		'1': new Number( -3 )
 	};
-	t.strictEqual( isSafeIntegerArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isSafeIntegerArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ new Number( 1e100 ), new Number( 2e200 ), new Number( 3e300 ) ];
-	t.strictEqual( isSafeIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isSafeIntegerArray.objects( arr ), false, 'returns expected value' );
 
 	arr = [ new Number( 5 ), 1, 1 ];
-	t.strictEqual( isSafeIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isSafeIntegerArray.objects( arr ), false, 'returns expected value' );
 
 	arr = [ -5, 1, 1 ];
-	t.strictEqual( isSafeIntegerArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isSafeIntegerArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-safe-integer/test/test.main.js b/lib/node_modules/@stdlib/assert/is-safe-integer/test/test.main.js
index 85e98e3a4fe2..17bef6af2617 100644
--- a/lib/node_modules/@stdlib/assert/is-safe-integer/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-safe-integer/test/test.main.js
@@ -34,10 +34,10 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number having a safe integer value', function test( t ) {
-	t.strictEqual( isSafeInteger( 5 ), true, 'returns true' );
-	t.strictEqual( isSafeInteger( -5 ), true, 'returns true' );
-	t.strictEqual( isSafeInteger( new Number( 5 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
-	t.strictEqual( isSafeInteger( new Number( -5 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isSafeInteger( 5 ), true, 'returns expected value' );
+	t.strictEqual( isSafeInteger( -5 ), true, 'returns expected value' );
+	t.strictEqual( isSafeInteger( new Number( 5 ) ), true, 'returns expected value' );
+	t.strictEqual( isSafeInteger( new Number( -5 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-safe-integer/test/test.object.js b/lib/node_modules/@stdlib/assert/is-safe-integer/test/test.object.js
index ed6361151f59..9ec69c588a26 100644
--- a/lib/node_modules/@stdlib/assert/is-safe-integer/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-safe-integer/test/test.object.js
@@ -34,17 +34,17 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a safe integer value', function test( t ) {
-	t.strictEqual( isSafeInteger( new Number( 5 ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isSafeInteger( new Number( 5 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object not having a safe integer value', function test( t ) {
-	t.strictEqual( isSafeInteger( new Number( 2.0e200 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isSafeInteger( new Number( 2.0e200 ) ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number, even if the number is a safe integer value', function test( t ) {
-	t.strictEqual( isSafeInteger( 3.0 ), false, 'returns false' );
+	t.strictEqual( isSafeInteger( 3.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-safe-integer/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-safe-integer/test/test.primitive.js
index 405feed5d0e4..ead49f0a9072 100644
--- a/lib/node_modules/@stdlib/assert/is-safe-integer/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-safe-integer/test/test.primitive.js
@@ -34,17 +34,17 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive number having a safe integer value', function test( t ) {
-	t.strictEqual( isSafeInteger( -3.0 ), true, 'returns true' );
+	t.strictEqual( isSafeInteger( -3.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive number not having a safe integer value', function test( t ) {
-	t.strictEqual( isSafeInteger( 2.0e200 ), false, 'returns false' );
+	t.strictEqual( isSafeInteger( 2.0e200 ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object, even if the number has a safe integer value', function test( t ) {
-	t.strictEqual( isSafeInteger( new Number( 5.0 ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isSafeInteger( new Number( 5.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-same-native-class/test/test.js b/lib/node_modules/@stdlib/assert/is-same-native-class/test/test.js
index 63b3a5e86f95..e8118dbc6233 100644
--- a/lib/node_modules/@stdlib/assert/is-same-native-class/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-same-native-class/test/test.js
@@ -53,7 +53,7 @@ tape( 'the function returns `true` if provided two arguments which have the same
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isSameNativeClass( values[ i ][ 0 ], values[ i ][ 1 ] );
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'the function returns `false` if not provided two arguments having the sam
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isSameNativeClass( values[ i ][ 0 ], values[ i ][ 1 ] );
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-same-type/test/test.js b/lib/node_modules/@stdlib/assert/is-same-type/test/test.js
index 03a8c11ce45c..7668e18a6764 100644
--- a/lib/node_modules/@stdlib/assert/is-same-type/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-same-type/test/test.js
@@ -52,7 +52,7 @@ tape( 'the function returns `true` if provided two arguments which have the same
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isSameType( values[ i ][ 0 ], values[ i ][ 1 ] );
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'the function returns `false` if not provided two arguments having the sam
 
 	for ( i = 0; i < values.length; i++ ) {
 		bool = isSameType( values[ i ][ 0 ], values[ i ][ 1 ] );
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-sharedarraybuffer/test/test.js b/lib/node_modules/@stdlib/assert/is-sharedarraybuffer/test/test.js
index b964a2131e62..d70bf45a3c55 100644
--- a/lib/node_modules/@stdlib/assert/is-sharedarraybuffer/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-sharedarraybuffer/test/test.js
@@ -32,6 +32,7 @@ var Uint16Array = require( '@stdlib/array/uint16' );
 var Uint32Array = require( '@stdlib/array/uint32' );
 var ArrayBuffer = require( '@stdlib/array/buffer' );
 var SharedArrayBuffer = require( '@stdlib/array/shared-buffer' );
+var zeros = require( '@stdlib/array/zeros' );
 var isSharedArrayBuffer = require( './../lib' );
 
 
@@ -45,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided a SharedArrayBuffer', function test( t ) {
 	try {
-		t.strictEqual( isSharedArrayBuffer( new SharedArrayBuffer( 10 ) ), true, 'returns true' );
+		t.strictEqual( isSharedArrayBuffer( new SharedArrayBuffer( 10 ) ), true, 'returns expected value' );
 	} catch ( err ) { // eslint-disable-line no-unused-vars
 		t.pass( 'environment does not support SharedArrayBuffer' );
 	}
@@ -66,7 +67,7 @@ tape( 'the function returns `false` if not provided a SharedArrayBuffer', functi
 		[],
 		{},
 		function noop() {},
-		new Array( 10 ),
+		zeros( 10, 'generic' ),
 		new Float64Array( 10 ),
 		new Float32Array( 10 ),
 		new Uint32Array( 10 ),
diff --git a/lib/node_modules/@stdlib/assert/is-skew-centrosymmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-skew-centrosymmetric-matrix/test/test.js
index 1b6d1181d01c..d661f6f55b9e 100644
--- a/lib/node_modules/@stdlib/assert/is-skew-centrosymmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-skew-centrosymmetric-matrix/test/test.js
@@ -49,7 +49,7 @@ tape( 'the function returns `true` if provided a skew-centrosymmetric matrix (od
 	];
 	arr = ndarray( 'generic', buffer, [ 5, 5 ], [ 5, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'the function returns `true` if provided a skew-centrosymmetric matrix (ev
 	];
 	arr = ndarray( 'generic', buffer, [ 6, 6 ], [ 6, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -90,7 +90,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
@@ -100,13 +100,13 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 
 tape( 'the function returns `false` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a skew-centrosymmetric matrix (even order)', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 3, 4 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -121,7 +121,7 @@ tape( 'the function returns `false` if not provided a skew-centrosymmetric matri
 	];
 	arr = ndarray( 'generic', buffer, [ 3, 3 ], [ 3, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -140,7 +140,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -159,7 +159,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewCentrosymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
diff --git a/lib/node_modules/@stdlib/assert/is-skew-persymmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-skew-persymmetric-matrix/test/test.js
index 08bc04833509..6b96502196a1 100644
--- a/lib/node_modules/@stdlib/assert/is-skew-persymmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-skew-persymmetric-matrix/test/test.js
@@ -48,7 +48,7 @@ tape( 'the function returns `true` if provided a skew-persymmetric matrix', func
 	];
 	arr = ndarray( 'generic', buffer, [ 4, 4 ], [ 4, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isSkewPersymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewPersymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isSkewPersymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewPersymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
@@ -77,13 +77,13 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 
 tape( 'the function returns `false` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isSkewPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewPersymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a skew-persymmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 2, -1 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isSkewPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewPersymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -102,7 +102,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.strictEqual( isSkewPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewPersymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -121,7 +121,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.strictEqual( isSkewPersymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewPersymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
diff --git a/lib/node_modules/@stdlib/assert/is-skew-symmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-skew-symmetric-matrix/test/test.js
index 73cc87e0c00b..aebbf5fd3f18 100644
--- a/lib/node_modules/@stdlib/assert/is-skew-symmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-skew-symmetric-matrix/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided a skew-symmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 1, -1, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isSkewSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewSymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -55,7 +55,7 @@ tape( 'the function returns `true` if provided a skew-symmetric 2-dimensional nd
 		'set': noop
 	};
 
-	t.strictEqual( isSkewSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSkewSymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
@@ -65,13 +65,13 @@ tape( 'the function returns `true` if provided a skew-symmetric 2-dimensional nd
 
 tape( 'the function returns `false` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isSkewSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewSymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a skew-symmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 1, -1, 1 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isSkewSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewSymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -90,7 +90,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.strictEqual( isSkewSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewSymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -109,7 +109,7 @@ tape( 'the function returns `false` if not provided a skew-symmetric 2-dimension
 		'set': noop
 	};
 
-	t.strictEqual( isSkewSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSkewSymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
diff --git a/lib/node_modules/@stdlib/assert/is-slice/test/test.js b/lib/node_modules/@stdlib/assert/is-slice/test/test.js
index 0652d1b95f32..2be97512eba4 100644
--- a/lib/node_modules/@stdlib/assert/is-slice/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-slice/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a Slice instance', function test( t ) {
-	t.strictEqual( isSlice( new Slice( 0, 10, 1 ) ), true, 'returns true' );
+	t.strictEqual( isSlice( new Slice( 0, 10, 1 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-snakecase/test/test.js b/lib/node_modules/@stdlib/assert/is-snakecase/test/test.js
index 638876a1585b..1b6dd3a05bdf 100644
--- a/lib/node_modules/@stdlib/assert/is-snakecase/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-snakecase/test/test.js
@@ -51,7 +51,7 @@ tape( 'the function returns `true` if a string is in snake case', function test(
 });
 
 tape( 'the function returns `true` if provided an empty string', function test( t ) {
-	t.strictEqual( isSnakeCase( '' ), true, 'returns true' );
+	t.strictEqual( isSnakeCase( '' ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-square-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-square-matrix/test/test.js
index e447552a3e34..9379c7a89e37 100644
--- a/lib/node_modules/@stdlib/assert/is-square-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-square-matrix/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided a 2-dimensional ndarray having equal dimensions', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isSquareMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSquareMatrix( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -55,13 +55,13 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isSquareMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSquareMatrix( arr ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a 2-dimensional ndarray not having equal dimensions', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isSquareMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSquareMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -80,7 +80,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.strictEqual( isSquareMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSquareMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-square-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-square-number/test/test.main.js
index bea927f25fef..90141da253c3 100644
--- a/lib/node_modules/@stdlib/assert/is-square-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-square-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a square number', function test( t ) {
-	t.strictEqual( isSquareNumber( 4.0 ), true, 'returns true' );
-	t.strictEqual( isSquareNumber( new Number( 4.0 ) ), true, 'returns true' );
+	t.strictEqual( isSquareNumber( 4.0 ), true, 'returns expected value' );
+	t.strictEqual( isSquareNumber( new Number( 4.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-square-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-square-number/test/test.object.js
index 2f9688757e39..f7cbe4b1fd19 100644
--- a/lib/node_modules/@stdlib/assert/is-square-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-square-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a square number', function test( t ) {
-	t.strictEqual( isSquareNumber( new Number( 4.0 ) ), true, 'returns true' );
+	t.strictEqual( isSquareNumber( new Number( 4.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive square number', function test( t ) {
-	t.strictEqual( isSquareNumber( 4.0 ), false, 'returns false' );
+	t.strictEqual( isSquareNumber( 4.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-square-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-square-number/test/test.primitive.js
index aaa7765613fa..41e628c5b3d7 100644
--- a/lib/node_modules/@stdlib/assert/is-square-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-square-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive square number', function test( t ) {
-	t.strictEqual( isSquareNumber( 4.0 ), true, 'returns true' );
+	t.strictEqual( isSquareNumber( 4.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object', function test( t ) {
-	t.strictEqual( isSquareNumber( new Number( 4.0 ) ), false, 'returns false' );
+	t.strictEqual( isSquareNumber( new Number( 4.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.main.js
index 98bca5ac7ac2..c270c7e3898d 100644
--- a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a square triangular number', function test( t ) {
-	t.strictEqual( isSquareTriangularNumber( 36.0 ), true, 'returns true' );
-	t.strictEqual( isSquareTriangularNumber( new Number( 36.0 ) ), true, 'returns true' );
+	t.strictEqual( isSquareTriangularNumber( 36.0 ), true, 'returns expected value' );
+	t.strictEqual( isSquareTriangularNumber( new Number( 36.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.object.js
index f5869d4d0eb9..6bc4523e40c4 100644
--- a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a square triangular number', function test( t ) {
-	t.strictEqual( isSquareTriangularNumber( new Number( 36.0 ) ), true, 'returns true' );
+	t.strictEqual( isSquareTriangularNumber( new Number( 36.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive square triangular number', function test( t ) {
-	t.strictEqual( isSquareTriangularNumber( 36.0 ), false, 'returns false' );
+	t.strictEqual( isSquareTriangularNumber( 36.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.primitive.js
index 029cc0d3f4f0..ca08c71fa75f 100644
--- a/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-square-triangular-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive square triangular number', function test( t ) {
-	t.strictEqual( isSquareTriangularNumber( 36.0 ), true, 'returns true' );
+	t.strictEqual( isSquareTriangularNumber( 36.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object', function test( t ) {
-	t.strictEqual( isSquareTriangularNumber( new Number( 36.0 ) ), false, 'returns false' );
+	t.strictEqual( isSquareTriangularNumber( new Number( 36.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-startcase/test/test.js b/lib/node_modules/@stdlib/assert/is-startcase/test/test.js
index 4243a8a58e10..16ab553f1471 100644
--- a/lib/node_modules/@stdlib/assert/is-startcase/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-startcase/test/test.js
@@ -70,7 +70,7 @@ tape( 'the function returns `false` if provided a non-startcase string', functio
 });
 
 tape( 'the function returns `true` if provided an empty string', function test( t ) {
-	t.strictEqual( isStartcase( '' ), true, 'returns true' );
+	t.strictEqual( isStartcase( '' ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-string-array/test/test.js b/lib/node_modules/@stdlib/assert/is-string-array/test/test.js
index cb5d9b3e2ead..3b3985202000 100644
--- a/lib/node_modules/@stdlib/assert/is-string-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-string-array/test/test.js
@@ -36,10 +36,10 @@ tape( 'the function tests for an array of `string` values', function test( t ) {
 	var arr;
 
 	arr = [ 'a', new String( 'b' ) ]; // eslint-disable-line no-new-wrappers
-	t.strictEqual( isStringArray( arr ), true, 'returns true' );
+	t.strictEqual( isStringArray( arr ), true, 'returns expected value' );
 
 	arr = [ 'a', 5, null ];
-	t.strictEqual( isStringArray( arr ), false, 'returns false' );
+	t.strictEqual( isStringArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -48,10 +48,10 @@ tape( 'the function provides a method to test for an array of `string` primitive
 	var arr;
 
 	arr = [ 'a', 'b' ];
-	t.strictEqual( isStringArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isStringArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ new String( 'a' ), 'b' ]; // eslint-disable-line no-new-wrappers
-	t.strictEqual( isStringArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isStringArray.primitives( arr ), false, 'returns expected value' );
 
 	t.end();
 });
@@ -60,10 +60,10 @@ tape( 'the function provides a method to test for an array of `String` objects',
 	var arr;
 
 	arr = [ new String( 'a' ), new String( 'b' ) ]; // eslint-disable-line no-new-wrappers
-	t.strictEqual( isStringArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isStringArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ 'a', 'b' ];
-	t.strictEqual( isStringArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isStringArray.objects( arr ), false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-string/test/test.main.js b/lib/node_modules/@stdlib/assert/is-string/test/test.main.js
index 4551e138d2e8..483752853979 100644
--- a/lib/node_modules/@stdlib/assert/is-string/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-string/test/test.main.js
@@ -33,8 +33,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a string', function test( t ) {
-	t.strictEqual( isString( 'a' ), true, 'returns true' );
-	t.strictEqual( isString( new String( 'a' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isString( 'a' ), true, 'returns expected value' );
+	t.strictEqual( isString( new String( 'a' ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-string/test/test.object.js b/lib/node_modules/@stdlib/assert/is-string/test/test.object.js
index 1bd13d039a94..bb894352c631 100644
--- a/lib/node_modules/@stdlib/assert/is-string/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-string/test/test.object.js
@@ -43,12 +43,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a string object', function test( t ) {
-	t.strictEqual( isString( new String( 'a' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isString( new String( 'a' ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive string', function test( t ) {
-	t.strictEqual( isString( 'a' ), false, 'returns false' );
+	t.strictEqual( isString( 'a' ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -67,7 +67,7 @@ tape( 'if `Symbol.toStringTag` is supported, the function guards against objects
 	if ( hasToStringTag() ) {
 		mock[ Symbol.toStringTag ] = 'String';
 	}
-	t.strictEqual( isString( mock ), false, 'returns false' );
+	t.strictEqual( isString( mock ), false, 'returns expected value' );
 	t.end();
 
 	function detect() {
@@ -86,8 +86,8 @@ tape( 'if `Symbol.toStringTag` is not supported, the function attempts to determ
 		'@stdlib/assert/has-tostringtag-support': detect
 	});
 
-	t.strictEqual( isString( new String( 'a' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
-	t.strictEqual( isString( {} ), false, 'returns false' );
+	t.strictEqual( isString( new String( 'a' ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isString( {} ), false, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/assert/is-string/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-string/test/test.primitive.js
index 7bdb3726946c..7af583086993 100644
--- a/lib/node_modules/@stdlib/assert/is-string/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-string/test/test.primitive.js
@@ -33,12 +33,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive string', function test( t ) {
-	t.strictEqual( isString( 'a' ), true, 'returns true' );
+	t.strictEqual( isString( 'a' ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a string object', function test( t ) {
-	t.strictEqual( isString( new String( 'a' ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isString( new String( 'a' ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-string/test/test.try2valueof.js b/lib/node_modules/@stdlib/assert/is-string/test/test.try2valueof.js
index 31f3b3573d46..f569addac88d 100644
--- a/lib/node_modules/@stdlib/assert/is-string/test/test.try2valueof.js
+++ b/lib/node_modules/@stdlib/assert/is-string/test/test.try2valueof.js
@@ -33,12 +33,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if able to extract a string value', function test( t ) {
-	t.strictEqual( valueOf( 'a' ), true, 'returns true' );
-	t.strictEqual( valueOf( new String( 'a' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( valueOf( 'a' ), true, 'returns expected value' );
+	t.strictEqual( valueOf( new String( 'a' ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
 tape( 'the function returns `false` if unable to extract a string value', function test( t ) {
-	t.strictEqual( valueOf( {} ), false, 'returns false' );
+	t.strictEqual( valueOf( {} ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-symbol-array/test/test.js b/lib/node_modules/@stdlib/assert/is-symbol-array/test/test.js
index ac01014541c1..54c8761dc729 100644
--- a/lib/node_modules/@stdlib/assert/is-symbol-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-symbol-array/test/test.js
@@ -46,27 +46,27 @@ tape( 'the function tests for an array-like object containing only symbols (ES20
 	var arr;
 
 	arr = [ Symbol( 'a' ), Symbol( 'b' ) ];
-	t.strictEqual( isSymbolArray( arr ), true, 'returns true' );
+	t.strictEqual( isSymbolArray( arr ), true, 'returns expected value' );
 
 	arr = [ Object( Symbol( 'a' ) ), Object( Symbol( 'b' ) ) ];
-	t.strictEqual( isSymbolArray( arr ), true, 'returns true' );
+	t.strictEqual( isSymbolArray( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': Symbol( 'a' ),
 		'1': Symbol( 'b' )
 	};
-	t.strictEqual( isSymbolArray( arr ), true, 'returns true' );
+	t.strictEqual( isSymbolArray( arr ), true, 'returns expected value' );
 
 	arr = [ 'a', 5, null ];
-	t.strictEqual( isSymbolArray( arr ), false, 'returns false' );
+	t.strictEqual( isSymbolArray( arr ), false, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided an array-like object containing only symbols (all environments)', function test( t ) {
 	var arr = [ 'a', 5, null ];
-	t.strictEqual( isSymbolArray( arr ), false, 'returns false' );
+	t.strictEqual( isSymbolArray( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -74,24 +74,24 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ Symbol( 'a' ), Symbol( 'b' ) ];
-	t.strictEqual( isSymbolArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isSymbolArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': Symbol( 'a' ),
 		'1': Symbol( 'b' )
 	};
-	t.strictEqual( isSymbolArray.primitives( arr ), true, 'returns true' );
+	t.strictEqual( isSymbolArray.primitives( arr ), true, 'returns expected value' );
 
 	arr = [ Object( Symbol( 'a' ) ), Object( Symbol( 'b' ) ) ];
-	t.strictEqual( isSymbolArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isSymbolArray.primitives( arr ), false, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided an array-like object containing only `symbol` primitives (all environments; primitives)', function test( t ) {
 	var arr = [ 'a', 5, null ];
-	t.strictEqual( isSymbolArray.primitives( arr ), false, 'returns false' );
+	t.strictEqual( isSymbolArray.primitives( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -99,23 +99,23 @@ tape( 'the function provides a method to test for an array-like object containin
 	var arr;
 
 	arr = [ Symbol( 'a' ), Symbol( 'b' ) ];
-	t.strictEqual( isSymbolArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isSymbolArray.objects( arr ), false, 'returns expected value' );
 
 	arr = {
 		'length': 2,
 		'0': Object( Symbol( 'a' ) ),
 		'1': Object( Symbol( 'b' ) )
 	};
-	t.strictEqual( isSymbolArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isSymbolArray.objects( arr ), true, 'returns expected value' );
 
 	arr = [ Object( Symbol( 'a' ) ), Object( Symbol( 'b' ) ) ];
-	t.strictEqual( isSymbolArray.objects( arr ), true, 'returns true' );
+	t.strictEqual( isSymbolArray.objects( arr ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided an array-like object containing only `Symbol` objects (all environments; objects)', function test( t ) {
 	var arr = [ {}, {}, null ];
-	t.strictEqual( isSymbolArray.objects( arr ), false, 'returns false' );
+	t.strictEqual( isSymbolArray.objects( arr ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-symbol/test/test.generic.js b/lib/node_modules/@stdlib/assert/is-symbol/test/test.generic.js
index c559ee8223e7..561af73ed6f3 100644
--- a/lib/node_modules/@stdlib/assert/is-symbol/test/test.generic.js
+++ b/lib/node_modules/@stdlib/assert/is-symbol/test/test.generic.js
@@ -43,8 +43,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a symbol', opts, function test( t ) {
-	t.strictEqual( isSymbol( Symbol( 'a' ) ), true, 'returns true' );
-	t.strictEqual( isSymbol( Object( Symbol( 'a' ) ) ), true, 'returns true' );
+	t.strictEqual( isSymbol( Symbol( 'a' ) ), true, 'returns expected value' );
+	t.strictEqual( isSymbol( Object( Symbol( 'a' ) ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-symbol/test/test.object.js b/lib/node_modules/@stdlib/assert/is-symbol/test/test.object.js
index 5207924c8b01..b9d2caf9dabd 100644
--- a/lib/node_modules/@stdlib/assert/is-symbol/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-symbol/test/test.object.js
@@ -44,12 +44,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a Symbol object', opts, function test( t ) {
-	t.strictEqual( isSymbol( Object( Symbol( 'a' ) ) ), true, 'returns true' );
+	t.strictEqual( isSymbol( Object( Symbol( 'a' ) ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive symbol', opts, function test( t ) {
-	t.strictEqual( isSymbol( Symbol( 'a' ) ), false, 'returns false' );
+	t.strictEqual( isSymbol( Symbol( 'a' ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-symbol/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-symbol/test/test.primitive.js
index ec705d7ced4c..d9fff696b703 100644
--- a/lib/node_modules/@stdlib/assert/is-symbol/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-symbol/test/test.primitive.js
@@ -43,12 +43,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive symbol', opts, function test( t ) {
-	t.strictEqual( isSymbol( Symbol( 'a' ) ), true, 'returns true' );
+	t.strictEqual( isSymbol( Symbol( 'a' ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a Symbol object', opts, function test( t ) {
-	t.strictEqual( isSymbol( Object( Symbol( 'a' ) ) ), false, 'returns false' );
+	t.strictEqual( isSymbol( Object( Symbol( 'a' ) ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-symbol/test/test.try2tostring.js b/lib/node_modules/@stdlib/assert/is-symbol/test/test.try2tostring.js
index 230fac372f8a..4fb375d83697 100644
--- a/lib/node_modules/@stdlib/assert/is-symbol/test/test.try2tostring.js
+++ b/lib/node_modules/@stdlib/assert/is-symbol/test/test.try2tostring.js
@@ -68,7 +68,7 @@ tape( 'the function returns `false` if not provided a symbol', function test( t
 
 tape( 'the function returns `false` if provided an empty object without a prototype', function test( t ) {
 	var o = Object.create( null );
-	t.strictEqual( tryToString( o ), false, 'returns false' );
+	t.strictEqual( tryToString( o ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -76,7 +76,7 @@ tape( 'the function returns `false` if provided an object whose primitive value
 	var o = Object.create( null );
 	o.valueOf = valueOf;
 
-	t.strictEqual( tryToString( o ), false, 'returns false' );
+	t.strictEqual( tryToString( o ), false, 'returns expected value' );
 	t.end();
 
 	function valueOf() {
@@ -95,7 +95,7 @@ tape( 'the function returns `true` if able to successfully call a Symbol method'
 	o = Object.create( null );
 	o.valueOf = valueOf;
 
-	t.strictEqual( tryToString( o ), true, 'returns true' );
+	t.strictEqual( tryToString( o ), true, 'returns expected value' );
 	t.end();
 
 	function valueOf() {
@@ -108,7 +108,7 @@ tape( 'the function returns `true` if able to successfully call a Symbol method'
 });
 
 tape( 'if an environment supports symbols, the function returns `true`', opts, function test( t ) {
-	t.strictEqual( tryToString( Symbol( 'beep' ) ), true, 'returns true' );
-	t.strictEqual( tryToString( Object( Symbol( 'beep' ) ) ), true, 'returns true' );
+	t.strictEqual( tryToString( Symbol( 'beep' ) ), true, 'returns expected value' );
+	t.strictEqual( tryToString( Object( Symbol( 'beep' ) ) ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-symmetric-matrix/test/test.js b/lib/node_modules/@stdlib/assert/is-symmetric-matrix/test/test.js
index f93f9df7fc0c..cd25bfb4e560 100644
--- a/lib/node_modules/@stdlib/assert/is-symmetric-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-symmetric-matrix/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided a symmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 1, 1, 2 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -55,7 +55,7 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isSymmetricMatrix( arr ), true, 'returns true' );
+	t.strictEqual( isSymmetricMatrix( arr ), true, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
@@ -65,14 +65,14 @@ tape( 'the function returns `true` if provided a 2-dimensional ndarray-like obje
 
 tape( 'the function returns `false` if not provided a square matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0, 0, 0 ], [ 3, 2 ], [ 2, 1 ], 0, 'row-major' );
-	t.strictEqual( isSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a symmetric matrix', function test( t ) {
 	var arr = ndarray( 'generic', [ 1, 2, 3, 4 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
 
-	t.strictEqual( isSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -91,7 +91,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.strictEqual( isSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -110,7 +110,7 @@ tape( 'the function returns `false` if provided a 2-dimensional ndarray-like obj
 		'set': noop
 	};
 
-	t.strictEqual( isSymmetricMatrix( arr ), false, 'returns false' );
+	t.strictEqual( isSymmetricMatrix( arr ), false, 'returns expected value' );
 	t.end();
 
 	function get( i, j ) {
diff --git a/lib/node_modules/@stdlib/assert/is-syntax-error/test/test.js b/lib/node_modules/@stdlib/assert/is-syntax-error/test/test.js
index 2804c4add93e..457e15a1253d 100644
--- a/lib/node_modules/@stdlib/assert/is-syntax-error/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-syntax-error/test/test.js
@@ -72,13 +72,13 @@ tape( 'the function returns `true` if provided an object inheriting from `Syntax
 
 tape( 'the function returns `true` if provided a `SyntaxError` object from a different realm', opts, function test( t ) {
 	var error = vm.runInNewContext( 'new SyntaxError()' );
-	t.strictEqual( isSyntaxError( error ), true, 'returns true' );
+	t.strictEqual( isSyntaxError( error ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an object from a different realm which inherits from a `SyntaxError` object', opts, function test( t ) {
 	var error = vm.runInNewContext( 'function Err() { return this; }; Err.prototype = new SyntaxError(); new Err();' );
-	t.strictEqual( isSyntaxError( error ), true, 'returns true' );
+	t.strictEqual( isSyntaxError( error ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-touch-device/test/test.browser.js b/lib/node_modules/@stdlib/assert/is-touch-device/test/test.browser.js
index ab881169db99..1d50dbc05828 100644
--- a/lib/node_modules/@stdlib/assert/is-touch-device/test/test.browser.js
+++ b/lib/node_modules/@stdlib/assert/is-touch-device/test/test.browser.js
@@ -47,7 +47,7 @@ tape( 'the function returns `true` if the current environment is a touch device
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.strictEqual( isTouchDevice(), true, 'returns true' );
+	t.strictEqual( isTouchDevice(), true, 'returns expected value' );
 	t.end();
 
 	function getGlobal() {
@@ -66,7 +66,7 @@ tape( 'the function returns `false` if the current environment is a touch device
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.strictEqual( isTouchDevice(), false, 'returns false' );
+	t.strictEqual( isTouchDevice(), false, 'returns expected value' );
 	t.end();
 
 	function getGlobal() {
@@ -88,7 +88,7 @@ tape( 'the function returns `true` if the current environment is a touch device
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.strictEqual( isTouchDevice(), true, 'returns true' );
+	t.strictEqual( isTouchDevice(), true, 'returns expected value' );
 	t.end();
 
 	function getGlobal() {
@@ -110,7 +110,7 @@ tape( 'the function returns `false` if the current environment is not a touch de
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.strictEqual( isTouchDevice(), false, 'returns false' );
+	t.strictEqual( isTouchDevice(), false, 'returns expected value' );
 	t.end();
 
 	function getGlobal() {
@@ -134,7 +134,7 @@ tape( 'the function returns `true` if the current environment is a touch device
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.strictEqual( isTouchDevice(), true, 'returns true' );
+	t.strictEqual( isTouchDevice(), true, 'returns expected value' );
 	t.end();
 
 	function getGlobal() {
@@ -158,7 +158,7 @@ tape( 'the function returns `false` if the current environment is not a touch de
 		'@stdlib/assert/is-browser': true
 	});
 
-	t.strictEqual( isTouchDevice(), false, 'returns false' );
+	t.strictEqual( isTouchDevice(), false, 'returns expected value' );
 	t.end();
 
 	function getGlobal() {
@@ -171,6 +171,6 @@ tape( 'the function returns `false` if the current environment is not a browser'
 		'@stdlib/assert/is-browser': false
 	});
 
-	t.strictEqual( isTouchDevice(), false, 'returns false' );
+	t.strictEqual( isTouchDevice(), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-touch-device/test/test.main.js b/lib/node_modules/@stdlib/assert/is-touch-device/test/test.main.js
index 32601d5f907e..a972d5f07b7d 100644
--- a/lib/node_modules/@stdlib/assert/is-touch-device/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-touch-device/test/test.main.js
@@ -33,6 +33,6 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `false`', function test( t ) {
-	t.strictEqual( isTouchDevice(), false, 'returns false' );
+	t.strictEqual( isTouchDevice(), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.main.js b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.main.js
index 5e0a9e94127a..c7dc4f2a82c1 100644
--- a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.main.js
@@ -34,8 +34,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a triangular number', function test( t ) {
-	t.strictEqual( isTriangularNumber( 36.0 ), true, 'returns true' );
-	t.strictEqual( isTriangularNumber( new Number( 36.0 ) ), true, 'returns true' );
+	t.strictEqual( isTriangularNumber( 36.0 ), true, 'returns expected value' );
+	t.strictEqual( isTriangularNumber( new Number( 36.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.object.js b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.object.js
index 57fe95703092..8a4be41763e7 100644
--- a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.object.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a number object having a triangular number', function test( t ) {
-	t.strictEqual( isTriangularNumber( new Number( 36.0 ) ), true, 'returns true' );
+	t.strictEqual( isTriangularNumber( new Number( 36.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a primitive triangular number', function test( t ) {
-	t.strictEqual( isTriangularNumber( 36.0 ), false, 'returns false' );
+	t.strictEqual( isTriangularNumber( 36.0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.primitive.js
index 951c187a8678..c093c51be0a0 100644
--- a/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-triangular-number/test/test.primitive.js
@@ -34,12 +34,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a primitive triangular number', function test( t ) {
-	t.strictEqual( isTriangularNumber( 36.0 ), true, 'returns true' );
+	t.strictEqual( isTriangularNumber( 36.0 ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a number object', function test( t ) {
-	t.strictEqual( isTriangularNumber( new Number( 36.0 ) ), false, 'returns false' );
+	t.strictEqual( isTriangularNumber( new Number( 36.0 ) ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-truthy-array/test/test.js b/lib/node_modules/@stdlib/assert/is-truthy-array/test/test.js
index 49ccd9890cb0..f1facce6e2a3 100644
--- a/lib/node_modules/@stdlib/assert/is-truthy-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-truthy-array/test/test.js
@@ -38,7 +38,7 @@ tape( 'the function returns `true` if provided an array-like object containing o
 
 	arr = [ true, 5, 'beep', [], {}, isTruthyArray, new Date(), /.*/ ];
 	bool = isTruthyArray( arr );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,7 +57,7 @@ tape( 'the function returns `true` if provided an array-like object containing o
 		'5': isTruthyArray
 	};
 	bool = isTruthyArray( arr );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-truthy/test/test.js b/lib/node_modules/@stdlib/assert/is-truthy/test/test.js
index fe76461beebc..157b35231387 100644
--- a/lib/node_modules/@stdlib/assert/is-truthy/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-truthy/test/test.js
@@ -33,12 +33,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `false` if provided a "falsy" value', function test( t ) {
-	t.strictEqual( isTruthy( false ), false, 'returns false' );
-	t.strictEqual( isTruthy( '' ), false, 'returns false' );
-	t.strictEqual( isTruthy( 0 ), false, 'returns false' );
-	t.strictEqual( isTruthy( NaN ), false, 'returns false' );
-	t.strictEqual( isTruthy( null ), false, 'returns false' );
-	t.strictEqual( isTruthy( void 0 ), false, 'returns false' );
+	t.strictEqual( isTruthy( false ), false, 'returns expected value' );
+	t.strictEqual( isTruthy( '' ), false, 'returns expected value' );
+	t.strictEqual( isTruthy( 0 ), false, 'returns expected value' );
+	t.strictEqual( isTruthy( NaN ), false, 'returns expected value' );
+	t.strictEqual( isTruthy( null ), false, 'returns expected value' );
+	t.strictEqual( isTruthy( void 0 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-type-error/test/test.js b/lib/node_modules/@stdlib/assert/is-type-error/test/test.js
index 5a54fe85ee65..420e4b75f167 100644
--- a/lib/node_modules/@stdlib/assert/is-type-error/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-type-error/test/test.js
@@ -72,13 +72,13 @@ tape( 'the function returns `true` if provided an object inheriting from `TypeEr
 
 tape( 'the function returns `true` if provided a `TypeError` object from a different realm', opts, function test( t ) {
 	var error = vm.runInNewContext( 'new TypeError()' );
-	t.strictEqual( isTypeError( error ), true, 'returns true' );
+	t.strictEqual( isTypeError( error ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an object from a different realm which inherits from a `TypeError` object', opts, function test( t ) {
 	var error = vm.runInNewContext( 'function Err() { return this; }; Err.prototype = new TypeError(); new Err();' );
-	t.strictEqual( isTypeError( error ), true, 'returns true' );
+	t.strictEqual( isTypeError( error ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-typed-array-length/test/test.js b/lib/node_modules/@stdlib/assert/is-typed-array-length/test/test.js
index f78647836283..39181bc13518 100644
--- a/lib/node_modules/@stdlib/assert/is-typed-array-length/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-typed-array-length/test/test.js
@@ -34,16 +34,16 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a valid typed array length', function test( t ) {
-	t.strictEqual( isTypedArrayLength( 0 ), true, 'returns true' );
-	t.strictEqual( isTypedArrayLength( 10 ), true, 'returns true' );
-	t.strictEqual( isTypedArrayLength( MAX_LENGTH ), true, 'returns true' );
+	t.strictEqual( isTypedArrayLength( 0 ), true, 'returns expected value' );
+	t.strictEqual( isTypedArrayLength( 10 ), true, 'returns expected value' );
+	t.strictEqual( isTypedArrayLength( MAX_LENGTH ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if not provided a valid typed array length', function test( t ) {
-	t.strictEqual( isTypedArrayLength( MAX_LENGTH+1 ), false, 'returns false' );
-	t.strictEqual( isTypedArrayLength( -1 ), false, 'returns false' );
-	t.strictEqual( isTypedArrayLength( 3.14 ), false, 'returns false' );
+	t.strictEqual( isTypedArrayLength( MAX_LENGTH+1 ), false, 'returns expected value' );
+	t.strictEqual( isTypedArrayLength( -1 ), false, 'returns expected value' );
+	t.strictEqual( isTypedArrayLength( 3.14 ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-typed-array/test/test.js b/lib/node_modules/@stdlib/assert/is-typed-array/test/test.js
index 48244da70d9d..9dca92efafa1 100644
--- a/lib/node_modules/@stdlib/assert/is-typed-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-typed-array/test/test.js
@@ -154,13 +154,13 @@ tape( 'the function returns `true` if provided an object inheriting from a typed
 
 tape( 'the function returns `true` if provided a typed array from a different realm', opts, function test( t ) {
 	var arr = vm.runInNewContext( 'new Float64Array( [ 5.0, 3.0 ] )' );
-	t.strictEqual( isTypedArray( arr ), true, 'returns true' );
+	t.strictEqual( isTypedArray( arr ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an object from a different realm which inherits from a typed array', opts, function test( t ) {
 	var arr = vm.runInNewContext( 'function Arr() { return this; }; Arr.prototype = Object.create( Float64Array.prototype ); Arr.prototype.constructor = Arr; new Arr( [ 5.0, 3.0 ] );' );
-	t.strictEqual( isTypedArray( arr ), true, 'returns true' );
+	t.strictEqual( isTypedArray( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-uint16array/test/test.js b/lib/node_modules/@stdlib/assert/is-uint16array/test/test.js
index 027b4d8d4bb5..8eee969a9a63 100644
--- a/lib/node_modules/@stdlib/assert/is-uint16array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-uint16array/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a Uint16Array', function test( t ) {
-	t.strictEqual( isUint16Array( new Uint16Array( 10 ) ), true, 'returns true' );
+	t.strictEqual( isUint16Array( new Uint16Array( 10 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-uint32array/test/test.js b/lib/node_modules/@stdlib/assert/is-uint32array/test/test.js
index 2387cc5f2653..92d289b7448e 100644
--- a/lib/node_modules/@stdlib/assert/is-uint32array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-uint32array/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a Uint32Array', function test( t ) {
-	t.strictEqual( isUint32Array( new Uint32Array( 10 ) ), true, 'returns true' );
+	t.strictEqual( isUint32Array( new Uint32Array( 10 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-uint8array/test/test.js b/lib/node_modules/@stdlib/assert/is-uint8array/test/test.js
index ec7244f0e457..30f17d32bee9 100644
--- a/lib/node_modules/@stdlib/assert/is-uint8array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-uint8array/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a Uint8Array', function test( t ) {
-	t.strictEqual( isUint8Array( new Uint8Array( 10 ) ), true, 'returns true' );
+	t.strictEqual( isUint8Array( new Uint8Array( 10 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-uint8clampedarray/test/test.js b/lib/node_modules/@stdlib/assert/is-uint8clampedarray/test/test.js
index 1251ec3633fe..6fca643c404a 100644
--- a/lib/node_modules/@stdlib/assert/is-uint8clampedarray/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-uint8clampedarray/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a Uint8ClampedArray', function test( t ) {
-	t.strictEqual( isUint8ClampedArray( new Uint8ClampedArray( 10 ) ), true, 'returns true' );
+	t.strictEqual( isUint8ClampedArray( new Uint8ClampedArray( 10 ) ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-unity-probability-array/test/test.js b/lib/node_modules/@stdlib/assert/is-unity-probability-array/test/test.js
index 924d23c97182..56282e00af52 100644
--- a/lib/node_modules/@stdlib/assert/is-unity-probability-array/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-unity-probability-array/test/test.js
@@ -67,7 +67,7 @@ tape( 'the function returns `true` if provided an array of probabilities that su
 
 tape( 'the function allows a difference in sum within floating-point epsilon', function test( t ) {
 	var bool = isUnityProbabilityArray( [ 0.1, 0.2, 0.1, 0.1, 0.2, 0.2, 0.1 ] );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-uri-error/test/test.js b/lib/node_modules/@stdlib/assert/is-uri-error/test/test.js
index 5a9866548e04..73d16b4b82b1 100644
--- a/lib/node_modules/@stdlib/assert/is-uri-error/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-uri-error/test/test.js
@@ -72,13 +72,13 @@ tape( 'the function returns `true` if provided an object inheriting from `URIErr
 
 tape( 'the function returns `true` if provided a `URIError` object from a different realm', opts, function test( t ) {
 	var error = vm.runInNewContext( 'new URIError()' );
-	t.strictEqual( isURIError( error ), true, 'returns true' );
+	t.strictEqual( isURIError( error ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `true` if provided an object from a different realm which inherits from a `URIError` object', opts, function test( t ) {
 	var error = vm.runInNewContext( 'function Err() { return this; }; Err.prototype = new URIError(); new Err();' );
-	t.strictEqual( isURIError( error ), true, 'returns true' );
+	t.strictEqual( isURIError( error ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-vector-like/test/test.js b/lib/node_modules/@stdlib/assert/is-vector-like/test/test.js
index 23553b37481c..e9a258d6ce1f 100644
--- a/lib/node_modules/@stdlib/assert/is-vector-like/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-vector-like/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `true` if provided a 1-dimensional ndarray', function test( t ) {
 	var arr = ndarray( 'generic', [ 0, 0, 0, 0 ], [ 4 ], [ 1 ], 0, 'row-major' );
-	t.strictEqual( isVectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isVectorLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -55,7 +55,7 @@ tape( 'the function returns `true` if provided a 1-dimensional ndarray-like obje
 		'set': noop
 	};
 
-	t.strictEqual( isVectorLike( arr ), true, 'returns true' );
+	t.strictEqual( isVectorLike( arr ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-web-worker/test/test.main.js b/lib/node_modules/@stdlib/assert/is-web-worker/test/test.main.js
index 430766cd9e4a..3e70d969084b 100644
--- a/lib/node_modules/@stdlib/assert/is-web-worker/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-web-worker/test/test.main.js
@@ -164,7 +164,7 @@ tape( 'the function returns `true` if the runtime is a web worker', function tes
 		'./global_scope.js': true
 	});
 
-	t.strictEqual( isWebWorker(), true, 'returns true' );
+	t.strictEqual( isWebWorker(), true, 'returns expected value' );
 
 	cleanup();
 	t.end();
@@ -212,7 +212,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`WorkerG
 		'./global_scope.js': true
 	});
 
-	t.strictEqual( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns expected value' );
 
 	cleanup();
 	t.end();
@@ -262,7 +262,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`WorkerN
 		'./global_scope.js': true
 	});
 
-	t.strictEqual( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns expected value' );
 
 	cleanup();
 	t.end();
@@ -315,7 +315,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`navigat
 		'./global_scope.js': true
 	});
 
-	t.strictEqual( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns expected value' );
 
 	cleanup();
 	t.end();
@@ -365,7 +365,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`WorkerL
 		'./global_scope.js': true
 	});
 
-	t.strictEqual( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns expected value' );
 
 	cleanup();
 	t.end();
@@ -418,7 +418,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`locatio
 		'./global_scope.js': true
 	});
 
-	t.strictEqual( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns expected value' );
 
 	cleanup();
 	t.end();
@@ -468,7 +468,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`self` g
 		'./global_scope.js': true
 	});
 
-	t.strictEqual( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns expected value' );
 
 	cleanup();
 	t.end();
@@ -518,7 +518,7 @@ tape( 'the function returns `false` if the runtime is not a web worker (`self` g
 		'./global_scope.js': false
 	});
 
-	t.strictEqual( isWebWorker(), false, 'returns false' );
+	t.strictEqual( isWebWorker(), false, 'returns expected value' );
 
 	cleanup();
 	t.end();
diff --git a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.main.js b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.main.js
index ad2ffdfdf5dd..52d4fd9ecbd4 100644
--- a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.main.js
@@ -33,8 +33,8 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a well-formed string', function test( t ) {
-	t.strictEqual( isWellFormedString( '' ), true, 'returns true' );
-	t.strictEqual( isWellFormedString( new String( '' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isWellFormedString( '' ), true, 'returns expected value' );
+	t.strictEqual( isWellFormedString( new String( '' ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.object.js b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.object.js
index 2bf35defb3e1..0f9ebc30cc52 100644
--- a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.object.js
+++ b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.object.js
@@ -33,12 +33,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a well-formed string object', function test( t ) {
-	t.strictEqual( isWellFormedString( new String( '' ) ), true, 'returns true' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isWellFormedString( new String( '' ) ), true, 'returns expected value' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a string primitive, even if it is well-formed', function test( t ) {
-	t.strictEqual( isWellFormedString( '' ), false, 'returns false' );
+	t.strictEqual( isWellFormedString( '' ), false, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.primitive.js b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.primitive.js
index 5656c6b3df1d..5455a7205f5f 100644
--- a/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-well-formed-string/test/test.primitive.js
@@ -33,12 +33,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns `true` if provided a well-formed string primitive', function test( t ) {
-	t.strictEqual( isWellFormedString( '' ), true, 'returns true' );
+	t.strictEqual( isWellFormedString( '' ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a string object, even if the string is well-formed', function test( t ) {
-	t.strictEqual( isWellFormedString( new String( '' ) ), false, 'returns false' ); // eslint-disable-line no-new-wrappers
+	t.strictEqual( isWellFormedString( new String( '' ) ), false, 'returns expected value' ); // eslint-disable-line no-new-wrappers
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/assert/is-writable-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-writable-property-in/test/test.js
index c1ef027b81b0..f8fb0ba8cb90 100644
--- a/lib/node_modules/@stdlib/assert/is-writable-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-writable-property-in/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property is writable', function
 		'a': 'b'
 	};
 	bool = isWritablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isWritablePropertyIn( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isWritablePropertyIn( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isWritablePropertyIn( new Foo(), 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isWritablePropertyIn( [ 'a' ], 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property is writable', function
 	});
 
 	bool = isWritablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -79,7 +79,7 @@ tape( 'the function returns `true` if an object property is writable', function
 	});
 
 	bool = isWritablePropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -92,13 +92,13 @@ tape( 'the function returns `true` if provided a writable inherited property', f
 	var bool;
 
 	bool = isWritablePropertyIn( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isWritablePropertyIn( {}, 'constructor' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isWritablePropertyIn( {}, 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isWritablePropertyIn( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isWritablePropertyIn( 'beep', 'toString' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-writable-property/test/test.js b/lib/node_modules/@stdlib/assert/is-writable-property/test/test.js
index 002433e3385d..0a4ec2337d78 100644
--- a/lib/node_modules/@stdlib/assert/is-writable-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-writable-property/test/test.js
@@ -46,19 +46,19 @@ tape( 'the function returns `true` if an object property is writable', function
 		'a': 'b'
 	};
 	bool = isWritableProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isWritableProperty( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isWritableProperty( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isWritableProperty( new Foo(), 'bar' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isWritableProperty( [ 'a' ], 'length' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -69,7 +69,7 @@ tape( 'the function returns `true` if an object property is writable', function
 	});
 
 	bool = isWritableProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -79,7 +79,7 @@ tape( 'the function returns `true` if an object property is writable', function
 	});
 
 	bool = isWritableProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -109,7 +109,7 @@ tape( 'the function returns `false` if provided a property argument which does n
 	};
 
 	bool = isWritableProperty( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -118,13 +118,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isWritableProperty( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWritableProperty( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWritableProperty( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -133,7 +133,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isWritableProperty( 'beep', 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-write-only-property-in/test/test.js b/lib/node_modules/@stdlib/assert/is-write-only-property-in/test/test.js
index a99bbd1e5937..cfee2549e316 100644
--- a/lib/node_modules/@stdlib/assert/is-write-only-property-in/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-write-only-property-in/test/test.js
@@ -52,10 +52,10 @@ tape( 'the function returns `true` if an object property is write-only', functio
 	});
 
 	bool = isWriteOnlyPropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isWriteOnlyPropertyIn( obj, 'b' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -87,10 +87,10 @@ tape( 'the function returns `true` if an inherited object property is write-only
 	obj = new Foo();
 
 	bool = isWriteOnlyPropertyIn( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isWriteOnlyPropertyIn( obj, 'b' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -112,19 +112,19 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 		'a': 'b'
 	};
 	bool = isWriteOnlyPropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyPropertyIn( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyPropertyIn( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyPropertyIn( new Foo(), 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyPropertyIn( [ 'a' ], 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -135,7 +135,7 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 	});
 
 	bool = isWriteOnlyPropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -146,7 +146,7 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 	});
 
 	bool = isWriteOnlyPropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -156,7 +156,7 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 	});
 
 	bool = isWriteOnlyPropertyIn( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -210,16 +210,16 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isWriteOnlyPropertyIn( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyPropertyIn( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyPropertyIn( obj, 'e' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyPropertyIn( obj, 'f' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -236,13 +236,13 @@ tape( 'the function returns `false` if provided an inherited property which is n
 	var bool;
 
 	bool = isWriteOnlyPropertyIn( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyPropertyIn( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyPropertyIn( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -251,7 +251,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isWriteOnlyPropertyIn( 'beep', 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/is-write-only-property/test/test.js b/lib/node_modules/@stdlib/assert/is-write-only-property/test/test.js
index 95e90c25f92d..f851da6e5d17 100644
--- a/lib/node_modules/@stdlib/assert/is-write-only-property/test/test.js
+++ b/lib/node_modules/@stdlib/assert/is-write-only-property/test/test.js
@@ -52,10 +52,10 @@ tape( 'the function returns `true` if an object property is write-only', functio
 	});
 
 	bool = isWriteOnlyProperty( obj, 'a' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = isWriteOnlyProperty( obj, 'b' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 
@@ -77,19 +77,19 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 		'a': 'b'
 	};
 	bool = isWriteOnlyProperty( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyProperty( [ 1, 2, 3 ], '1' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyProperty( [ 1, 2, 3 ], 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyProperty( new Foo(), 'bar' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyProperty( [ 'a' ], 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -100,7 +100,7 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 	});
 
 	bool = isWriteOnlyProperty( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -111,7 +111,7 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 	});
 
 	bool = isWriteOnlyProperty( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	obj = {};
 	defineProperty( obj, 'a', {
@@ -121,7 +121,7 @@ tape( 'the function returns `false` if an object property is not write-only', fu
 	});
 
 	bool = isWriteOnlyProperty( obj, 'a' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -175,16 +175,16 @@ tape( 'the function returns `false` if provided a property argument which does n
 	});
 
 	bool = isWriteOnlyProperty( obj, 'c' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyProperty( obj, 'd' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyProperty( obj, 'e' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyProperty( obj, 'f' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 
@@ -201,13 +201,13 @@ tape( 'the function returns `false` if provided an inherited property', function
 	var bool;
 
 	bool = isWriteOnlyProperty( {}, 'hasOwnProperty' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyProperty( {}, 'toString' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = isWriteOnlyProperty( {}, 'constructor' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -216,7 +216,7 @@ tape( 'values are coerced to objects', function test( t ) {
 	var bool;
 
 	bool = isWriteOnlyProperty( 'beep', 'length' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/tools/array-function/test/test.js b/lib/node_modules/@stdlib/assert/tools/array-function/test/test.js
index c00988601cc1..f1647640b401 100644
--- a/lib/node_modules/@stdlib/assert/tools/array-function/test/test.js
+++ b/lib/node_modules/@stdlib/assert/tools/array-function/test/test.js
@@ -110,7 +110,7 @@ tape( 'the function returns a function which returns `false` if not supplied an
 	f = arrayfcn( isEven );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( f( values[ i ] ), false, 'returns false' );
+		t.strictEqual( f( values[ i ] ), false, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/tools/array-like-function/test/test.js b/lib/node_modules/@stdlib/assert/tools/array-like-function/test/test.js
index 94b4b5965f63..4381d580c120 100644
--- a/lib/node_modules/@stdlib/assert/tools/array-like-function/test/test.js
+++ b/lib/node_modules/@stdlib/assert/tools/array-like-function/test/test.js
@@ -117,7 +117,7 @@ tape( 'the function returns a function which returns `false` if not supplied an
 	f = arraylikefcn( isEven );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( f( values[ i ] ), false, 'returns false' );
+		t.strictEqual( f( values[ i ] ), false, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/assert/tools/typed-array-function/test/test.js b/lib/node_modules/@stdlib/assert/tools/typed-array-function/test/test.js
index b7111ae96c42..1852f97a99f7 100644
--- a/lib/node_modules/@stdlib/assert/tools/typed-array-function/test/test.js
+++ b/lib/node_modules/@stdlib/assert/tools/typed-array-function/test/test.js
@@ -113,7 +113,7 @@ tape( 'the function returns a function which returns `false` if not supplied a t
 	f = typedarrayfcn( isEven );
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( f( values[ i ] ), false, 'returns false' );
+		t.strictEqual( f( values[ i ] ), false, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/buffer/alloc-unsafe/test/test.js b/lib/node_modules/@stdlib/buffer/alloc-unsafe/test/test.js
index 3a1820d3e73c..b2995db44093 100644
--- a/lib/node_modules/@stdlib/buffer/alloc-unsafe/test/test.js
+++ b/lib/node_modules/@stdlib/buffer/alloc-unsafe/test/test.js
@@ -85,7 +85,7 @@ tape( 'the function throws an error if not provided a nonnegative integer', func
 
 tape( 'the function (unsafely) allocates a buffer having a specified number of bytes', function test( t ) {
 	var buf = allocUnsafe( 1000 );
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 1000, 'has expected length' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/buffer/alloc-unsafe/test/test.main.js b/lib/node_modules/@stdlib/buffer/alloc-unsafe/test/test.main.js
index 916c5ad93b54..3bcced3db256 100644
--- a/lib/node_modules/@stdlib/buffer/alloc-unsafe/test/test.main.js
+++ b/lib/node_modules/@stdlib/buffer/alloc-unsafe/test/test.main.js
@@ -75,7 +75,7 @@ tape( 'the function throws an error if not provided a nonnegative integer', func
 
 tape( 'the function (unsafely) allocates a buffer having a specified number of bytes', opts, function test( t ) {
 	var buf = allocUnsafe( 1000 );
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 1000, 'has expected length' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/buffer/alloc-unsafe/test/test.polyfill.js b/lib/node_modules/@stdlib/buffer/alloc-unsafe/test/test.polyfill.js
index 7a461012c3e6..3a6a84778c8f 100644
--- a/lib/node_modules/@stdlib/buffer/alloc-unsafe/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/buffer/alloc-unsafe/test/test.polyfill.js
@@ -66,7 +66,7 @@ tape( 'the function throws an error if not provided a nonnegative integer', func
 
 tape( 'the function (unsafely) allocates a buffer having a specified number of bytes', function test( t ) {
 	var buf = allocUnsafe( 1000 );
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 1000, 'has expected length' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/buffer/from-array/test/test.js b/lib/node_modules/@stdlib/buffer/from-array/test/test.js
index ab112adc1616..436790d67b0b 100644
--- a/lib/node_modules/@stdlib/buffer/from-array/test/test.js
+++ b/lib/node_modules/@stdlib/buffer/from-array/test/test.js
@@ -93,7 +93,7 @@ tape( 'the function allocates a buffer using an octet array (array)', function t
 	arr = [ 1, 2, 3, 4 ];
 	buf = array2buffer( arr );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 
 	for ( i = 0; i < arr.length; i++ ) {
 		t.strictEqual( buf[ i ], arr[ i ], 'returns expected value for element ' + i );
@@ -109,7 +109,7 @@ tape( 'the function allocates a buffer using an octet array (typed array)', func
 	arr = new Uint8Array( [ 1, 2, 3, 4 ] );
 	buf = array2buffer( arr );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 
 	for ( i = 0; i < arr.length; i++ ) {
 		t.strictEqual( buf[ i ], arr[ i ], 'returns expected value for element ' + i );
@@ -131,7 +131,7 @@ tape( 'the function allocates a buffer using an octet array (array-like)', funct
 	};
 	buf = array2buffer( arr );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 
 	for ( i = 0; i < arr.length; i++ ) {
 		t.strictEqual( buf[ i ], arr[ i ], 'returns expected value for element ' + i );
@@ -141,7 +141,7 @@ tape( 'the function allocates a buffer using an octet array (array-like)', funct
 
 tape( 'if provided an empty array, the function returns an empty buffer', function test( t ) {
 	var buf = array2buffer( [] );
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 0, 'has expected length' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/buffer/from-array/test/test.main.js b/lib/node_modules/@stdlib/buffer/from-array/test/test.main.js
index ad45c98ac394..90b8f65cc889 100644
--- a/lib/node_modules/@stdlib/buffer/from-array/test/test.main.js
+++ b/lib/node_modules/@stdlib/buffer/from-array/test/test.main.js
@@ -82,7 +82,7 @@ tape( 'the function allocates a buffer using an octet array (array)', opts, func
 	arr = [ 1, 2, 3, 4 ];
 	buf = array2buffer( arr );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 
 	for ( i = 0; i < arr.length; i++ ) {
 		t.strictEqual( buf[ i ], arr[ i ], 'returns expected value for element ' + i );
@@ -98,7 +98,7 @@ tape( 'the function allocates a buffer using an octet array (typed array)', opts
 	arr = new Uint8Array( [ 1, 2, 3, 4 ] );
 	buf = array2buffer( arr );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 
 	for ( i = 0; i < arr.length; i++ ) {
 		t.strictEqual( buf[ i ], arr[ i ], 'returns expected value for element ' + i );
@@ -120,7 +120,7 @@ tape( 'the function allocates a buffer using an octet array (array-like)', opts,
 	};
 	buf = array2buffer( arr );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 
 	for ( i = 0; i < arr.length; i++ ) {
 		t.strictEqual( buf[ i ], arr[ i ], 'returns expected value for element ' + i );
@@ -130,7 +130,7 @@ tape( 'the function allocates a buffer using an octet array (array-like)', opts,
 
 tape( 'if provided an empty array, the function returns an empty buffer', opts, function test( t ) {
 	var buf = array2buffer( [] );
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 0, 'has expected length' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/buffer/from-array/test/test.polyfill.js b/lib/node_modules/@stdlib/buffer/from-array/test/test.polyfill.js
index de15a931a170..054b29814b21 100644
--- a/lib/node_modules/@stdlib/buffer/from-array/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/buffer/from-array/test/test.polyfill.js
@@ -74,7 +74,7 @@ tape( 'the function allocates a buffer using an octet array (array)', function t
 	arr = [ 1, 2, 3, 4 ];
 	buf = array2buffer( arr );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 
 	for ( i = 0; i < arr.length; i++ ) {
 		t.strictEqual( buf[ i ], arr[ i ], 'returns expected value for element ' + i );
@@ -90,7 +90,7 @@ tape( 'the function allocates a buffer using an octet array (typed array)', func
 	arr = new Uint8Array( [ 1, 2, 3, 4 ] );
 	buf = array2buffer( arr );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 
 	for ( i = 0; i < arr.length; i++ ) {
 		t.strictEqual( buf[ i ], arr[ i ], 'returns expected value for element ' + i );
@@ -112,7 +112,7 @@ tape( 'the function allocates a buffer using an octet array (array-like)', funct
 	};
 	buf = array2buffer( arr );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 
 	for ( i = 0; i < arr.length; i++ ) {
 		t.strictEqual( buf[ i ], arr[ i ], 'returns expected value for element ' + i );
@@ -122,7 +122,7 @@ tape( 'the function allocates a buffer using an octet array (array-like)', funct
 
 tape( 'if provided an empty array, the function returns an empty buffer', function test( t ) {
 	var buf = array2buffer( [] );
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 0, 'has expected length' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/buffer/from-arraybuffer/test/test.js b/lib/node_modules/@stdlib/buffer/from-arraybuffer/test/test.js
index 6b3e5a12490d..e5bf966adf06 100644
--- a/lib/node_modules/@stdlib/buffer/from-arraybuffer/test/test.js
+++ b/lib/node_modules/@stdlib/buffer/from-arraybuffer/test/test.js
@@ -327,7 +327,7 @@ tape( 'the function allocates a buffer from an ArrayBuffer', opts, function test
 	ab = new ArrayBuffer( 10 );
 	buf = arraybuffer2buffer( ab );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, ab.byteLength, 'has expected length' );
 
 	t.end();
@@ -347,7 +347,7 @@ tape( 'the function supports specifying a byte offset to indicate the index of t
 	}
 	buf = arraybuffer2buffer( ab, 2 );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 8, 'has expected length' );
 
 	expected = [ 2, 3, 4, 5, 6, 7, 8, 9 ];
@@ -371,7 +371,7 @@ tape( 'the function supports specifying a length to indicate the number of buffe
 	}
 	buf = arraybuffer2buffer( ab, 2, 4 );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 4, 'has expected length' );
 
 	expected = [ 2, 3, 4, 5 ];
@@ -383,7 +383,7 @@ tape( 'the function supports specifying a length to indicate the number of buffe
 
 tape( 'if provided an empty ArrayBuffer, the function returns an empty buffer', opts, function test( t ) {
 	var buf = arraybuffer2buffer( new ArrayBuffer( 0 ) );
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 0, 'has expected length' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/buffer/from-arraybuffer/test/test.main.js b/lib/node_modules/@stdlib/buffer/from-arraybuffer/test/test.main.js
index 38a279fb5c74..a6d2a21c63b4 100644
--- a/lib/node_modules/@stdlib/buffer/from-arraybuffer/test/test.main.js
+++ b/lib/node_modules/@stdlib/buffer/from-arraybuffer/test/test.main.js
@@ -314,7 +314,7 @@ tape( 'the function allocates a buffer from an ArrayBuffer', opts, function test
 	ab = new ArrayBuffer( 10 );
 	buf = arraybuffer2buffer( ab );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, ab.byteLength, 'has expected length' );
 	t.strictEqual( ArrayBuffer.isView( buf ), true, 'is a typed array view' );
 	t.strictEqual( buf.buffer, ab, 'is a view' );
@@ -336,7 +336,7 @@ tape( 'the function supports specifying a byte offset to indicate the index of t
 	}
 	buf = arraybuffer2buffer( ab, 2 );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 8, 'has expected length' );
 	t.strictEqual( ArrayBuffer.isView( buf ), true, 'is a typed array view' );
 	t.strictEqual( buf.buffer, ab, 'is a view' );
@@ -362,7 +362,7 @@ tape( 'the function supports specifying a length to indicate the number of buffe
 	}
 	buf = arraybuffer2buffer( ab, 2, 4 );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 4, 'has expected length' );
 	t.strictEqual( ArrayBuffer.isView( buf ), true, 'is a typed array view' );
 	t.strictEqual( buf.buffer, ab, 'is a view' );
@@ -381,7 +381,7 @@ tape( 'if provided an empty ArrayBuffer, the function returns an empty buffer',
 	ab = new ArrayBuffer( 0 );
 	buf = arraybuffer2buffer( ab );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 0, 'has expected length' );
 	t.strictEqual( ArrayBuffer.isView( buf ), true, 'is a typed array view' );
 
@@ -405,7 +405,7 @@ tape( 'if provided an empty ArrayBuffer, the function returns an empty buffer (N
 	ab = new ArrayBuffer( 0 );
 	buf = arraybuffer2buffer( ab );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 0, 'has expected length' );
 	t.strictEqual( ArrayBuffer.isView( buf ), true, 'is a typed array view' );
 	t.notEqual( buf.buffer, ab, 'is not a view' );
diff --git a/lib/node_modules/@stdlib/buffer/from-arraybuffer/test/test.polyfill.js b/lib/node_modules/@stdlib/buffer/from-arraybuffer/test/test.polyfill.js
index b74186370957..cc26a1d33e67 100644
--- a/lib/node_modules/@stdlib/buffer/from-arraybuffer/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/buffer/from-arraybuffer/test/test.polyfill.js
@@ -310,7 +310,7 @@ tape( 'the function allocates a buffer from an ArrayBuffer', opts, function test
 	ab = new ArrayBuffer( 10 );
 	buf = arraybuffer2buffer( ab );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, ab.byteLength, 'has expected length' );
 
 	t.end();
@@ -328,7 +328,7 @@ tape( 'the function allocates a buffer from an ArrayBuffer (Node <v3.0.0)', opts
 	ab = new ArrayBuffer( 10 );
 	buf = arraybuffer2buffer( ab );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, ab.byteLength, 'has expected length' );
 	t.notEqual( buf.buffer, ab, 'is a not view' );
 
@@ -347,7 +347,7 @@ tape( 'the function allocates a buffer from an ArrayBuffer (Node >=v3.0.0)', opt
 	ab = new ArrayBuffer( 10 );
 	buf = arraybuffer2buffer( ab );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	if ( version > 0 ) {
 		t.strictEqual( buf.length, ab.byteLength, 'has expected length' );
 		t.strictEqual( buf.buffer, ab, 'is a view' );
@@ -371,7 +371,7 @@ tape( 'the function supports specifying a byte offset to indicate the index of t
 	}
 	buf = arraybuffer2buffer( ab, 2 );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 8, 'has expected length' );
 	t.notEqual( buf.buffer, ab, 'is not a view' );
 
@@ -396,7 +396,7 @@ tape( 'the function supports specifying a length to indicate the number of buffe
 	}
 	buf = arraybuffer2buffer( ab, 2, 4 );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 4, 'has expected length' );
 	t.notEqual( buf.buffer, ab, 'is not a view' );
 
@@ -414,7 +414,7 @@ tape( 'if provided an empty ArrayBuffer, the function returns an empty buffer',
 	ab = new ArrayBuffer( 0 );
 	buf = arraybuffer2buffer( ab );
 
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 0, 'has expected length' );
 	t.notEqual( buf.buffer, ab, 'is not a view' );
 
diff --git a/lib/node_modules/@stdlib/buffer/from-string/test/test.js b/lib/node_modules/@stdlib/buffer/from-string/test/test.js
index a7834d5b800a..4c9d7eea255c 100644
--- a/lib/node_modules/@stdlib/buffer/from-string/test/test.js
+++ b/lib/node_modules/@stdlib/buffer/from-string/test/test.js
@@ -144,7 +144,7 @@ tape( 'the function throws an error if not provided a valid encoding argument',
 
 tape( 'the function allocates a buffer containing a provided string', function test( t ) {
 	var buf = string2buffer( 'beep boop' );
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 9, 'has expected length' );
 	t.strictEqual( buf.toString(), 'beep boop', 'returns expected value' );
 	t.end();
@@ -152,7 +152,7 @@ tape( 'the function allocates a buffer containing a provided string', function t
 
 tape( 'the function allocates a buffer containing a provided string (encoding)', function test( t ) {
 	var buf = string2buffer( '7468697320697320612074c3a97374', 'hex' );
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 15, 'has expected length' );
 	t.strictEqual( buf.toString(), 'this is a tést', 'returns expected value' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/buffer/from-string/test/test.main.js b/lib/node_modules/@stdlib/buffer/from-string/test/test.main.js
index f98b3c2eaa44..c2903582bfc3 100644
--- a/lib/node_modules/@stdlib/buffer/from-string/test/test.main.js
+++ b/lib/node_modules/@stdlib/buffer/from-string/test/test.main.js
@@ -134,7 +134,7 @@ tape( 'the function throws an error if not provided a valid encoding argument',
 
 tape( 'the function allocates a buffer containing a provided string', opts, function test( t ) {
 	var buf = string2buffer( 'beep boop' );
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 9, 'has expected length' );
 	t.strictEqual( buf.toString(), 'beep boop', 'returns expected value' );
 	t.end();
@@ -142,7 +142,7 @@ tape( 'the function allocates a buffer containing a provided string', opts, func
 
 tape( 'the function allocates a buffer containing a provided string (encoding)', opts, function test( t ) {
 	var buf = string2buffer( '7468697320697320612074c3a97374', 'hex' );
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 15, 'has expected length' );
 	t.strictEqual( buf.toString(), 'this is a tést', 'returns expected value' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/buffer/from-string/test/test.polyfill.js b/lib/node_modules/@stdlib/buffer/from-string/test/test.polyfill.js
index 435efba684ba..62db4eb604c0 100644
--- a/lib/node_modules/@stdlib/buffer/from-string/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/buffer/from-string/test/test.polyfill.js
@@ -125,7 +125,7 @@ tape( 'the function throws an error if not provided a valid encoding argument',
 
 tape( 'the function allocates a buffer containing a provided string', function test( t ) {
 	var buf = string2buffer( 'beep boop' );
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 9, 'has expected length' );
 	t.strictEqual( buf.toString(), 'beep boop', 'returns expected value' );
 	t.end();
@@ -133,7 +133,7 @@ tape( 'the function allocates a buffer containing a provided string', function t
 
 tape( 'the function allocates a buffer containing a provided string (encoding)', function test( t ) {
 	var buf = string2buffer( '7468697320697320612074c3a97374', 'hex' );
-	t.strictEqual( isBuffer( buf ), true, 'returns a buffer' );
+	t.strictEqual( isBuffer( buf ), true, 'returns expected value' );
 	t.strictEqual( buf.length, 15, 'has expected length' );
 	t.strictEqual( buf.toString(), 'this is a tést', 'returns expected value' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.re_filename.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.re_filename.js
index 0163bc92336f..af164dba2ec7 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.re_filename.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.re_filename.js
@@ -37,16 +37,16 @@ tape( 'the regular expression can be used to test for file name convention for n
 	var bool;
 
 	bool = RE.test( 'beep.txt' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = RE.test( 'beep.json' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = RE.test( '2008_barack_obama_d.json' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = RE.test( '2008_barack_obama_d.txt' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/error/tools/fmtprodmsg/test/test.js b/lib/node_modules/@stdlib/error/tools/fmtprodmsg/test/test.js
index 77612b5edf4d..3168acf3f549 100644
--- a/lib/node_modules/@stdlib/error/tools/fmtprodmsg/test/test.js
+++ b/lib/node_modules/@stdlib/error/tools/fmtprodmsg/test/test.js
@@ -37,6 +37,6 @@ tape( 'the function returns a formatted error message', function test( t ) {
 
 	actual = fmtprodmsg( 'foo' );
 
-	t.strictEqual( typeof actual, 'string', 'returns a string' );
+	t.strictEqual( typeof actual, 'string', 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/error/tools/id2msg/test/test.js b/lib/node_modules/@stdlib/error/tools/id2msg/test/test.js
index 37272418a5fc..3d6d88dc6f63 100644
--- a/lib/node_modules/@stdlib/error/tools/id2msg/test/test.js
+++ b/lib/node_modules/@stdlib/error/tools/id2msg/test/test.js
@@ -74,7 +74,7 @@ tape( 'the function returns an error message', function test( t ) {
 	];
 	for ( i = 0; i < list.length; i++ ) {
 		actual = id2msg( list[ i ] );
-		t.strictEqual( typeof actual, 'string', 'returns a string' );
+		t.strictEqual( typeof actual, 'string', 'returns expected value' );
 		t.strictEqual( msg2id( actual ), list[ i ], 'returns expected value' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/error/tools/id2pkg/test/test.js b/lib/node_modules/@stdlib/error/tools/id2pkg/test/test.js
index 103780dba36f..638bfa581654 100644
--- a/lib/node_modules/@stdlib/error/tools/id2pkg/test/test.js
+++ b/lib/node_modules/@stdlib/error/tools/id2pkg/test/test.js
@@ -75,7 +75,7 @@ tape( 'the function returns a package name', function test( t ) {
 	for ( i = 0; i < list.length; i++ ) {
 		expected = list[ i ];
 		actual = id2pkg( pkg2id( list[ i ] ) );
-		t.strictEqual( typeof actual, 'string', 'returns a string' );
+		t.strictEqual( typeof actual, 'string', 'returns expected value' );
 		t.strictEqual( actual, expected, 'returns expected value' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/error/tools/msg2id/test/test.js b/lib/node_modules/@stdlib/error/tools/msg2id/test/test.js
index 5ec2aec28f43..d01039458bc6 100644
--- a/lib/node_modules/@stdlib/error/tools/msg2id/test/test.js
+++ b/lib/node_modules/@stdlib/error/tools/msg2id/test/test.js
@@ -71,7 +71,7 @@ tape( 'the function returns a two-character error identifier', function test( t
 	];
 	for ( i = 0; i < list.length; i++ ) {
 		actual = msg2id( list[ i ] );
-		t.strictEqual( typeof actual, 'string', 'returns a string' );
+		t.strictEqual( typeof actual, 'string', 'returns expected value' );
 		t.strictEqual( actual.length, 2, 'returns a two-character string' );
 		t.strictEqual( id2msg( actual ), list[ i ], 'returns expected value' );
 	}
diff --git a/lib/node_modules/@stdlib/error/tools/pkg2id/test/test.js b/lib/node_modules/@stdlib/error/tools/pkg2id/test/test.js
index 125ac60f162a..eb01a99eb5d6 100644
--- a/lib/node_modules/@stdlib/error/tools/pkg2id/test/test.js
+++ b/lib/node_modules/@stdlib/error/tools/pkg2id/test/test.js
@@ -79,7 +79,7 @@ tape( 'the function returns a three-character identifier containing letters and
 	for ( i = 0; i < PKG_LIST.length; i++ ) {
 		pkg = replace( PKG_LIST[ i ], '-', '/' );
 		actual = pkg2id( pkg );
-		t.strictEqual( typeof actual, 'string', 'returns a string' );
+		t.strictEqual( typeof actual, 'string', 'returns expected value' );
 		t.strictEqual( actual.length, 3, 'returns a three-character string' );
 		t.ok( actual.match( RE_ID_FORMAT ), 'returns a string containing only letters and digits' );
 	}
@@ -94,7 +94,7 @@ tape( 'the function returns a three-character identifier containing letters and
 	for ( i = 0; i < PKG_LIST.length; i++ ) {
 		pkg = PKG_LIST[ i ];
 		actual = pkg2id( pkg );
-		t.strictEqual( typeof actual, 'string', 'returns a string' );
+		t.strictEqual( typeof actual, 'string', 'returns expected value' );
 		t.strictEqual( actual.length, 3, 'returns a three-character string' );
 		t.ok( actual.match( RE_ID_FORMAT ), 'returns a string containing only letters and digits' );
 	}
diff --git a/lib/node_modules/@stdlib/fs/exists/test/test.async.js b/lib/node_modules/@stdlib/fs/exists/test/test.async.js
index 7def4e2287f8..ea51ec568216 100644
--- a/lib/node_modules/@stdlib/fs/exists/test/test.async.js
+++ b/lib/node_modules/@stdlib/fs/exists/test/test.async.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns true if a path exists', opts, function test( t ) {
 	exists( __filename, onExists );
 	function onExists( bool ) {
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -54,7 +54,7 @@ tape( 'the function returns true if a path exists', opts, function test( t ) {
 tape( 'the function returns false if a path does not exist', opts, function test( t ) {
 	exists( 'beepboopbebop', onExists );
 	function onExists( bool ) {
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -68,7 +68,7 @@ tape( 'if `fs.access` is not supported, the function uses `fs.stat`', opts, func
 	});
 	exists( __filename, onExists );
 	function onExists( bool ) {
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -82,7 +82,7 @@ tape( 'if `fs.access` is not supported, the function uses `fs.stat`', opts, func
 	});
 	exists( 'beepboopbebop', onExists );
 	function onExists( bool ) {
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -91,7 +91,7 @@ tape( 'the function supports error-first callbacks (success)', opts, function te
 	exists( __filename, onExists );
 	function onExists( error, bool ) {
 		t.strictEqual( error, null, 'error is null' );
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -100,7 +100,7 @@ tape( 'the function supports error-first callbacks (failure)', opts, function te
 	exists( 'beepboopbebop', onExists );
 	function onExists( error, bool ) {
 		t.ok( error, 'returns an error' );
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -115,7 +115,7 @@ tape( 'the function supports using `fs.stat` with error-first callbacks (success
 	exists( __filename, onExists );
 	function onExists( error, bool ) {
 		t.strictEqual( error, null, 'error is null' );
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -130,7 +130,7 @@ tape( 'the function supports using `fs.stat` with error-first callbacks (failure
 	exists( 'beepboopbebop', onExists );
 	function onExists( error, bool ) {
 		t.ok( error, 'returns an error' );
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/fs/exists/test/test.sync.js b/lib/node_modules/@stdlib/fs/exists/test/test.sync.js
index 977717f7dd10..655f3bcbfc3f 100644
--- a/lib/node_modules/@stdlib/fs/exists/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/exists/test/test.sync.js
@@ -44,12 +44,12 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns true if a path exists', opts, function test( t ) {
-	t.strictEqual( exists( __filename ), true, 'returns true' );
+	t.strictEqual( exists( __filename ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns false if a path does not exists', opts, function test( t ) {
-	t.strictEqual( exists( 'beepboopbebop' ), false, 'returns false' );
+	t.strictEqual( exists( 'beepboopbebop' ), false, 'returns expected value' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'if `fs.access` is not supported, the function uses `fs.statSync`', opts,
 			'accessSync': void 0
 		}
 	});
-	t.strictEqual( exists( __filename ), true, 'returns true' );
+	t.strictEqual( exists( __filename ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -71,6 +71,6 @@ tape( 'the function should negatively test using `statSync`', opts, function tes
 			'accessSync': void 0
 		}
 	});
-	t.strictEqual( exists( 'beepboopbebop' ), false, 'returns false' );
+	t.strictEqual( exists( 'beepboopbebop' ), false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/any/test/test.js b/lib/node_modules/@stdlib/iter/any/test/test.js
index 8d3b3e14a8e7..23c0c6b5b6d4 100644
--- a/lib/node_modules/@stdlib/iter/any/test/test.js
+++ b/lib/node_modules/@stdlib/iter/any/test/test.js
@@ -69,7 +69,7 @@ tape( 'if provided an "empty" iterator, the function returns `false`', function
 	arr = array2iterator( [] );
 	bool = iterAny( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -80,7 +80,7 @@ tape( 'the function returns `true` if at least one iterated value is truthy', fu
 	arr = array2iterator( [ 0, 0, 0, 0, 1 ] );
 	bool = iterAny( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -91,6 +91,6 @@ tape( 'the function returns `false` if all iterated values are falsy', function
 	arr = array2iterator( [ 0, 0, 0 ] );
 	bool = iterAny( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/every/test/test.js b/lib/node_modules/@stdlib/iter/every/test/test.js
index 5220ed69c062..acc7c5fc0e5e 100644
--- a/lib/node_modules/@stdlib/iter/every/test/test.js
+++ b/lib/node_modules/@stdlib/iter/every/test/test.js
@@ -69,7 +69,7 @@ tape( 'if provided an "empty" iterator, the function returns `true`', function t
 	arr = array2iterator( [] );
 	bool = iterEvery( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -80,7 +80,7 @@ tape( 'the function returns `true` if all iterated values are truthy', function
 	arr = array2iterator( [ 1, 1, 1, 1, 1 ] );
 	bool = iterEvery( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -91,6 +91,6 @@ tape( 'the function returns `false` if at least one iterated value is falsy', fu
 	arr = array2iterator( [ 1, 1, 1, 0 ] );
 	bool = iterEvery( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/none/test/test.js b/lib/node_modules/@stdlib/iter/none/test/test.js
index 3d5a6bd38918..2c976366d268 100644
--- a/lib/node_modules/@stdlib/iter/none/test/test.js
+++ b/lib/node_modules/@stdlib/iter/none/test/test.js
@@ -69,7 +69,7 @@ tape( 'if provided an "empty" iterator, the function returns `true`', function t
 	arr = array2iterator( [] );
 	bool = iterNone( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -80,7 +80,7 @@ tape( 'the function returns `true` if all iterated values are falsy', function t
 	arr = array2iterator( [ 0, 0, 0, 0, 0 ] );
 	bool = iterNone( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -91,6 +91,6 @@ tape( 'the function returns `false` if at least one iterated value is truthy', f
 	arr = array2iterator( [ 0, 0, 0, 1 ] );
 	bool = iterNone( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/iter/some/test/test.js b/lib/node_modules/@stdlib/iter/some/test/test.js
index 3ba61d5bfef4..6a30401428d5 100644
--- a/lib/node_modules/@stdlib/iter/some/test/test.js
+++ b/lib/node_modules/@stdlib/iter/some/test/test.js
@@ -100,7 +100,7 @@ tape( 'if provided an "empty" iterator, the function returns `false`', function
 	arr = array2iterator( [] );
 	bool = iterSome( arr, 1 );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function returns `true` if at least `n` iterated values are truthy',
 	arr = array2iterator( [ 0, 0, 1, 1, 1 ] );
 	bool = iterSome( arr, 3 );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -122,6 +122,6 @@ tape( 'the function returns `false` if less than `n` elements are truthy', funct
 	arr = array2iterator( [ 0, 0, 0 ] );
 	bool = iterSome( arr, 2 );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile-c/test/test.js b/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile-c/test/test.js
index 90320fb5e543..f15bad7d0406 100644
--- a/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile-c/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile-c/test/test.js
@@ -49,16 +49,16 @@ tape( 'the function returns a string (default)', opts, function test( t ) {
 	var str;
 
 	str = compile( [] );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0 ] );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ] );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( new Float64Array( 501 ) );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	t.end();
 });
@@ -72,16 +72,16 @@ tape( 'the function returns a string (custom name)', opts, function test( t ) {
 	};
 
 	str = compile( [], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( new Float64Array( 501 ), options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'the function returns a string (custom dtype)', opts, function test( t ) {
 	};
 
 	str = compile( [], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( new Float64Array( 501 ), options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile/test/test.js b/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile/test/test.js
index d2d8073377b6..a004b52037a6 100644
--- a/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/evalpoly-compile/test/test.js
@@ -50,16 +50,16 @@ tape( 'the function returns a string', opts, function test( t ) {
 	var str;
 
 	str = compile( [] );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0 ] );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ] );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( new Float64Array( 501 ) );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	t.end();
 });
@@ -73,16 +73,16 @@ tape( 'the function returns a string (dtype=float64)', opts, function test( t )
 	};
 
 	str = compile( [], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( new Float64Array( 501 ) );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	t.end();
 });
@@ -96,16 +96,16 @@ tape( 'the function returns a string (dtype=float32)', opts, function test( t )
 	};
 
 	str = compile( [], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( new Float64Array( 501 ) );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/evalrational-compile-c/test/test.js b/lib/node_modules/@stdlib/math/base/tools/evalrational-compile-c/test/test.js
index 6b981de315bb..c8ce9ca49549 100644
--- a/lib/node_modules/@stdlib/math/base/tools/evalrational-compile-c/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/evalrational-compile-c/test/test.js
@@ -49,16 +49,16 @@ tape( 'the function returns a string (default)', opts, function test( t ) {
 	var str;
 
 	str = compile( [], [] );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0 ], [ 2.0 ] );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], [ 3.0, 2.0, 1.0 ] );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( new Float64Array( 501 ), new Float64Array( 501 ) );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	t.end();
 });
@@ -72,16 +72,16 @@ tape( 'the function returns a string (custom name)', opts, function test( t ) {
 	};
 
 	str = compile( [], [], options );
-	t.strictEqual( typeof str, 'string', 'returns a string', options );
+	t.strictEqual( typeof str, 'string', 'returns expected value', options );
 
 	str = compile( [ 1.0 ], [ 2.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string', options );
+	t.strictEqual( typeof str, 'string', 'returns expected value', options );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], [ 3.0, 2.0, 1.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string', options );
+	t.strictEqual( typeof str, 'string', 'returns expected value', options );
 
 	str = compile( new Float64Array( 501 ), new Float64Array( 501 ), options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'the function returns a string (custom dtype)', opts, function test( t ) {
 	};
 
 	str = compile( [], [], options );
-	t.strictEqual( typeof str, 'string', 'returns a string', options );
+	t.strictEqual( typeof str, 'string', 'returns expected value', options );
 
 	str = compile( [ 1.0 ], [ 2.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string', options );
+	t.strictEqual( typeof str, 'string', 'returns expected value', options );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], [ 3.0, 2.0, 1.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string', options );
+	t.strictEqual( typeof str, 'string', 'returns expected value', options );
 
 	str = compile( new Float64Array( 501 ), new Float64Array( 501 ), options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/evalrational-compile/test/test.js b/lib/node_modules/@stdlib/math/base/tools/evalrational-compile/test/test.js
index b7c5fa4e70a4..c38aca442e52 100644
--- a/lib/node_modules/@stdlib/math/base/tools/evalrational-compile/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/evalrational-compile/test/test.js
@@ -52,16 +52,16 @@ tape( 'the function returns a string', opts, function test( t ) {
 	var str;
 
 	str = compile( [], [] );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0 ], [ 2.0 ] );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], [ 3.0, 2.0, 1.0 ] );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( new Float64Array( 501 ), new Float64Array( 501 ) );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	t.end();
 });
@@ -75,16 +75,16 @@ tape( 'the function returns a string (dtype=float64)', opts, function test( t )
 	};
 
 	str = compile( [], [], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0 ], [ 2.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], [ 3.0, 2.0, 1.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( new Float64Array( 501 ), new Float64Array( 501 ), options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	t.end();
 });
@@ -98,16 +98,16 @@ tape( 'the function returns a string (dtype=float32)', opts, function test( t )
 	};
 
 	str = compile( [], [], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0 ], [ 2.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( [ 1.0, 2.0, 3.0 ], [ 3.0, 2.0, 1.0 ], options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	str = compile( new Float32Array( 501 ), new Float32Array( 501 ), options );
-	t.strictEqual( typeof str, 'string', 'returns a string' );
+	t.strictEqual( typeof str, 'string', 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/special/abs/test/test.js b/lib/node_modules/@stdlib/math/iter/special/abs/test/test.js
index aa9a378a28a2..882eb82529bc 100644
--- a/lib/node_modules/@stdlib/math/iter/special/abs/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/abs/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = abs( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAbs( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAbs( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/abs2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/abs2/test/test.js
index 02e3cbc3f414..1d21193cb031 100644
--- a/lib/node_modules/@stdlib/math/iter/special/abs2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/abs2/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = abs2( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAbs2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAbs2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/acos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/acos/test/test.js
index d0e7f176c920..fa6c5be5ba9b 100644
--- a/lib/node_modules/@stdlib/math/iter/special/acos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/acos/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = acos( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAcos( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAcos( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/acosh/test/test.js b/lib/node_modules/@stdlib/math/iter/special/acosh/test/test.js
index 781f3a6bfad0..d921261daa2f 100644
--- a/lib/node_modules/@stdlib/math/iter/special/acosh/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/acosh/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = acosh( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAcosh( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAcosh( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/acot/test/test.js b/lib/node_modules/@stdlib/math/iter/special/acot/test/test.js
index 491daebb1ad7..02b625f3bfd4 100644
--- a/lib/node_modules/@stdlib/math/iter/special/acot/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/acot/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = acot( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAcot( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAcot( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/acoth/test/test.js b/lib/node_modules/@stdlib/math/iter/special/acoth/test/test.js
index 29fa4cdea627..03acb4164c7d 100644
--- a/lib/node_modules/@stdlib/math/iter/special/acoth/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/acoth/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = acoth( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAcoth( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAcoth( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/acovercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/acovercos/test/test.js
index c3895c92b4e0..fca51b31639f 100644
--- a/lib/node_modules/@stdlib/math/iter/special/acovercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/acovercos/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = acovercos( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAcovercos( uniform( 0.0, 2.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAcovercos( uniform( 0.0, 2.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/acoversin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/acoversin/test/test.js
index 80edd0918166..cd0f11366dfd 100644
--- a/lib/node_modules/@stdlib/math/iter/special/acoversin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/acoversin/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = acoversin( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAcoversin( uniform( 0.0, 2.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAcoversin( uniform( 0.0, 2.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/ahavercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ahavercos/test/test.js
index c82b168f0b30..192e7e7d8a0f 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ahavercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ahavercos/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = ahavercos( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAhavercos( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAhavercos( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/ahaversin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ahaversin/test/test.js
index afef681c2391..d9c7cf85435b 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ahaversin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ahaversin/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = ahaversin( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAhaversin( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAhaversin( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/asin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/asin/test/test.js
index d33b0393f1bc..c95359e31622 100644
--- a/lib/node_modules/@stdlib/math/iter/special/asin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/asin/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = asin( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAsin( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAsin( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/asinh/test/test.js b/lib/node_modules/@stdlib/math/iter/special/asinh/test/test.js
index 081acc5f675c..543c2ea3fe2d 100644
--- a/lib/node_modules/@stdlib/math/iter/special/asinh/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/asinh/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = asinh( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAsinh( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAsinh( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/atan/test/test.js b/lib/node_modules/@stdlib/math/iter/special/atan/test/test.js
index 5bfba7821d14..3cb21439ebcf 100644
--- a/lib/node_modules/@stdlib/math/iter/special/atan/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/atan/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = atan( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAtan( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAtan( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/atan2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/atan2/test/test.js
index 83ee40f17d3b..1850c8578a85 100644
--- a/lib/node_modules/@stdlib/math/iter/special/atan2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/atan2/test/test.js
@@ -100,8 +100,8 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, ite
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -116,8 +116,8 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, sca
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -132,8 +132,8 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, itera
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -148,8 +148,8 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, scala
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -173,7 +173,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = atan2( y.next().value, x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -199,7 +199,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = atan2( y.next().value, 2.0 );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -225,7 +225,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = atan2( 2.0, x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -304,7 +304,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -316,11 +316,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAtan2( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -341,11 +341,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAtan2( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/atanh/test/test.js b/lib/node_modules/@stdlib/math/iter/special/atanh/test/test.js
index 1bfbbbf93a83..8c4b5a5d283c 100644
--- a/lib/node_modules/@stdlib/math/iter/special/atanh/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/atanh/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = atanh( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAtanh( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAtanh( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/avercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/avercos/test/test.js
index ee096ae10598..67f97f1c2894 100644
--- a/lib/node_modules/@stdlib/math/iter/special/avercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/avercos/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = avercos( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAvercos( uniform( -2.0, 0.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAvercos( uniform( -2.0, 0.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/aversin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/aversin/test/test.js
index f7c02997d371..ffe5624844dc 100644
--- a/lib/node_modules/@stdlib/math/iter/special/aversin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/aversin/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = aversin( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterAversin( uniform( 0.0, 2.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterAversin( uniform( 0.0, 2.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/besselj0/test/test.js b/lib/node_modules/@stdlib/math/iter/special/besselj0/test/test.js
index 2486f429277b..c0331da76a04 100644
--- a/lib/node_modules/@stdlib/math/iter/special/besselj0/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/besselj0/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = besselj0( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBesselj0( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBesselj0( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/besselj1/test/test.js b/lib/node_modules/@stdlib/math/iter/special/besselj1/test/test.js
index 37743f9c2e9a..fbb49326fa45 100644
--- a/lib/node_modules/@stdlib/math/iter/special/besselj1/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/besselj1/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = besselj1( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBesselj1( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBesselj1( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/bessely0/test/test.js b/lib/node_modules/@stdlib/math/iter/special/bessely0/test/test.js
index ce65ac3a2370..8f4ca372f1dd 100644
--- a/lib/node_modules/@stdlib/math/iter/special/bessely0/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/bessely0/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = bessely0( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBessely0( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBessely0( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/bessely1/test/test.js b/lib/node_modules/@stdlib/math/iter/special/bessely1/test/test.js
index eae1b675e5c7..c0a84102d504 100644
--- a/lib/node_modules/@stdlib/math/iter/special/bessely1/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/bessely1/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = bessely1( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBessely1( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBessely1( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/beta/test/test.js b/lib/node_modules/@stdlib/math/iter/special/beta/test/test.js
index 80d71b82e960..b0feb1dba005 100644
--- a/lib/node_modules/@stdlib/math/iter/special/beta/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/beta/test/test.js
@@ -100,8 +100,8 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, ite
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -116,8 +116,8 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, sca
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -132,8 +132,8 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, itera
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -148,8 +148,8 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, scala
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -173,7 +173,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = beta( x.next().value, y.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -199,7 +199,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = beta( x.next().value, 2.0 );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -225,7 +225,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = beta( 2.0, y.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -304,7 +304,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -316,11 +316,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBeta( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -341,11 +341,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBeta( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/betaln/test/test.js b/lib/node_modules/@stdlib/math/iter/special/betaln/test/test.js
index ec5411d7d97e..f81fb84967d5 100644
--- a/lib/node_modules/@stdlib/math/iter/special/betaln/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/betaln/test/test.js
@@ -100,8 +100,8 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, ite
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -116,8 +116,8 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, sca
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -132,8 +132,8 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, itera
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -148,8 +148,8 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, scala
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -173,7 +173,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = betaln( x.next().value, y.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -199,7 +199,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = betaln( x.next().value, 2.0 );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -225,7 +225,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = betaln( 2.0, y.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -304,7 +304,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -316,11 +316,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBetaln( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -341,11 +341,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBetaln( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/binet/test/test.js b/lib/node_modules/@stdlib/math/iter/special/binet/test/test.js
index 89561a66f416..27cc80561c4a 100644
--- a/lib/node_modules/@stdlib/math/iter/special/binet/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/binet/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = binet( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterBinet( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterBinet( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/cbrt/test/test.js b/lib/node_modules/@stdlib/math/iter/special/cbrt/test/test.js
index f47e6b3746e2..90c8d24c6629 100644
--- a/lib/node_modules/@stdlib/math/iter/special/cbrt/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/cbrt/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = cbrt( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCbrt( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCbrt( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/ceil/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ceil/test/test.js
index 9be4dee1cf65..cf76e6c3755e 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ceil/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ceil/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 		r = it.next();
 		expected = ceil( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCeil( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCeil( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/ceil10/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ceil10/test/test.js
index 9cc1828cd46d..356238864332 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ceil10/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ceil10/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 		r = it.next();
 		expected = ceil10( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCeil10( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCeil10( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/ceil2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ceil2/test/test.js
index 753fb3408f7a..94098ea69a75 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ceil2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ceil2/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 		r = it.next();
 		expected = ceil2( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCeil2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCeil2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/cos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/cos/test/test.js
index e932ce3035b2..28d747de1457 100644
--- a/lib/node_modules/@stdlib/math/iter/special/cos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/cos/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = cos( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCos( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCos( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/cosh/test/test.js b/lib/node_modules/@stdlib/math/iter/special/cosh/test/test.js
index 7f093d3c0863..ec1138fb6a9f 100644
--- a/lib/node_modules/@stdlib/math/iter/special/cosh/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/cosh/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = cosh( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCosh( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCosh( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/cosm1/test/test.js b/lib/node_modules/@stdlib/math/iter/special/cosm1/test/test.js
index 9801e469106b..9e1f8360412c 100644
--- a/lib/node_modules/@stdlib/math/iter/special/cosm1/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/cosm1/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = cosm1( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCosm1( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCosm1( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/cospi/test/test.js b/lib/node_modules/@stdlib/math/iter/special/cospi/test/test.js
index dd8180549506..93feb3e91b90 100644
--- a/lib/node_modules/@stdlib/math/iter/special/cospi/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/cospi/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = cospi( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCospi( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCospi( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/covercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/covercos/test/test.js
index d2ef9a8cf960..7fd5d15953b4 100644
--- a/lib/node_modules/@stdlib/math/iter/special/covercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/covercos/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = covercos( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCovercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCovercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/coversin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/coversin/test/test.js
index 39db89fcca0d..78958cc78c03 100644
--- a/lib/node_modules/@stdlib/math/iter/special/coversin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/coversin/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = coversin( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterCoversin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterCoversin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/deg2rad/test/test.js b/lib/node_modules/@stdlib/math/iter/special/deg2rad/test/test.js
index d0101694e453..b2206338cbab 100644
--- a/lib/node_modules/@stdlib/math/iter/special/deg2rad/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/deg2rad/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which converts
 		r = it.next();
 		expected = deg2rad( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDeg2rad( uniform( -360.0, 360.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDeg2rad( uniform( -360.0, 360.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/digamma/test/test.js b/lib/node_modules/@stdlib/math/iter/special/digamma/test/test.js
index 159d1852acdf..9be095659cf0 100644
--- a/lib/node_modules/@stdlib/math/iter/special/digamma/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/digamma/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = digamma( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDigamma( uniform( 0.01, 5.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDigamma( uniform( 0.01, 5.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/dirac-delta/test/test.js b/lib/node_modules/@stdlib/math/iter/special/dirac-delta/test/test.js
index c63db4b5a01e..257f33d1fd0d 100644
--- a/lib/node_modules/@stdlib/math/iter/special/dirac-delta/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/dirac-delta/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = diracDelta( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterDiracDelta( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterDiracDelta( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/dirichlet-eta/test/test.js b/lib/node_modules/@stdlib/math/iter/special/dirichlet-eta/test/test.js
index fa3fa5101a7b..e1c7b81fab70 100644
--- a/lib/node_modules/@stdlib/math/iter/special/dirichlet-eta/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/dirichlet-eta/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = eta( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterEta( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterEta( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/ellipe/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ellipe/test/test.js
index 9b6c2cbdab5e..b972fbd91f7f 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ellipe/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ellipe/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = ellipe( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterEllipe( uniform( -1.0, 1.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterEllipe( uniform( -1.0, 1.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/ellipk/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ellipk/test/test.js
index e377183a29d3..ee74570ce8c0 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ellipk/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ellipk/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = ellipk( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterEllipk( uniform( -1.0, 1.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterEllipk( uniform( -1.0, 1.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/erf/test/test.js b/lib/node_modules/@stdlib/math/iter/special/erf/test/test.js
index 5b664fb4ab16..3699ccf94bca 100644
--- a/lib/node_modules/@stdlib/math/iter/special/erf/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/erf/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = erf( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterErf( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterErf( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/erfc/test/test.js b/lib/node_modules/@stdlib/math/iter/special/erfc/test/test.js
index cf062ea03ca0..ff2aca9faa0d 100644
--- a/lib/node_modules/@stdlib/math/iter/special/erfc/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/erfc/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = erfc( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterErfc( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterErfc( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/erfcinv/test/test.js b/lib/node_modules/@stdlib/math/iter/special/erfcinv/test/test.js
index 2995f67209b4..598e851cd536 100644
--- a/lib/node_modules/@stdlib/math/iter/special/erfcinv/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/erfcinv/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = erfcinv( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterErfcinv( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterErfcinv( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/erfinv/test/test.js b/lib/node_modules/@stdlib/math/iter/special/erfinv/test/test.js
index 4f2a6af4f890..ad09404e4a28 100644
--- a/lib/node_modules/@stdlib/math/iter/special/erfinv/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/erfinv/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = erfinv( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterErfinv( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterErfinv( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/exp/test/test.js b/lib/node_modules/@stdlib/math/iter/special/exp/test/test.js
index 78077c10a51c..e2c0ebd2cfd8 100644
--- a/lib/node_modules/@stdlib/math/iter/special/exp/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/exp/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = exp( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterExp( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterExp( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/exp10/test/test.js b/lib/node_modules/@stdlib/math/iter/special/exp10/test/test.js
index 2bbdc5f5a9fc..ef86db64d737 100644
--- a/lib/node_modules/@stdlib/math/iter/special/exp10/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/exp10/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = exp10( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterExp10( uniform( -50.0, 50.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterExp10( uniform( -50.0, 50.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/exp2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/exp2/test/test.js
index f57c4f60de90..dd33a79a70eb 100644
--- a/lib/node_modules/@stdlib/math/iter/special/exp2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/exp2/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = exp2( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterExp2( uniform( -50.0, 50.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterExp2( uniform( -50.0, 50.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/expit/test/test.js b/lib/node_modules/@stdlib/math/iter/special/expit/test/test.js
index a46dbc97a668..130dbdc9d064 100644
--- a/lib/node_modules/@stdlib/math/iter/special/expit/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/expit/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = expit( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterExpit( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterExpit( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/expm1/test/test.js b/lib/node_modules/@stdlib/math/iter/special/expm1/test/test.js
index 4b8e55561f12..379c630f8e9d 100644
--- a/lib/node_modules/@stdlib/math/iter/special/expm1/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/expm1/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = expm1( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterExpm1( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterExpm1( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/expm1rel/test/test.js b/lib/node_modules/@stdlib/math/iter/special/expm1rel/test/test.js
index 761f450a73d5..297b27be5542 100644
--- a/lib/node_modules/@stdlib/math/iter/special/expm1rel/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/expm1rel/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = expm1rel( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterExpm1rel( uniform( -50.0, 50.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterExpm1rel( uniform( -50.0, 50.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/factorial/test/test.js b/lib/node_modules/@stdlib/math/iter/special/factorial/test/test.js
index 15b3d1632736..239a9f8cedaa 100644
--- a/lib/node_modules/@stdlib/math/iter/special/factorial/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/factorial/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = factorial( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFactorial( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFactorial( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/factorialln/test/test.js b/lib/node_modules/@stdlib/math/iter/special/factorialln/test/test.js
index 017e75390b68..a0182ee2f48e 100644
--- a/lib/node_modules/@stdlib/math/iter/special/factorialln/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/factorialln/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = factorialln( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFactorialln( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFactorialln( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/floor/test/test.js b/lib/node_modules/@stdlib/math/iter/special/floor/test/test.js
index 58c92d4a90a4..52471d206500 100644
--- a/lib/node_modules/@stdlib/math/iter/special/floor/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/floor/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 		r = it.next();
 		expected = floor( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFloor( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFloor( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/floor10/test/test.js b/lib/node_modules/@stdlib/math/iter/special/floor10/test/test.js
index 8bc387420860..66ee91e375d5 100644
--- a/lib/node_modules/@stdlib/math/iter/special/floor10/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/floor10/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 		r = it.next();
 		expected = floor10( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFloor10( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFloor10( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/floor2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/floor2/test/test.js
index 47a5b4779dd2..374a805c77ff 100644
--- a/lib/node_modules/@stdlib/math/iter/special/floor2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/floor2/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 		r = it.next();
 		expected = floor2( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFloor2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFloor2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/fresnelc/test/test.js b/lib/node_modules/@stdlib/math/iter/special/fresnelc/test/test.js
index 9ce41d8ce56d..73a38d57798f 100644
--- a/lib/node_modules/@stdlib/math/iter/special/fresnelc/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/fresnelc/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = fresnelc( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFresnelc( uniform( 0.0, 10.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFresnelc( uniform( 0.0, 10.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/fresnels/test/test.js b/lib/node_modules/@stdlib/math/iter/special/fresnels/test/test.js
index 002051ae8446..927f8229fcae 100644
--- a/lib/node_modules/@stdlib/math/iter/special/fresnels/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/fresnels/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = fresnels( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterFresnels( uniform( 0.0, 10.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterFresnels( uniform( 0.0, 10.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/gamma/test/test.js b/lib/node_modules/@stdlib/math/iter/special/gamma/test/test.js
index adf86fadcd18..e00d49d6a88d 100644
--- a/lib/node_modules/@stdlib/math/iter/special/gamma/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/gamma/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = gamma( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterGamma( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterGamma( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/gamma1pm1/test/test.js b/lib/node_modules/@stdlib/math/iter/special/gamma1pm1/test/test.js
index a92abd3420b9..8a732ec9b06b 100644
--- a/lib/node_modules/@stdlib/math/iter/special/gamma1pm1/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/gamma1pm1/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = gamma1pm1( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterGamma1pm1( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterGamma1pm1( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/gammaln/test/test.js b/lib/node_modules/@stdlib/math/iter/special/gammaln/test/test.js
index 527652ec0875..03d2d344e237 100644
--- a/lib/node_modules/@stdlib/math/iter/special/gammaln/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/gammaln/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = gammaln( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterGammaln( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterGammaln( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/hacovercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/hacovercos/test/test.js
index 9aa9372e2e32..5edefd370b63 100644
--- a/lib/node_modules/@stdlib/math/iter/special/hacovercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/hacovercos/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = hacovercos( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterHacovercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterHacovercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/hacoversin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/hacoversin/test/test.js
index ac7fb85433e7..f5f7eaea1cd9 100644
--- a/lib/node_modules/@stdlib/math/iter/special/hacoversin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/hacoversin/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = hacoversin( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterHacoversin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterHacoversin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/havercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/havercos/test/test.js
index 8fa1e7100dee..eecc7fab1e4f 100644
--- a/lib/node_modules/@stdlib/math/iter/special/havercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/havercos/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = havercos( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterHavercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterHavercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/haversin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/haversin/test/test.js
index faa9e8de2e85..0c3debc36d55 100644
--- a/lib/node_modules/@stdlib/math/iter/special/haversin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/haversin/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = haversin( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterHaversin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterHaversin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/inv/test/test.js b/lib/node_modules/@stdlib/math/iter/special/inv/test/test.js
index 7d51d23f929c..a98326009b64 100644
--- a/lib/node_modules/@stdlib/math/iter/special/inv/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/inv/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = inv( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterInv( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterInv( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/ln/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ln/test/test.js
index eecfc1e383ca..ab935c7be8b7 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ln/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ln/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = ln( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLn( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLn( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/log/test/test.js b/lib/node_modules/@stdlib/math/iter/special/log/test/test.js
index fad8ead7cbda..d967fe8e3924 100644
--- a/lib/node_modules/@stdlib/math/iter/special/log/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/log/test/test.js
@@ -100,8 +100,8 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, ite
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -116,8 +116,8 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, sca
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -132,8 +132,8 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, itera
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -148,8 +148,8 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, scala
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -173,7 +173,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = log( x.next().value, y.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -199,7 +199,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = log( x.next().value, 2.0 );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -225,7 +225,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = log( 2.0, y.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -304,7 +304,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -316,11 +316,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLog( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -341,11 +341,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLog( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/log10/test/test.js b/lib/node_modules/@stdlib/math/iter/special/log10/test/test.js
index 962f1e7fc78f..d7d11d527d4b 100644
--- a/lib/node_modules/@stdlib/math/iter/special/log10/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/log10/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = log10( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLog10( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLog10( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/log1mexp/test/test.js b/lib/node_modules/@stdlib/math/iter/special/log1mexp/test/test.js
index 005680bd8fa9..e7df12c85541 100644
--- a/lib/node_modules/@stdlib/math/iter/special/log1mexp/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/log1mexp/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = log1mexp( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLog1mexp( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLog1mexp( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/log1p/test/test.js b/lib/node_modules/@stdlib/math/iter/special/log1p/test/test.js
index f5a552b1f1e3..38bf8cda783b 100644
--- a/lib/node_modules/@stdlib/math/iter/special/log1p/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/log1p/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = log1p( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLog1p( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLog1p( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/log1pexp/test/test.js b/lib/node_modules/@stdlib/math/iter/special/log1pexp/test/test.js
index e269f72b3689..d3839181f874 100644
--- a/lib/node_modules/@stdlib/math/iter/special/log1pexp/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/log1pexp/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = log1pexp( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLog1pexp( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLog1pexp( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/log2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/log2/test/test.js
index b79a9eaf206a..2603d237317f 100644
--- a/lib/node_modules/@stdlib/math/iter/special/log2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/log2/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = log2( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLog2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLog2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/logit/test/test.js b/lib/node_modules/@stdlib/math/iter/special/logit/test/test.js
index 7d305ee001e2..6f2163afad92 100644
--- a/lib/node_modules/@stdlib/math/iter/special/logit/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/logit/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = logit( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterLogit( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterLogit( uniform( 0.0, 1.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/pow/test/test.js b/lib/node_modules/@stdlib/math/iter/special/pow/test/test.js
index 05ec2fd0c998..57e760c09001 100644
--- a/lib/node_modules/@stdlib/math/iter/special/pow/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/pow/test/test.js
@@ -100,8 +100,8 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, ite
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -116,8 +116,8 @@ tape( 'the function returns an iterator protocol-compliant object (iterator, sca
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -132,8 +132,8 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, itera
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -148,8 +148,8 @@ tape( 'the function returns an iterator protocol-compliant object (scalar, scala
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -173,7 +173,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = pow( x.next().value, y.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -199,7 +199,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = pow( x.next().value, 2.0 );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -225,7 +225,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = pow( 2.0, y.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -304,7 +304,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -316,11 +316,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterPow( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -341,11 +341,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterPow( randu(), randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/rad2deg/test/test.js b/lib/node_modules/@stdlib/math/iter/special/rad2deg/test/test.js
index 9ade51818102..2c9d817acb87 100644
--- a/lib/node_modules/@stdlib/math/iter/special/rad2deg/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/rad2deg/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which converts
 		r = it.next();
 		expected = rad2deg( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterRad2deg( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterRad2deg( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/ramp/test/test.js b/lib/node_modules/@stdlib/math/iter/special/ramp/test/test.js
index 04516dc6bfbd..881557cfde68 100644
--- a/lib/node_modules/@stdlib/math/iter/special/ramp/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/ramp/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = ramp( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterRamp( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterRamp( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/riemann-zeta/test/test.js b/lib/node_modules/@stdlib/math/iter/special/riemann-zeta/test/test.js
index 2dd58a86f02e..df2aa98b1be5 100644
--- a/lib/node_modules/@stdlib/math/iter/special/riemann-zeta/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/riemann-zeta/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = zeta( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterZeta( uniform( 1.1, 50.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterZeta( uniform( 1.1, 50.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/round/test/test.js b/lib/node_modules/@stdlib/math/iter/special/round/test/test.js
index 2ba542c87bc5..4279a0076d6c 100644
--- a/lib/node_modules/@stdlib/math/iter/special/round/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/round/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 		r = it.next();
 		expected = round( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterRound( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterRound( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/round10/test/test.js b/lib/node_modules/@stdlib/math/iter/special/round10/test/test.js
index 98491a1b7d5a..b0c864f4b2f1 100644
--- a/lib/node_modules/@stdlib/math/iter/special/round10/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/round10/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 		r = it.next();
 		expected = round10( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterRound10( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterRound10( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/round2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/round2/test/test.js
index 4cf3c036e2b5..a6d9380b94a9 100644
--- a/lib/node_modules/@stdlib/math/iter/special/round2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/round2/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 		r = it.next();
 		expected = round2( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterRound2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterRound2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/rsqrt/test/test.js b/lib/node_modules/@stdlib/math/iter/special/rsqrt/test/test.js
index c87734a87c40..d2f0376dcaa4 100644
--- a/lib/node_modules/@stdlib/math/iter/special/rsqrt/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/rsqrt/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = rsqrt( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterRsqrt( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterRsqrt( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/signum/test/test.js b/lib/node_modules/@stdlib/math/iter/special/signum/test/test.js
index 90b14aadd910..dfb6b34efc0f 100644
--- a/lib/node_modules/@stdlib/math/iter/special/signum/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/signum/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = signum( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSignum( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSignum( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/sin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/sin/test/test.js
index 687db3a1dd97..6d080aabca3b 100644
--- a/lib/node_modules/@stdlib/math/iter/special/sin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/sin/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = sin( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSin( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSin( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/sinc/test/test.js b/lib/node_modules/@stdlib/math/iter/special/sinc/test/test.js
index 41a3d151e458..59c0acbe2e5f 100644
--- a/lib/node_modules/@stdlib/math/iter/special/sinc/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/sinc/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = sinc( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSinc( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSinc( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/sinh/test/test.js b/lib/node_modules/@stdlib/math/iter/special/sinh/test/test.js
index 6efa1609b04b..9be4838fef25 100644
--- a/lib/node_modules/@stdlib/math/iter/special/sinh/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/sinh/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = sinh( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSinh( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSinh( uniform( -5.0, 5.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/sinpi/test/test.js b/lib/node_modules/@stdlib/math/iter/special/sinpi/test/test.js
index b5ec26dc3c8e..92de20656a0c 100644
--- a/lib/node_modules/@stdlib/math/iter/special/sinpi/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/sinpi/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = sinpi( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSinpi( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSinpi( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/spence/test/test.js b/lib/node_modules/@stdlib/math/iter/special/spence/test/test.js
index 9e48f30655fe..b021010bf572 100644
--- a/lib/node_modules/@stdlib/math/iter/special/spence/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/spence/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = spence( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSpence( uniform( 0.0, 100.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSpence( uniform( 0.0, 100.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/sqrt/test/test.js b/lib/node_modules/@stdlib/math/iter/special/sqrt/test/test.js
index d2258bc0f04d..5b915f1b4e71 100644
--- a/lib/node_modules/@stdlib/math/iter/special/sqrt/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/sqrt/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = sqrt( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSqrt( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSqrt( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/sqrt1pm1/test/test.js b/lib/node_modules/@stdlib/math/iter/special/sqrt1pm1/test/test.js
index da26efcf62e2..b516c7bdec2c 100644
--- a/lib/node_modules/@stdlib/math/iter/special/sqrt1pm1/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/sqrt1pm1/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = sqrt1pm1( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterSqrt1pm1( uniform( 0.0, 100.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterSqrt1pm1( uniform( 0.0, 100.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/tan/test/test.js b/lib/node_modules/@stdlib/math/iter/special/tan/test/test.js
index de569f71fee2..37818bd8ef0d 100644
--- a/lib/node_modules/@stdlib/math/iter/special/tan/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/tan/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = tan( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTan( uniform( -1.57, 1.57 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTan( uniform( -1.57, 1.57 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/tanh/test/test.js b/lib/node_modules/@stdlib/math/iter/special/tanh/test/test.js
index 45b49a5a04bc..70973b7aab0a 100644
--- a/lib/node_modules/@stdlib/math/iter/special/tanh/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/tanh/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = tanh( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTanh( uniform( -4.0, 4.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTanh( uniform( -4.0, 4.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/trigamma/test/test.js b/lib/node_modules/@stdlib/math/iter/special/trigamma/test/test.js
index 522bd2ca1fb0..2284b54b529f 100644
--- a/lib/node_modules/@stdlib/math/iter/special/trigamma/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/trigamma/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which evaluate
 		r = it.next();
 		expected = trigamma( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTrigamma( uniform( 0.01, 50.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTrigamma( uniform( 0.01, 50.0 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/trunc/test/test.js b/lib/node_modules/@stdlib/math/iter/special/trunc/test/test.js
index df37cfc78be2..e03c5a26c5be 100644
--- a/lib/node_modules/@stdlib/math/iter/special/trunc/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/trunc/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 		r = it.next();
 		expected = trunc( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTrunc( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTrunc( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/trunc10/test/test.js b/lib/node_modules/@stdlib/math/iter/special/trunc10/test/test.js
index a68615c9510c..9ac6c34db1d9 100644
--- a/lib/node_modules/@stdlib/math/iter/special/trunc10/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/trunc10/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 		r = it.next();
 		expected = trunc10( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTrunc10( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTrunc10( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/trunc2/test/test.js b/lib/node_modules/@stdlib/math/iter/special/trunc2/test/test.js
index dc3318e58d7d..72b0d8310a64 100644
--- a/lib/node_modules/@stdlib/math/iter/special/trunc2/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/trunc2/test/test.js
@@ -75,8 +75,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'the function returns an iterator protocol-compliant object which rounds e
 		r = it.next();
 		expected = trunc2( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -157,7 +157,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -169,11 +169,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterTrunc2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -194,11 +194,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterTrunc2( randu() );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/vercos/test/test.js b/lib/node_modules/@stdlib/math/iter/special/vercos/test/test.js
index 7395a483b8a1..2d12f9d3539b 100644
--- a/lib/node_modules/@stdlib/math/iter/special/vercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/vercos/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = vercos( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterVercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterVercos( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/math/iter/special/versin/test/test.js b/lib/node_modules/@stdlib/math/iter/special/versin/test/test.js
index a014eb6a80bb..cb52a8264e95 100644
--- a/lib/node_modules/@stdlib/math/iter/special/versin/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/special/versin/test/test.js
@@ -74,8 +74,8 @@ tape( 'the function returns an iterator protocol-compliant object', function tes
 
 	for ( i = 0; i < 100; i++ ) {
 		r = it.next();
-		t.strictEqual( typeof r.value, 'number', 'returns a number' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.value, 'number', 'returns expected value' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'the function returns an iterator protocol-compliant object which computes
 		r = it.next();
 		expected = versin( x.next().value );
 		t.strictEqual( r.value, expected, 'returns expected value' );
-		t.strictEqual( typeof r.done, 'boolean', 'returns a boolean' );
+		t.strictEqual( typeof r.done, 'boolean', 'returns expected value' );
 	}
 	r = it.next();
 	t.strictEqual( r.value, void 0, 'returns expected value' );
@@ -163,7 +163,7 @@ tape( 'the function returns an iterator protocol-compliant object which returns
 		} else {
 			t.notEqual( actual.value, actual.value, 'returns expected value' );
 		}
-		t.strictEqual( actual.done, expected[ i ].done, 'returns a boolean' );
+		t.strictEqual( actual.done, expected[ i ].done, 'returns expected value' );
 	}
 	t.end();
 });
@@ -175,11 +175,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (no a
 	it = iterVersin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return();
@@ -200,11 +200,11 @@ tape( 'the returned iterator has a `return` method for closing an iterator (argu
 	it = iterVersin( uniform( 0.0, 6.28 ) );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.next();
-	t.strictEqual( typeof r.value, 'number', 'returns a number' );
+	t.strictEqual( typeof r.value, 'number', 'returns expected value' );
 	t.strictEqual( r.done, false, 'returns expected value' );
 
 	r = it.return( 'finished' );
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/test/test.js b/lib/node_modules/@stdlib/namespace/alias2pkg/test/test.js
index fe16e00e63f9..d783b6b39d2a 100644
--- a/lib/node_modules/@stdlib/namespace/alias2pkg/test/test.js
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/test/test.js
@@ -71,7 +71,7 @@ tape( 'the function returns a package name', function test( t ) {
 	for ( i = 0; i < list.length; i++ ) {
 		expected = DATA[ list[i] ];
 		actual = alias2pkg( list[i] );
-		t.strictEqual( typeof actual, 'string', 'returns a string' );
+		t.strictEqual( typeof actual, 'string', 'returns expected value' );
 		t.strictEqual( actual, expected, 'returns expected value for '+list[i] );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/namespace/alias2standalone/test/test.js b/lib/node_modules/@stdlib/namespace/alias2standalone/test/test.js
index 088de1769f8f..2ecf9a8d95ea 100644
--- a/lib/node_modules/@stdlib/namespace/alias2standalone/test/test.js
+++ b/lib/node_modules/@stdlib/namespace/alias2standalone/test/test.js
@@ -71,7 +71,7 @@ tape( 'the function returns a package name', function test( t ) {
 	for ( i = 0; i < list.length; i++ ) {
 		expected = DATA[ list[i] ];
 		actual = alias2standalone( list[i] );
-		t.strictEqual( typeof actual, 'string', 'returns a string' );
+		t.strictEqual( typeof actual, 'string', 'returns expected value' );
 		t.strictEqual( actual, expected, 'returns expected value for '+list[i] );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/test/test.js b/lib/node_modules/@stdlib/namespace/pkg2alias/test/test.js
index d2a4c43f6e7b..611a4ac911e9 100644
--- a/lib/node_modules/@stdlib/namespace/pkg2alias/test/test.js
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/test/test.js
@@ -75,7 +75,7 @@ tape( 'the function returns an alias', function test( t ) {
 		pkg = alias2pkg( list[i] );
 		expected = DATA[ pkg ];
 		actual = pkg2alias( pkg );
-		t.strictEqual( typeof actual, 'string', 'returns a string' );
+		t.strictEqual( typeof actual, 'string', 'returns expected value' );
 		t.strictEqual( actual, expected, 'returns expected value for '+pkg );
 	}
 	t.end();
@@ -93,7 +93,7 @@ tape( 'the function supports providing a standalone package name', function test
 		pkg = alias2standalone( list[i] );
 		expected = DATA[ alias2pkg( list[i] ) ];
 		actual = pkg2alias( pkg );
-		t.strictEqual( typeof actual, 'string', 'returns a string' );
+		t.strictEqual( typeof actual, 'string', 'returns expected value' );
 		t.strictEqual( actual, expected, 'returns expected value for '+pkg );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/namespace/pkg2standalone/test/test.js b/lib/node_modules/@stdlib/namespace/pkg2standalone/test/test.js
index 251bbe9f2b0e..f8d522ed2f01 100644
--- a/lib/node_modules/@stdlib/namespace/pkg2standalone/test/test.js
+++ b/lib/node_modules/@stdlib/namespace/pkg2standalone/test/test.js
@@ -74,7 +74,7 @@ tape( 'the function returns a standalone package name', function test( t ) {
 		pkg = alias2pkg( list[i] );
 		expected = DATA[ pkg ];
 		actual = pkg2standalone( pkg );
-		t.strictEqual( typeof actual, 'string', 'returns a string' );
+		t.strictEqual( typeof actual, 'string', 'returns expected value' );
 		t.strictEqual( actual, expected, 'returns expected value for '+pkg );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/namespace/standalone2pkg/test/test.js b/lib/node_modules/@stdlib/namespace/standalone2pkg/test/test.js
index 30ad0c2d9367..e7663f99f17b 100644
--- a/lib/node_modules/@stdlib/namespace/standalone2pkg/test/test.js
+++ b/lib/node_modules/@stdlib/namespace/standalone2pkg/test/test.js
@@ -74,7 +74,7 @@ tape( 'the function returns a package name', function test( t ) {
 		pkg = alias2standalone( list[i] );
 		expected = DATA[ pkg ];
 		actual = standalone2pkg( pkg );
-		t.strictEqual( typeof actual, 'string', 'returns a string' );
+		t.strictEqual( typeof actual, 'string', 'returns expected value' );
 		t.strictEqual( actual, expected, 'returns expected value for '+pkg );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.js b/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.js
index b6371051cebb..12de1a5e385e 100644
--- a/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a number', function test( t ) {
-	t.strictEqual( typeof exponentf( toFloat32( 3.14e30 ) ), 'number', 'returns a number' );
+	t.strictEqual( typeof exponentf( toFloat32( 3.14e30 ) ), 'number', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.native.js b/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.native.js
index 0dff500b92a8..ac640ea48fb7 100644
--- a/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float32/base/exponent/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns a number', opts, function test( t ) {
-	t.strictEqual( typeof exponentf( toFloat32( 3.14e30 ) ), 'number', 'returns a number' );
+	t.strictEqual( typeof exponentf( toFloat32( 3.14e30 ) ), 'number', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.js b/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.js
index 1bee060a4dca..500cf3a2e683 100644
--- a/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a boolean', function test( t ) {
-	t.strictEqual( typeof signbitf(5.0), 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof signbitf(5.0), 'boolean', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.native.js b/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.native.js
index 6619a9c850e4..ee989a3572ba 100644
--- a/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float32/base/signbit/test/test.native.js
@@ -46,7 +46,7 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns a boolean', opts, function test( t ) {
-	t.strictEqual( typeof signbitf(5.0), 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof signbitf(5.0), 'boolean', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/significand/test/test.js b/lib/node_modules/@stdlib/number/float32/base/significand/test/test.js
index 133c7caa9941..f536f50ea121 100644
--- a/lib/node_modules/@stdlib/number/float32/base/significand/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/significand/test/test.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a number', function test( t ) {
-	t.strictEqual( typeof significandf( toFloat32( 3.14e30 ) ), 'number', 'returns a number' );
+	t.strictEqual( typeof significandf( toFloat32( 3.14e30 ) ), 'number', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/significand/test/test.native.js b/lib/node_modules/@stdlib/number/float32/base/significand/test/test.native.js
index 7cea1c444bd8..81fbbe7f31f2 100644
--- a/lib/node_modules/@stdlib/number/float32/base/significand/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float32/base/significand/test/test.native.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns a number', opts, function test( t ) {
-	t.strictEqual( typeof significand( toFloat32( 3.14e30 ) ), 'number', 'returns a number' );
+	t.strictEqual( typeof significand( toFloat32( 3.14e30 ) ), 'number', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.js b/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.js
index 4441c6909950..0c09cb55f4b3 100644
--- a/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a number', function test( t ) {
-	t.strictEqual( typeof exponent(3.14e240), 'number', 'returns a number' );
+	t.strictEqual( typeof exponent(3.14e240), 'number', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.native.js
index 51d07484b837..73fb383ee791 100644
--- a/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/exponent/test/test.native.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns a number', opts, function test( t ) {
-	t.strictEqual( typeof exponent( 3.14e240 ), 'number', 'returns a number' );
+	t.strictEqual( typeof exponent( 3.14e240 ), 'number', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.js b/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.js
index a60e4ae0f890..8faa9ddf0967 100644
--- a/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns number', function test( t ) {
 	var x = fromWords( 5, 4 );
-	t.strictEqual( typeof x, 'number', 'returns a number' );
+	t.strictEqual( typeof x, 'number', 'returns expected value' );
 	t.end();
 });
 
@@ -106,7 +106,7 @@ tape( 'the function can return `NaN`', function test( t ) {
 	w = toWords( NaN );
 	x = fromWords( w[0], w[1] );
 
-	t.strictEqual( isnan( x ), true, 'returns NaN' );
+	t.strictEqual( isnan( x ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.native.js
index 792fe46db9d3..bba7f02f268d 100644
--- a/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/from-words/test/test.native.js
@@ -48,7 +48,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'the function returns number', opts, function test( t ) {
 	var x = fromWords( 5, 4 );
-	t.strictEqual( typeof x, 'number', 'returns a number' );
+	t.strictEqual( typeof x, 'number', 'returns expected value' );
 	t.end();
 });
 
@@ -115,7 +115,7 @@ tape( 'the function can return `NaN`', opts, function test( t ) {
 	w = toWords( NaN );
 	x = fromWords( w[0], w[1] );
 
-	t.strictEqual( isnan( x ), true, 'returns NaN' );
+	t.strictEqual( isnan( x ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.js b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.js
index 76b60d1eb995..2feacf94444a 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns an integer', function test( t ) {
 	var w = getHighWord( pow( 2.0, 53 ) );
 
-	t.strictEqual( typeof w, 'number', 'returns a number' );
+	t.strictEqual( typeof w, 'number', 'returns expected value' );
 	t.strictEqual( w%1, 0, 'returns an integer' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.native.js
index 68501fceca48..e79add029439 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns an integer', opts, function test( t ) {
 	var w = getHighWord( pow( 2.0, 53 ) );
 
-	t.strictEqual( typeof w, 'number', 'returns a number' );
+	t.strictEqual( typeof w, 'number', 'returns expected value' );
 	t.strictEqual( w%1, 0, 'returns an integer' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.js b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.js
index 780382eaa18a..a8f8408b3e96 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.js
@@ -40,7 +40,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns an integer', function test( t ) {
 	var w = getLowWord( pow( 2, 53 ) );
 
-	t.strictEqual( typeof w, 'number', 'returns a number' );
+	t.strictEqual( typeof w, 'number', 'returns expected value' );
 	t.strictEqual( w%1, 0, 'returns an integer' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.native.js
index 8967e8793552..cf182a65bf2a 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.native.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns an integer', opts, function test( t ) {
 	var w = getLowWord( pow( 2, 53 ) );
 
-	t.strictEqual( typeof w, 'number', 'returns a number' );
+	t.strictEqual( typeof w, 'number', 'returns expected value' );
 	t.strictEqual( w%1, 0, 'returns an integer' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.js b/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.js
index b1635a7cf931..c5115e0c7188 100644
--- a/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.js
@@ -58,7 +58,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a number', function test( t ) {
 	var y = setHighWord( pow( 2.0, 53 ), 5 );
-	t.strictEqual( typeof y, 'number', 'returns a number' );
+	t.strictEqual( typeof y, 'number', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.native.js
index 5766a764dd25..cd481814ad9a 100644
--- a/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/set-high-word/test/test.native.js
@@ -63,7 +63,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'the function returns a number', opts, function test( t ) {
 	var y = setHighWord( pow( 2.0, 53 ), 5 );
-	t.strictEqual( typeof y, 'number', 'returns a number' );
+	t.strictEqual( typeof y, 'number', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.js b/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.js
index 134dacea1aca..851f41be823d 100644
--- a/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a number', function test( t ) {
 	var y = setLowWord( pow( 2, 53 ), 5 );
-	t.strictEqual( typeof y, 'number', 'returns a number' );
+	t.strictEqual( typeof y, 'number', 'returns expected value' );
 	t.end();
 });
 
@@ -146,7 +146,7 @@ tape( 'if provided `+infinity`, setting the lower order bits will return `NaN`',
 	low = pow( 2.0, 14 );
 	y = setLowWord( PINF, low );
 
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -161,7 +161,7 @@ tape( 'if provided `+infinity`, setting the lower order bits will return `NaN` (
 	low = pow( 2.0, 14 );
 	y = setLowWord( PINF, low );
 
-	t.strictEqual( isNumber( y ), true, 'returns a number' );
+	t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	t.strictEqual( y.toString(), 'NaN', 'serializes as NaN' );
 
 	bool = isnan( y );
@@ -183,7 +183,7 @@ tape( 'if provided `-infinity`, setting the lower order bits will return `NaN`',
 	low = pow( 2.0, 14 );
 	y = setLowWord( NINF, low );
 
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -198,7 +198,7 @@ tape( 'if provided `-infinity`, setting the lower order bits will return `NaN` (
 	low = pow( 2.0, 14 );
 	y = setLowWord( NINF, low );
 
-	t.strictEqual( isNumber( y ), true, 'returns a number' );
+	t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	t.strictEqual( y.toString(), 'NaN', 'serializes as NaN' );
 
 	bool = isnan( y );
@@ -212,6 +212,6 @@ tape( 'if provided `-infinity`, setting the lower order bits will return `NaN` (
 
 tape( 'if provided `NaN`, setting the lower order bits will return `NaN`', function test( t ) {
 	var y = setLowWord( NaN, pow( 2.0, 14 ) );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.native.js
index 1503041b9e57..8d660bcff796 100644
--- a/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/set-low-word/test/test.native.js
@@ -57,7 +57,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'the function returns a number', opts, function test( t ) {
 	var y = setLowWord( pow( 2, 53 ), 5 );
-	t.strictEqual( typeof y, 'number', 'returns a number' );
+	t.strictEqual( typeof y, 'number', 'returns expected value' );
 	t.end();
 });
 
@@ -150,7 +150,7 @@ tape( 'if provided `+infinity`, setting the lower order bits will return `NaN`',
 	low = pow( 2.0, 14 );
 	y = setLowWord( PINF, low );
 
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -165,7 +165,7 @@ tape( 'if provided `+infinity`, setting the lower order bits will return `NaN` (
 	low = pow( 2.0, 14 );
 	y = setLowWord( PINF, low );
 
-	t.strictEqual( isNumber( y ), true, 'returns a number' );
+	t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	t.strictEqual( y.toString(), 'NaN', 'serializes as NaN' );
 
 	bool = isnan( y );
@@ -187,7 +187,7 @@ tape( 'if provided `-infinity`, setting the lower order bits will return `NaN`',
 	low = pow( 2.0, 14 );
 	y = setLowWord( NINF, low );
 
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -202,7 +202,7 @@ tape( 'if provided `-infinity`, setting the lower order bits will return `NaN` (
 	low = pow( 2.0, 14 );
 	y = setLowWord( NINF, low );
 
-	t.strictEqual( isNumber( y ), true, 'returns a number' );
+	t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	t.strictEqual( y.toString(), 'NaN', 'serializes as NaN' );
 
 	bool = isnan( y );
@@ -219,6 +219,6 @@ opts = {
 };
 tape( 'if provided `NaN`, setting the lower order bits will return `NaN`', opts, function test( t ) {
 	var y = setLowWord( NaN, pow( 2.0, 14 ) );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.js b/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.js
index 75e4d7cd9a78..a5d05de12c1b 100644
--- a/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a boolean', function test( t ) {
-	t.strictEqual( typeof signbit( 5.0 ), 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof signbit( 5.0 ), 'boolean', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.native.js
index 8e42a1898e92..cea60026b348 100644
--- a/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/signbit/test/test.native.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 
 tape( 'the function returns a boolean', opts, function test( t ) {
-	t.strictEqual( typeof signbit( 5.0 ), 'boolean', 'returns a boolean' );
+	t.strictEqual( typeof signbit( 5.0 ), 'boolean', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/uint16/base/to-binary-string/test/test.js b/lib/node_modules/@stdlib/number/uint16/base/to-binary-string/test/test.js
index 89ac0be39697..a9646e0970e6 100644
--- a/lib/node_modules/@stdlib/number/uint16/base/to-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint16/base/to-binary-string/test/test.js
@@ -91,7 +91,7 @@ tape( 'the function will accept floating-point values, but will interpret the va
 
 	for ( i = 0; i < values.length; i++ ) {
 		str = toBinaryString( values[i] );
-		t.strictEqual( typeof str, 'string', 'returns a string' );
+		t.strictEqual( typeof str, 'string', 'returns expected value' );
 		t.strictEqual( str.length, 16, 'returns a string of length 16' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/uint32/base/to-binary-string/test/test.js b/lib/node_modules/@stdlib/number/uint32/base/to-binary-string/test/test.js
index d03280829a05..05318d7edc82 100644
--- a/lib/node_modules/@stdlib/number/uint32/base/to-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint32/base/to-binary-string/test/test.js
@@ -123,7 +123,7 @@ tape( 'the function will accept floating-point values, but will interpret the va
 
 	for ( i = 0; i < values.length; i++ ) {
 		str = toBinaryString( values[i] );
-		t.strictEqual( typeof str, 'string', 'returns a string' );
+		t.strictEqual( typeof str, 'string', 'returns expected value' );
 		t.strictEqual( str.length, 32, 'returns a string of length 32' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/number/uint8/base/to-binary-string/test/test.js b/lib/node_modules/@stdlib/number/uint8/base/to-binary-string/test/test.js
index 8ec08c8661d6..d569b615e146 100644
--- a/lib/node_modules/@stdlib/number/uint8/base/to-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint8/base/to-binary-string/test/test.js
@@ -91,7 +91,7 @@ tape( 'the function will accept floating-point values, but will interpret the va
 
 	for ( i = 0; i < values.length; i++ ) {
 		str = bits( values[i] );
-		t.strictEqual( typeof str, 'string', 'returns a string' );
+		t.strictEqual( typeof str, 'string', 'returns expected value' );
 		t.strictEqual( str.length, 8, 'returns a string of length 8' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/object/every-in-by/test/test.js b/lib/node_modules/@stdlib/object/every-in-by/test/test.js
index 8054c6291120..88c0ed85aa21 100644
--- a/lib/node_modules/@stdlib/object/every-in-by/test/test.js
+++ b/lib/node_modules/@stdlib/object/every-in-by/test/test.js
@@ -172,6 +172,6 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = everyInBy( obj, sum, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/object/every-own-by/test/test.js b/lib/node_modules/@stdlib/object/every-own-by/test/test.js
index 992a865add47..5bc3946f90d6 100644
--- a/lib/node_modules/@stdlib/object/every-own-by/test/test.js
+++ b/lib/node_modules/@stdlib/object/every-own-by/test/test.js
@@ -109,7 +109,7 @@ tape( 'if provided an empty object, the function returns `true`', function test(
 	obj = {};
 	bool = everyOwnBy( obj, foo );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -125,7 +125,7 @@ tape( 'the function returns `true` if all properties pass a test', function test
 
 	bool = everyOwnBy( obj, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -141,7 +141,7 @@ tape( 'the function returns `false` if one or more properties fail a test', func
 
 	bool = everyOwnBy( obj, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -172,7 +172,7 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = everyOwnBy( obj, sum, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( ctx.sum/ctx.count, 2.0, 'expected result' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/object/none-in-by/test/test.js b/lib/node_modules/@stdlib/object/none-in-by/test/test.js
index bda22ab0a4ea..8f33b0e2f285 100644
--- a/lib/node_modules/@stdlib/object/none-in-by/test/test.js
+++ b/lib/node_modules/@stdlib/object/none-in-by/test/test.js
@@ -99,7 +99,7 @@ tape( 'if provided an empty object, the function returns `true`', function test(
 
 	bool = noneInBy( obj, foo );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -114,7 +114,7 @@ tape('the function returns `true` if every property fails a test ', function tes
 
 	bool = noneInBy( obj, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -128,7 +128,7 @@ tape( 'the function returns `false` if one or more properties pass a test ', fun
 
 	bool = noneInBy( obj, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -159,7 +159,7 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = noneInBy( obj, sum, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( ctx.sum / ctx.count, 2.0, 'expected result' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/object/some-in-by/test/test.js b/lib/node_modules/@stdlib/object/some-in-by/test/test.js
index f3a36a552731..3d345b2320f5 100644
--- a/lib/node_modules/@stdlib/object/some-in-by/test/test.js
+++ b/lib/node_modules/@stdlib/object/some-in-by/test/test.js
@@ -151,7 +151,7 @@ tape( 'if provided an empty object, the function returns `false`', function test
 	obj = {};
 	bool = someInBy( obj, 1, foo );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -168,7 +168,7 @@ tape( 'the function returns `true` if an object contains at least `n` properties
 
 	bool = someInBy( obj, 2, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -184,7 +184,7 @@ tape( 'the function returns `false` if an object does not contain at least `n` p
 
 	bool = someInBy( obj, 1, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -200,7 +200,7 @@ tape( 'the function returns `false` if an object does not contain at least `n` p
 
 	bool = someInBy( obj, 2, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -229,7 +229,7 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = someInBy( obj, 2, sum, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( ctx.sum/ctx.count, 0.25, 'expected result' );
 
 	t.end();
@@ -260,7 +260,7 @@ tape( 'the function provides basic support for dynamic objects', function test(
 		'c': 3,
 		'd': 2
 	}, 'expected result' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -292,7 +292,7 @@ tape( 'the function does not skip undefined properties', function test( t ) {
 
 	bool = someInBy( obj, 1, verify );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/os/tmpdir/test/test.js b/lib/node_modules/@stdlib/os/tmpdir/test/test.js
index 834f83671355..60a7ac2456c6 100644
--- a/lib/node_modules/@stdlib/os/tmpdir/test/test.js
+++ b/lib/node_modules/@stdlib/os/tmpdir/test/test.js
@@ -34,7 +34,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function returns a string', function test( t ) {
-	t.strictEqual( typeof tmpdir(), 'string', 'returns a string' );
+	t.strictEqual( typeof tmpdir(), 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/process/read-stdin/test/test.js b/lib/node_modules/@stdlib/process/read-stdin/test/test.js
index 4a77f79aaf96..df8920bbd2ee 100644
--- a/lib/node_modules/@stdlib/process/read-stdin/test/test.js
+++ b/lib/node_modules/@stdlib/process/read-stdin/test/test.js
@@ -121,7 +121,7 @@ tape( 'if `stdin` is run in TTY mode and the encoding is not set, the function r
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isBuffer( data ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( data ), true, 'returns expected value' );
 		t.strictEqual( data.length, 0, 'buffer is empty' );
 		t.end();
 	}
@@ -146,7 +146,7 @@ tape( 'if `stdin` is run in TTY mode and the encoding is set, the function retur
 			t.ok( false, error.message );
 		}
 		t.strictEqual( isBuffer( data ), false, 'does not return a buffer' );
-		t.strictEqual( typeof data, 'string', 'returns a string' );
+		t.strictEqual( typeof data, 'string', 'returns expected value' );
 		t.strictEqual( data.length, 0, 'string is empty' );
 		t.end();
 	}
@@ -223,7 +223,7 @@ tape( 'if the `encoding` argument is not set, the function returns `stdin` data
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isBuffer( data ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( data ), true, 'returns expected value' );
 		t.strictEqual( data.toString(), 'beep boop', 'returns `stdin` data' );
 		t.end();
 	}
@@ -252,7 +252,7 @@ tape( 'if the `encoding` argument is not set, the function returns `stdin` data
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isBuffer( data ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( data ), true, 'returns expected value' );
 		t.strictEqual( data.toString(), 'beep boop', 'returns `stdin` data' );
 		t.end();
 	}
@@ -282,7 +282,7 @@ tape( 'if the `encoding` argument is set, the function returns `stdin` data as a
 			t.ok( false, error.message );
 		}
 		t.strictEqual( isBuffer( data ), false, 'does not return a buffer' );
-		t.strictEqual( typeof data, 'string', 'returns a string' );
+		t.strictEqual( typeof data, 'string', 'returns expected value' );
 		t.strictEqual( data, 'beep boop', 'returns `stdin` data' );
 		t.end();
 	}
@@ -308,7 +308,7 @@ tape( 'if the `encoding` argument is not set and no `stdin` data, the function r
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isBuffer( data ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( data ), true, 'returns expected value' );
 		t.strictEqual( data.length, 0, 'returns an empty buffer' );
 		t.strictEqual( data.toString(), '', 'buffer is empty' );
 		t.end();
@@ -336,7 +336,7 @@ tape( 'if the `encoding` argument is set and no `stdin` data, the function retur
 			t.ok( false, error.message );
 		}
 		t.strictEqual( isBuffer( data ), false, 'does not return a buffer' );
-		t.strictEqual( typeof data, 'string', 'returns a string' );
+		t.strictEqual( typeof data, 'string', 'returns expected value' );
 		t.strictEqual( data, '', 'returns empty string' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/process/umask/test/test.browser.js b/lib/node_modules/@stdlib/process/umask/test/test.browser.js
index 6a3320f883ab..3144d1dc3196 100644
--- a/lib/node_modules/@stdlib/process/umask/test/test.browser.js
+++ b/lib/node_modules/@stdlib/process/umask/test/test.browser.js
@@ -270,14 +270,14 @@ tape( 'if provided an expression mask, the function throws an error if unable to
 
 tape( 'if not provided any arguments, the function returns the process mask', function test( t ) {
 	var expected = 0;
-	t.strictEqual( typeof expected, 'number', 'returns a number' );
+	t.strictEqual( typeof expected, 'number', 'returns expected value' );
 	t.strictEqual( umask(), expected, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function ignores unrecognized/unsupported options and returns the process mask', function test( t ) {
 	var expected = 0;
-	t.strictEqual( typeof expected, 'number', 'returns a number' );
+	t.strictEqual( typeof expected, 'number', 'returns expected value' );
 	t.strictEqual( umask( {} ), expected, 'returns expected value' );
 	restore();
 	t.end();
@@ -309,7 +309,7 @@ tape( 'if the `symbolic` option is `false`, the function returns the process mas
 	};
 	mask = umask( opts );
 
-	t.strictEqual( typeof mask, 'number', 'returns a number' );
+	t.strictEqual( typeof mask, 'number', 'returns expected value' );
 	t.strictEqual( mask, 0, 'returns expected value' );
 
 	restore();
@@ -339,7 +339,7 @@ tape( 'if provided a nonnegative integer and the `symbolic` option is `false`, t
 	};
 	for ( i = 100; i < 200; i++ ) {
 		old = umask( opts );
-		t.strictEqual( typeof old, 'number', 'returns a number' );
+		t.strictEqual( typeof old, 'number', 'returns expected value' );
 		t.strictEqual( umask( i, opts ), old, 'returns previous mask' );
 		t.strictEqual( umask( opts ), 0, 'returns expected value' );
 	}
@@ -358,7 +358,7 @@ tape( 'if provided a nonnegative integer and the `symbolic` option is `true`, th
 	};
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask( opts );
-		t.strictEqual( typeof old, 'string', 'returns a string' );
+		t.strictEqual( typeof old, 'string', 'returns expected value' );
 
 		mask = umask( i, opts );
 		t.strictEqual( mask, old, 'returns previous mask' );
@@ -376,7 +376,7 @@ tape( 'if provided an expression mask, the function sets the process mask and re
 
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask();
-		t.strictEqual( typeof old, 'number', 'returns a number' );
+		t.strictEqual( typeof old, 'number', 'returns expected value' );
 
 		mask = INT_TO_SYMBOLIC[ i ];
 		t.strictEqual( umask( mask ), old, 'returns previous mask' );
@@ -398,7 +398,7 @@ tape( 'if provided an expression mask and the `symbolic` option is `false`, the
 	};
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask( opts );
-		t.strictEqual( typeof old, 'number', 'returns a number' );
+		t.strictEqual( typeof old, 'number', 'returns expected value' );
 
 		mask = INT_TO_SYMBOLIC[ i ];
 		t.strictEqual( umask( mask, opts ), old, 'returns previous mask' );
@@ -421,7 +421,7 @@ tape( 'if provided an expression mask, the function supports setting the process
 
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask( opts );
-		t.strictEqual( typeof old, 'string', 'returns a string' );
+		t.strictEqual( typeof old, 'string', 'returns expected value' );
 
 		mask = INT_TO_SYMBOLIC[ i ];
 		t.strictEqual( umask( mask, opts ), old, 'returns previous mask' );
diff --git a/lib/node_modules/@stdlib/process/umask/test/test.js b/lib/node_modules/@stdlib/process/umask/test/test.js
index 79594aed5f6c..c300707f9682 100644
--- a/lib/node_modules/@stdlib/process/umask/test/test.js
+++ b/lib/node_modules/@stdlib/process/umask/test/test.js
@@ -297,14 +297,14 @@ tape( 'if provided an expression mask, the function throws an error if unable to
 
 tape( 'if not provided any arguments, the function returns the process mask', opts, function test( t ) {
 	var expected = proc.umask();
-	t.strictEqual( typeof expected, 'number', 'returns a number' );
+	t.strictEqual( typeof expected, 'number', 'returns expected value' );
 	t.strictEqual( umask(), expected, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function ignores unrecognized/unsupported options and returns the process mask', opts, function test( t ) {
 	var expected = proc.umask();
-	t.strictEqual( typeof expected, 'number', 'returns a number' );
+	t.strictEqual( typeof expected, 'number', 'returns expected value' );
 	t.strictEqual( umask( {} ), expected, 'returns expected value' );
 	restore();
 	t.end();
@@ -339,7 +339,7 @@ tape( 'if the `symbolic` option is `false`, the function returns the process mas
 	};
 	mask = umask( opts );
 
-	t.strictEqual( typeof mask, 'number', 'returns a number' );
+	t.strictEqual( typeof mask, 'number', 'returns expected value' );
 	t.strictEqual( mask, proc.umask(), 'returns expected value' );
 
 	restore();
@@ -369,7 +369,7 @@ tape( 'if provided a nonnegative integer and the `symbolic` option is `false`, t
 	};
 	for ( i = 100; i < 200; i++ ) {
 		old = umask( opts );
-		t.strictEqual( typeof old, 'number', 'returns a number' );
+		t.strictEqual( typeof old, 'number', 'returns expected value' );
 		t.strictEqual( umask( i, opts ), old, 'returns previous mask' );
 		t.strictEqual( umask( opts ), i, 'returns expected value' );
 	}
@@ -388,7 +388,7 @@ tape( 'if provided a nonnegative integer and the `symbolic` option is `true`, th
 	};
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask( opts );
-		t.strictEqual( typeof old, 'string', 'returns a string' );
+		t.strictEqual( typeof old, 'string', 'returns expected value' );
 
 		mask = umask( i, opts );
 		t.strictEqual( mask, old, 'returns previous mask' );
@@ -406,7 +406,7 @@ tape( 'if provided an expression mask, the function sets the process mask and re
 
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask();
-		t.strictEqual( typeof old, 'number', 'returns a number' );
+		t.strictEqual( typeof old, 'number', 'returns expected value' );
 
 		mask = INT_TO_SYMBOLIC[ i ];
 		t.strictEqual( umask( mask ), old, 'returns previous mask' );
@@ -428,7 +428,7 @@ tape( 'if provided an expression mask and the `symbolic` option is `false`, the
 	};
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask( opts );
-		t.strictEqual( typeof old, 'number', 'returns a number' );
+		t.strictEqual( typeof old, 'number', 'returns expected value' );
 
 		mask = INT_TO_SYMBOLIC[ i ];
 		t.strictEqual( umask( mask, opts ), old, 'returns previous mask' );
@@ -451,7 +451,7 @@ tape( 'if provided an expression mask, the function supports setting the process
 
 	for ( i = 0; i < BINARY_SYMBOLIC.length; i++ ) {
 		old = umask( opts );
-		t.strictEqual( typeof old, 'string', 'returns a string' );
+		t.strictEqual( typeof old, 'string', 'returns expected value' );
 
 		mask = INT_TO_SYMBOLIC[ i ];
 		t.strictEqual( umask( mask, opts ), old, 'returns previous mask' );
diff --git a/lib/node_modules/@stdlib/random/base/arcsine/test/test.factory.js b/lib/node_modules/@stdlib/random/base/arcsine/test/test.factory.js
index fe2fbfb4f4f4..1ad3460c0c3e 100644
--- a/lib/node_modules/@stdlib/random/base/arcsine/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/arcsine/test/test.factory.js
@@ -393,14 +393,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	arcsine = factory( -10.0, 10.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = arcsine();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	arcsine = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = arcsine( -10.0, 10.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -588,7 +588,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	arcsine = factory();
 	r = arcsine( NaN, 5.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -599,7 +599,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	arcsine = factory();
 	r = arcsine( 0.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -610,7 +610,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	arcsine = factory();
 	r = arcsine( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -645,7 +645,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = arcsine();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -661,7 +661,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = arcsine( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/arcsine/test/test.js b/lib/node_modules/@stdlib/random/base/arcsine/test/test.js
index e70a549cb3f9..fc347ab7a4ab 100644
--- a/lib/node_modules/@stdlib/random/base/arcsine/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/arcsine/test/test.js
@@ -88,7 +88,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	b = 4.0;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = arcsine( a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/bernoulli/test/test.factory.js b/lib/node_modules/@stdlib/random/base/bernoulli/test/test.factory.js
index a4fe197c0606..bed6d1b6d495 100644
--- a/lib/node_modules/@stdlib/random/base/bernoulli/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/bernoulli/test/test.factory.js
@@ -375,14 +375,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	bernoulli = factory( 0.05 );
 	for ( i = 0; i < 100; i++ ) {
 		r = bernoulli();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	bernoulli = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = bernoulli( 0.1 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -571,7 +571,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	bernoulli = factory();
 	r = bernoulli( NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -582,13 +582,13 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	bernoulli = factory();
 
 	r = bernoulli( 3.14 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = bernoulli( -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = bernoulli( -3.14 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -604,7 +604,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = bernoulli();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -620,7 +620,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = bernoulli( 0.3 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/beta/test/test.factory.js b/lib/node_modules/@stdlib/random/base/beta/test/test.factory.js
index beb47e7d6056..57723b265e50 100644
--- a/lib/node_modules/@stdlib/random/base/beta/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/beta/test/test.factory.js
@@ -516,19 +516,19 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	beta = factory( 2.0, 2.0 );
 	for ( i = 0; i < 1e3; i++ ) {
 		r = beta();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	beta = factory( 30.0, 30.0 );
 	for ( i = 0; i < 1e3; i++ ) {
 		r = beta();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	beta = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		r = beta( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -771,7 +771,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	beta = factory();
 	r = beta( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -782,7 +782,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	beta = factory();
 	r = beta( 1.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -793,7 +793,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	beta = factory();
 	r = beta( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -804,10 +804,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	beta = factory();
 
 	r = beta( 0.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = beta( -1.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -819,10 +819,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	beta = factory();
 
 	r = beta( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = beta( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -893,7 +893,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = beta();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -909,7 +909,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = beta( 1.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/beta/test/test.js b/lib/node_modules/@stdlib/random/base/beta/test/test.js
index a7a1391c6014..925dbdd33030 100644
--- a/lib/node_modules/@stdlib/random/base/beta/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/beta/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		r = beta( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r >= 0.0, true, 'returns a nonnegative number' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/betaprime/test/test.factory.js b/lib/node_modules/@stdlib/random/base/betaprime/test/test.factory.js
index bf4109e5efde..f24b1fc88fc3 100644
--- a/lib/node_modules/@stdlib/random/base/betaprime/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/betaprime/test/test.factory.js
@@ -375,19 +375,19 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	betaprime = factory( 2.0, 2.0 );
 	for ( i = 0; i < 400; i++ ) {
 		r = betaprime();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	betaprime = factory( 30.0, 30.0 );
 	for ( i = 0; i < 400; i++ ) {
 		r = betaprime();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	betaprime = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = betaprime( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -630,7 +630,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	betaprime = factory();
 	r = betaprime( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -641,7 +641,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	betaprime = factory();
 	r = betaprime( 1.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -652,7 +652,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	betaprime = factory();
 	r = betaprime( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -663,10 +663,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	betaprime = factory();
 
 	r = betaprime( 0.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = betaprime( -1.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -678,10 +678,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	betaprime = factory();
 
 	r = betaprime( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = betaprime( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -697,7 +697,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = betaprime();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -713,7 +713,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = betaprime( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/betaprime/test/test.js b/lib/node_modules/@stdlib/random/base/betaprime/test/test.js
index dff786bee320..a3afcadd0d86 100644
--- a/lib/node_modules/@stdlib/random/base/betaprime/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/betaprime/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = betaprime( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r >= 0.0, true, 'returns a nonnegative number' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/binomial/test/test.factory.js b/lib/node_modules/@stdlib/random/base/binomial/test/test.factory.js
index 7cb53c25b6dd..e389fd82e33d 100644
--- a/lib/node_modules/@stdlib/random/base/binomial/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/binomial/test/test.factory.js
@@ -377,14 +377,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	binomial = factory( 80, 0.05 );
 	for ( i = 0; i < 100; i++ ) {
 		r = binomial();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	binomial = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = binomial( 120, 0.75 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -671,7 +671,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	binomial = factory();
 	r = binomial( NaN, 0.5 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -682,7 +682,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	binomial = factory();
 	r = binomial( 2, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -693,7 +693,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	binomial = factory();
 	r = binomial( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -704,13 +704,13 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	binomial = factory();
 
 	r = binomial( 3.14, 0.5 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = binomial( 0.0, 0.5 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = binomial( -1.0, 0.5 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -722,13 +722,13 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	binomial = factory();
 
 	r = binomial( 2, 3.14 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = binomial( 2, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = binomial( 2, 1.5 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -744,7 +744,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = binomial();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -760,7 +760,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = binomial( 10, 0.3 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/box-muller/test/test.factory.js b/lib/node_modules/@stdlib/random/base/box-muller/test/test.factory.js
index 81d5ebe5bd59..9cd9cb2c991c 100644
--- a/lib/node_modules/@stdlib/random/base/box-muller/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/box-muller/test/test.factory.js
@@ -255,7 +255,7 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	randn = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -268,7 +268,7 @@ tape( 'the function returns a pseudorandom number generator (options; no seed)',
 	randn = factory( {} );
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -538,7 +538,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/box-muller/test/test.js b/lib/node_modules/@stdlib/random/base/box-muller/test/test.js
index 6b7554f9a85d..e0f9b43d483c 100644
--- a/lib/node_modules/@stdlib/random/base/box-muller/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/box-muller/test/test.js
@@ -95,7 +95,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/cauchy/test/test.factory.js b/lib/node_modules/@stdlib/random/base/cauchy/test/test.factory.js
index 55702664c9e2..c1dc6b3e21cb 100644
--- a/lib/node_modules/@stdlib/random/base/cauchy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/cauchy/test/test.factory.js
@@ -373,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	cauchy = factory( 2.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = cauchy();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	cauchy = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = cauchy( 2.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -569,7 +569,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	cauchy = factory();
 	r = cauchy( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -580,7 +580,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	cauchy = factory();
 	r = cauchy( 0.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -591,7 +591,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	cauchy = factory();
 	r = cauchy( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -602,10 +602,10 @@ tape( 'when called without parameters, the function returns a PRNG that returns
 	cauchy = factory();
 
 	r = cauchy( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = cauchy( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -621,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = cauchy();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -637,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = cauchy( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/cauchy/test/test.js b/lib/node_modules/@stdlib/random/base/cauchy/test/test.js
index 103eaf02cf47..7b52ab423c12 100644
--- a/lib/node_modules/@stdlib/random/base/cauchy/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/cauchy/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = cauchy( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/chi/test/test.factory.js b/lib/node_modules/@stdlib/random/base/chi/test/test.factory.js
index 25f21a8618a0..969a918e3b06 100644
--- a/lib/node_modules/@stdlib/random/base/chi/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/chi/test/test.factory.js
@@ -373,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	chi = factory( 2 );
 	for ( i = 0; i < 100; i++ ) {
 		r = chi();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameter...
 	chi = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = chi( 100.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -569,7 +569,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	chi = factory();
 	r = chi( NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -580,13 +580,13 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	chi = factory();
 
 	r = chi( 0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = chi( -1 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = chi( -3.14 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -602,7 +602,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = chi();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -618,7 +618,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = chi( 4 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/chi/test/test.js b/lib/node_modules/@stdlib/random/base/chi/test/test.js
index 8d65823c576e..6efc115bf922 100644
--- a/lib/node_modules/@stdlib/random/base/chi/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/chi/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = chi( 3.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/chisquare/test/test.factory.js b/lib/node_modules/@stdlib/random/base/chisquare/test/test.factory.js
index 268aab995cef..b873e27733ef 100644
--- a/lib/node_modules/@stdlib/random/base/chisquare/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/chisquare/test/test.factory.js
@@ -373,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	chisquare = factory( 2 );
 	for ( i = 0; i < 100; i++ ) {
 		r = chisquare();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameter...
 	chisquare = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = chisquare( 100.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -569,7 +569,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	chisquare = factory();
 	r = chisquare( NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -580,13 +580,13 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	chisquare = factory();
 
 	r = chisquare( 0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = chisquare( -1 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = chisquare( -3.14 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -602,7 +602,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = chisquare();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -618,7 +618,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = chisquare( 10 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/chisquare/test/test.js b/lib/node_modules/@stdlib/random/base/chisquare/test/test.js
index ba06c5d82d97..29fff281786e 100644
--- a/lib/node_modules/@stdlib/random/base/chisquare/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/chisquare/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = chisquare( 3.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/cosine/test/test.factory.js b/lib/node_modules/@stdlib/random/base/cosine/test/test.factory.js
index 5b60e3c91f7f..35e59cd32a0a 100644
--- a/lib/node_modules/@stdlib/random/base/cosine/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/cosine/test/test.factory.js
@@ -373,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	cosine = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = cosine();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	cosine = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = cosine( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -569,7 +569,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	cosine = factory();
 	r = cosine( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -580,7 +580,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	cosine = factory();
 	r = cosine( 0.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -591,7 +591,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	cosine = factory();
 	r = cosine( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -602,10 +602,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	cosine = factory();
 
 	r = cosine( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = cosine( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -621,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = cosine();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -637,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = cosine( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/cosine/test/test.js b/lib/node_modules/@stdlib/random/base/cosine/test/test.js
index 05a97b39f0f1..1ebce1824b5e 100644
--- a/lib/node_modules/@stdlib/random/base/cosine/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/cosine/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = cosine( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.discrete_uniform.js b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.discrete_uniform.js
index 4c93ed51b0a9..44fb3b2692d7 100644
--- a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.discrete_uniform.js
+++ b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.discrete_uniform.js
@@ -68,7 +68,7 @@ tape( 'the function returns pseudorandom numbers (smaller range)', function test
 	b = 40;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
@@ -90,7 +90,7 @@ tape( 'the function returns pseudorandom numbers (smaller range)', function test
 	b = 40;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
@@ -114,7 +114,7 @@ tape( 'the function returns pseudorandom numbers (smaller range)', function test
 	b = 3;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
@@ -131,7 +131,7 @@ tape( 'the function returns pseudorandom numbers (smaller range)', function test
 	b = floor( randi.MAX/2 ) + 1; // high likelihood of sampling rejection
 	for ( i = 0; i < 1e3; i++ ) {
 		r = rand( randi, a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
@@ -148,7 +148,7 @@ tape( 'the function returns pseudorandom numbers (equal range)', function test(
 	b = randi.MAX + 101;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
@@ -168,7 +168,7 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 	b = 10;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
@@ -193,7 +193,7 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
@@ -218,7 +218,7 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
@@ -238,7 +238,7 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 	b = 1e2 + 3;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
@@ -259,7 +259,7 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
@@ -284,7 +284,7 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
diff --git a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.factory.js b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.factory.js
index 551ad7c61e15..5544fdaa00e6 100644
--- a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.factory.js
@@ -544,7 +544,7 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	discreteUniform = factory( -100, 100 );
 	for ( i = 0; i < 100; i++ ) {
 		r = discreteUniform();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 	}
 
@@ -552,7 +552,7 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	discreteUniform = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = discreteUniform( -100, 100 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 	}
 	t.end();
@@ -741,7 +741,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	discreteUniform = factory();
 	r = discreteUniform( NaN, 50 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -752,7 +752,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	discreteUniform = factory();
 	r = discreteUniform( 0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -763,7 +763,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	discreteUniform = factory();
 	r = discreteUniform( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -774,7 +774,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	discreteUniform = factory();
 	r = discreteUniform( 3.14, 50 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -785,7 +785,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	discreteUniform = factory();
 	r = discreteUniform( 0, 3.14 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -796,7 +796,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	discreteUniform = factory();
 	r = discreteUniform( -3.14, 3.14 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -878,7 +878,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = discreteUniform();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -894,7 +894,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = discreteUniform( 1, 10 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.js b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.js
index 3ca6c03bd1e1..64716015fde6 100644
--- a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.js
@@ -89,7 +89,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	b = 40;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = discreteUniform( a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( r ), true, 'returns an integer' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
diff --git a/lib/node_modules/@stdlib/random/base/erlang/test/test.factory.js b/lib/node_modules/@stdlib/random/base/erlang/test/test.factory.js
index d4389b2dae5e..ddda34b1f711 100644
--- a/lib/node_modules/@stdlib/random/base/erlang/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/erlang/test/test.factory.js
@@ -376,14 +376,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	erlang = factory( 2, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = erlang();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	erlang = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = erlang( 2, 2.5 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -572,7 +572,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	erlang = factory();
 	r = erlang( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -583,7 +583,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	erlang = factory();
 	r = erlang( 1, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -594,7 +594,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	erlang = factory();
 	r = erlang( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -605,10 +605,10 @@ tape( 'when called without parameters, the function returns a PRNG that returns
 	erlang = factory();
 
 	r = erlang( 0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = erlang( -1, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -620,10 +620,10 @@ tape( 'when called without parameters, the function returns a PRNG that returns
 	erlang = factory();
 
 	r = erlang( 1, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = erlang( 1, -3.14 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -639,7 +639,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = erlang();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -655,7 +655,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = erlang( 2, 4.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/erlang/test/test.js b/lib/node_modules/@stdlib/random/base/erlang/test/test.js
index da5a181cbe78..8df468f1f482 100644
--- a/lib/node_modules/@stdlib/random/base/erlang/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/erlang/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = erlang( 2, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/exponential/test/test.factory.js b/lib/node_modules/@stdlib/random/base/exponential/test/test.factory.js
index 14091b14d920..92f26bf2bb03 100644
--- a/lib/node_modules/@stdlib/random/base/exponential/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/exponential/test/test.factory.js
@@ -373,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	exponential = factory( 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = exponential();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameter...
 	exponential = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = exponential( 100.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -569,7 +569,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	exponential = factory();
 	r = exponential( NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -580,13 +580,13 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	exponential = factory();
 
 	r = exponential( 0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = exponential( -1 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = exponential( -3.14 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -602,7 +602,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = exponential();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -618,7 +618,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = exponential( 10.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/exponential/test/test.js b/lib/node_modules/@stdlib/random/base/exponential/test/test.js
index 60f3502852f5..f7fa977dcdd9 100644
--- a/lib/node_modules/@stdlib/random/base/exponential/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/exponential/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = exponential( 3.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r >= 0.0, true, 'returns a nonnegative number' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/f/test/test.factory.js b/lib/node_modules/@stdlib/random/base/f/test/test.factory.js
index 3811541ae1dd..54e590547532 100644
--- a/lib/node_modules/@stdlib/random/base/f/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/f/test/test.factory.js
@@ -375,14 +375,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	f = factory( 2.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = f();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	f = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = f( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -571,7 +571,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	f = factory();
 	r = f( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -582,7 +582,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	f = factory();
 	r = f( 1.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -593,7 +593,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	f = factory();
 	r = f( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -604,10 +604,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	f = factory();
 
 	r = f( 0.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = f( -1.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -619,10 +619,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	f = factory();
 
 	r = f( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = f( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -638,7 +638,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = f();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -654,7 +654,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = f( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/f/test/test.js b/lib/node_modules/@stdlib/random/base/f/test/test.js
index 81e182f9282e..c119e64f5607 100644
--- a/lib/node_modules/@stdlib/random/base/f/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/f/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = f( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r >= 0.0, true, 'returns a nonnegative number' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/frechet/test/test.factory.js b/lib/node_modules/@stdlib/random/base/frechet/test/test.factory.js
index c290f95c59cb..60772b2d11bc 100644
--- a/lib/node_modules/@stdlib/random/base/frechet/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/frechet/test/test.factory.js
@@ -403,14 +403,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	frechet = factory( 10.0, 10.0, 5.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = frechet();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	frechet = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = frechet( 10.0, 10.0, 5.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -599,7 +599,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	frechet = factory();
 	r = frechet( NaN, 5.0, 2.5 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -610,7 +610,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	frechet = factory();
 	r = frechet( 1.0, NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -621,7 +621,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	frechet = factory();
 	r = frechet( 10.0, 10.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -632,7 +632,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	frechet = factory();
 	r = frechet( NaN, NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -647,7 +647,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = frechet();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -663,7 +663,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = frechet( 2.0, 4.0, -1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/frechet/test/test.js b/lib/node_modules/@stdlib/random/base/frechet/test/test.js
index 6891c598df4c..8585e2f0b35e 100644
--- a/lib/node_modules/@stdlib/random/base/frechet/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/frechet/test/test.js
@@ -90,7 +90,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	m = 10.0;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = frechet( alpha, s, m );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r >= m, true, 'within support: '+r );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/gamma/test/test.factory.js b/lib/node_modules/@stdlib/random/base/gamma/test/test.factory.js
index 01af04b0e6a0..f1f52499fcd3 100644
--- a/lib/node_modules/@stdlib/random/base/gamma/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/gamma/test/test.factory.js
@@ -516,14 +516,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	gamma = factory( 2.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = gamma();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	gamma = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = gamma( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -712,7 +712,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	gamma = factory();
 	r = gamma( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -723,7 +723,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	gamma = factory();
 	r = gamma( 1.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -734,7 +734,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	gamma = factory();
 	r = gamma( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -745,10 +745,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	gamma = factory();
 
 	r = gamma( 0.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = gamma( -1.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -760,10 +760,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	gamma = factory();
 
 	r = gamma( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = gamma( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -834,7 +834,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = gamma();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -850,7 +850,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = gamma( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/gamma/test/test.js b/lib/node_modules/@stdlib/random/base/gamma/test/test.js
index 1e9d7ab191f3..e839cbcc9c6b 100644
--- a/lib/node_modules/@stdlib/random/base/gamma/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/gamma/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers (when `alpha >= 1`)', function
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = gamma( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r > 0.0, true, 'returns a positive number' );
 	}
 	t.end();
@@ -94,7 +94,7 @@ tape( 'the function returns pseudorandom numbers (when `alpha < 1`)', function t
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = gamma( 0.05, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r > 0.0, true, 'returns a positive number' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/geometric/test/test.factory.js b/lib/node_modules/@stdlib/random/base/geometric/test/test.factory.js
index b667f3a23572..afb149ecae24 100644
--- a/lib/node_modules/@stdlib/random/base/geometric/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/geometric/test/test.factory.js
@@ -375,14 +375,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	geometric = factory( 0.05 );
 	for ( i = 0; i < 100; i++ ) {
 		r = geometric();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	geometric = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = geometric( 0.1 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -571,7 +571,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	geometric = factory();
 	r = geometric( NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -582,13 +582,13 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	geometric = factory();
 
 	r = geometric( 3.14 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = geometric( -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = geometric( -3.14 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -604,7 +604,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = geometric();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -620,7 +620,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = geometric( 0.3 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/gumbel/test/test.factory.js b/lib/node_modules/@stdlib/random/base/gumbel/test/test.factory.js
index 0d1d061cad94..190bccac516c 100644
--- a/lib/node_modules/@stdlib/random/base/gumbel/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/gumbel/test/test.factory.js
@@ -373,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	gumbel = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = gumbel();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	gumbel = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = gumbel( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -569,7 +569,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	gumbel = factory();
 	r = gumbel( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -580,7 +580,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	gumbel = factory();
 	r = gumbel( 0.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -591,7 +591,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	gumbel = factory();
 	r = gumbel( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -602,10 +602,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	gumbel = factory();
 
 	r = gumbel( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = gumbel( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -621,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = gumbel();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -637,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = gumbel( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/gumbel/test/test.js b/lib/node_modules/@stdlib/random/base/gumbel/test/test.js
index 2df1e272b747..7f3af5ea0e28 100644
--- a/lib/node_modules/@stdlib/random/base/gumbel/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/gumbel/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = gumbel( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/hypergeometric/test/test.factory.js b/lib/node_modules/@stdlib/random/base/hypergeometric/test/test.factory.js
index 5c2e908cb247..0f20c6d12561 100644
--- a/lib/node_modules/@stdlib/random/base/hypergeometric/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/hypergeometric/test/test.factory.js
@@ -451,14 +451,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	hypergeometric = factory( 80, 50, 30 );
 	for ( i = 0; i < 100; i++ ) {
 		r = hypergeometric();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	hypergeometric = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = hypergeometric( 80, 50, 30 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -647,7 +647,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	hypergeometric = factory();
 	r = hypergeometric( NaN, 10, 5 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -658,7 +658,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	hypergeometric = factory();
 	r = hypergeometric( 10, NaN, 5 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -669,7 +669,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	hypergeometric = factory();
 	r = hypergeometric( 10, 10, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -680,7 +680,7 @@ tape( 'when called without arguments, the function returns a PRNG provided all `
 	hypergeometric = factory();
 	r = hypergeometric( NaN, NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -691,7 +691,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	hypergeometric = factory();
 	r = hypergeometric( 13.14, 10, 5 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -702,7 +702,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	hypergeometric = factory();
 	r = hypergeometric( 10, 9.99, 5 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -713,7 +713,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	hypergeometric = factory();
 	r = hypergeometric( 10, 10, 3.5 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -724,7 +724,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	hypergeometric = factory();
 	r = hypergeometric( 10, 10, 11 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -739,7 +739,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = hypergeometric();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -755,7 +755,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = hypergeometric( 100, 25, 7 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.factory.js b/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.factory.js
index b923f2c7394f..9ce826a4f547 100644
--- a/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.factory.js
@@ -255,7 +255,7 @@ tape( 'the function returns a pseudorandom number generator', function test( t )
 	randn = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -268,7 +268,7 @@ tape( 'the function returns a pseudorandom number generator (options; no seed)',
 	randn = factory( {} );
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -509,7 +509,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.js b/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.js
index af5020bfd34c..3259bced7db3 100644
--- a/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/improved-ziggurat/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		r = randn();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/invgamma/test/test.factory.js b/lib/node_modules/@stdlib/random/base/invgamma/test/test.factory.js
index 9a828d8674a0..a206dad41523 100644
--- a/lib/node_modules/@stdlib/random/base/invgamma/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/invgamma/test/test.factory.js
@@ -375,14 +375,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	invgamma = factory( 2.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = invgamma();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	invgamma = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = invgamma( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -571,7 +571,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	invgamma = factory();
 	r = invgamma( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -582,7 +582,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	invgamma = factory();
 	r = invgamma( 1.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -593,7 +593,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	invgamma = factory();
 	r = invgamma( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -604,10 +604,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	invgamma = factory();
 
 	r = invgamma( 0.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = invgamma( -1.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -619,10 +619,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	invgamma = factory();
 
 	r = invgamma( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = invgamma( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -638,7 +638,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = invgamma();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -654,7 +654,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = invgamma( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/invgamma/test/test.js b/lib/node_modules/@stdlib/random/base/invgamma/test/test.js
index f3cdb3660b1f..4a5c07b3eef3 100644
--- a/lib/node_modules/@stdlib/random/base/invgamma/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/invgamma/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = invgamma( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r >= 0.0, true, 'returns a nonnegative number' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.factory.js b/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.factory.js
index 007446140c1c..e5302e9fad6c 100644
--- a/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.factory.js
@@ -375,19 +375,19 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	kumaraswamy = factory( 2.0, 2.0 );
 	for ( i = 0; i < 400; i++ ) {
 		r = kumaraswamy();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	kumaraswamy = factory( 30.0, 30.0 );
 	for ( i = 0; i < 400; i++ ) {
 		r = kumaraswamy();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	kumaraswamy = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = kumaraswamy( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -603,7 +603,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	kumaraswamy = factory();
 	r = kumaraswamy( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -614,7 +614,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	kumaraswamy = factory();
 	r = kumaraswamy( 1.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -625,7 +625,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	kumaraswamy = factory();
 	r = kumaraswamy( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -636,10 +636,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	kumaraswamy = factory();
 
 	r = kumaraswamy( 0.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = kumaraswamy( -1.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -651,10 +651,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	kumaraswamy = factory();
 
 	r = kumaraswamy( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = kumaraswamy( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -670,7 +670,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = kumaraswamy();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -686,7 +686,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = kumaraswamy( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.js b/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.js
index 71057d3d518c..019a2080d577 100644
--- a/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/kumaraswamy/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = kumaraswamy( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r >= 0.0, true, 'returns a nonnegative number' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/laplace/test/test.factory.js b/lib/node_modules/@stdlib/random/base/laplace/test/test.factory.js
index b50c3227c5cb..22512e276959 100644
--- a/lib/node_modules/@stdlib/random/base/laplace/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/laplace/test/test.factory.js
@@ -373,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	laplace = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = laplace();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	laplace = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = laplace( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -569,7 +569,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	laplace = factory();
 	r = laplace( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -580,7 +580,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	laplace = factory();
 	r = laplace( 0.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -591,7 +591,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	laplace = factory();
 	r = laplace( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -602,10 +602,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	laplace = factory();
 
 	r = laplace( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = laplace( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -621,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = laplace();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -637,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = laplace( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/laplace/test/test.js b/lib/node_modules/@stdlib/random/base/laplace/test/test.js
index 496f28fa964e..1a78b3fe4efc 100644
--- a/lib/node_modules/@stdlib/random/base/laplace/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/laplace/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = laplace( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/levy/test/test.factory.js b/lib/node_modules/@stdlib/random/base/levy/test/test.factory.js
index 7b64e78f6e8f..426b239e88f2 100644
--- a/lib/node_modules/@stdlib/random/base/levy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/levy/test/test.factory.js
@@ -373,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	levy = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = levy();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	levy = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = levy( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -569,7 +569,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	levy = factory();
 	r = levy( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -580,7 +580,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	levy = factory();
 	r = levy( 0.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -591,7 +591,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	levy = factory();
 	r = levy( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -602,10 +602,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	levy = factory();
 
 	r = levy( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = levy( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -621,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = levy();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -637,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = levy( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/levy/test/test.js b/lib/node_modules/@stdlib/random/base/levy/test/test.js
index b110fa80b3df..79343dc72089 100644
--- a/lib/node_modules/@stdlib/random/base/levy/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/levy/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = levy( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/logistic/test/test.factory.js b/lib/node_modules/@stdlib/random/base/logistic/test/test.factory.js
index 76375b12b1ef..a2539deb205e 100644
--- a/lib/node_modules/@stdlib/random/base/logistic/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/logistic/test/test.factory.js
@@ -373,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	logistic = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = logistic();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	logistic = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = logistic( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -569,7 +569,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	logistic = factory();
 	r = logistic( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -580,7 +580,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	logistic = factory();
 	r = logistic( 0.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -591,7 +591,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	logistic = factory();
 	r = logistic( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -602,10 +602,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	logistic = factory();
 
 	r = logistic( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = logistic( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -621,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = logistic();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -637,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = logistic( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/logistic/test/test.js b/lib/node_modules/@stdlib/random/base/logistic/test/test.js
index e9dbbde824d1..8072e8bf7a45 100644
--- a/lib/node_modules/@stdlib/random/base/logistic/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/logistic/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = logistic( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/lognormal/test/test.factory.js b/lib/node_modules/@stdlib/random/base/lognormal/test/test.factory.js
index 1298c6506738..f319e7a3c516 100644
--- a/lib/node_modules/@stdlib/random/base/lognormal/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/lognormal/test/test.factory.js
@@ -373,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	lognormal = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = lognormal();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	lognormal = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = lognormal( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -569,7 +569,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	lognormal = factory();
 	r = lognormal( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -580,7 +580,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	lognormal = factory();
 	r = lognormal( 0.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -591,7 +591,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	lognormal = factory();
 	r = lognormal( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -602,10 +602,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	lognormal = factory();
 
 	r = lognormal( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = lognormal( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -621,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = lognormal();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -637,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = lognormal( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/lognormal/test/test.js b/lib/node_modules/@stdlib/random/base/lognormal/test/test.js
index 9d59a7a92ffe..25b114ae833a 100644
--- a/lib/node_modules/@stdlib/random/base/lognormal/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/lognormal/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = lognormal( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r > 0.0, true, 'returns a positive number' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.factory.js b/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.factory.js
index 8802eabffbfd..8fdfda160cac 100644
--- a/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.factory.js
@@ -431,7 +431,7 @@ tape( 'the function returns a pseudorandom number generator (no options)', funct
 	minstd = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( isPositiveInteger( v ), true, 'returns a positive integer' );
 		t.strictEqual( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
 	}
@@ -446,7 +446,7 @@ tape( 'the function returns a pseudorandom number generator (options; no seed)',
 	minstd = factory( {} );
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( isPositiveInteger( v ), true, 'returns a positive integer' );
 		t.strictEqual( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
 	}
@@ -931,7 +931,7 @@ tape( 'attached to the returned function is a `normalized` method for generating
 	minstd = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd.normalized();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.js b/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.js
index 07d4fc1d7900..41fb55b8735f 100644
--- a/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/minstd-shuffle/test/test.js
@@ -95,7 +95,7 @@ tape( 'the function returns pseudorandom integers strictly between 0 and 2^31-1
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( isPositiveInteger( v ), true, 'returns a positive integer' );
 		t.strictEqual( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
 	}
@@ -107,7 +107,7 @@ tape( 'the `normalized` method returns pseudorandom numbers strictly between 0 (
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd.normalized();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/minstd/test/test.factory.js b/lib/node_modules/@stdlib/random/base/minstd/test/test.factory.js
index 0b5b8b44ab07..1cfb39a3ee24 100644
--- a/lib/node_modules/@stdlib/random/base/minstd/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/minstd/test/test.factory.js
@@ -389,7 +389,7 @@ tape( 'the function returns a pseudorandom number generator (no options)', funct
 	minstd = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( isPositiveInteger( v ), true, 'returns a positive integer' );
 		t.strictEqual( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
 	}
@@ -404,7 +404,7 @@ tape( 'the function returns a pseudorandom number generator (options; no seed)',
 	minstd = factory( {} );
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( isPositiveInteger( v ), true, 'returns a positive integer' );
 		t.strictEqual( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
 	}
@@ -766,7 +766,7 @@ tape( 'attached to the returned function is a `normalized` method for generating
 	minstd = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd.normalized();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/minstd/test/test.js b/lib/node_modules/@stdlib/random/base/minstd/test/test.js
index cfc3e197fc9f..63d48972a3e7 100644
--- a/lib/node_modules/@stdlib/random/base/minstd/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/minstd/test/test.js
@@ -95,7 +95,7 @@ tape( 'the function returns pseudorandom integers strictly between 0 and 2^31-1
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( isPositiveInteger( v ), true, 'returns a positive integer' );
 		t.strictEqual( v >= 1 && v <= INT32_MAX-1, true, 'returns an integer between 1 and 2^31-1 (inclusive)' );
 	}
@@ -107,7 +107,7 @@ tape( 'the `normalized` method returns pseudorandom numbers strictly between 0 (
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = minstd.normalized();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/mt19937/test/test.factory.js b/lib/node_modules/@stdlib/random/base/mt19937/test/test.factory.js
index a522d9e36518..da53c423ea31 100644
--- a/lib/node_modules/@stdlib/random/base/mt19937/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/mt19937/test/test.factory.js
@@ -457,7 +457,7 @@ tape( 'the function returns a pseudorandom number generator (no options)', funct
 	mt19937 = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = mt19937();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( isNonNegativeInteger( v ), true, 'returns a nonnegative integer' );
 		t.strictEqual( v >= 0 && v <= UINT32_MAX, true, 'returns an integer between 0 and 2^32-1 (inclusive)' );
 	}
@@ -472,7 +472,7 @@ tape( 'the function returns a pseudorandom number generator (options; no seed)',
 	mt19937 = factory( {} );
 	for ( i = 0; i < 1e3; i++ ) {
 		v = mt19937();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( isNonNegativeInteger( v ), true, 'returns a nonnegative integer' );
 		t.strictEqual( v >= 0 && v <= UINT32_MAX, true, 'returns an integer between 0 and 2^32-1 (inclusive)' );
 	}
@@ -930,7 +930,7 @@ tape( 'attached to the returned function is a `normalized` method for generating
 	mt19937 = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = mt19937.normalized();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/mt19937/test/test.js b/lib/node_modules/@stdlib/random/base/mt19937/test/test.js
index c47a8d5e2af1..58837cab28e5 100644
--- a/lib/node_modules/@stdlib/random/base/mt19937/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/mt19937/test/test.js
@@ -96,7 +96,7 @@ tape( 'the function returns pseudorandom integers strictly between 0 and 2^32-1
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = mt19937();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( isNonNegativeInteger( v ), true, 'returns a nonnegative integer' );
 		t.strictEqual( v >= 0 && v <= UINT32_MAX, true, 'returns an integer between 0 and 2^32-1 (inclusive)' );
 	}
@@ -108,7 +108,7 @@ tape( 'the `normalized` method returns pseudorandom numbers strictly between 0 (
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = mt19937.normalized();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/negative-binomial/test/test.factory.js b/lib/node_modules/@stdlib/random/base/negative-binomial/test/test.factory.js
index ba737a277cc2..c6c09b68c2d9 100644
--- a/lib/node_modules/@stdlib/random/base/negative-binomial/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/negative-binomial/test/test.factory.js
@@ -540,14 +540,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	negativeBinomial = factory( 80, 0.05 );
 	for ( i = 0; i < 100; i++ ) {
 		r = negativeBinomial();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	negativeBinomial = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = negativeBinomial( 120, 0.75 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -736,7 +736,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	negativeBinomial = factory();
 	r = negativeBinomial( NaN, 0.5 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -747,7 +747,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	negativeBinomial = factory();
 	r = negativeBinomial( 2, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -758,7 +758,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	negativeBinomial = factory();
 	r = negativeBinomial( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -769,19 +769,19 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	negativeBinomial = factory();
 
 	r = negativeBinomial( 2, 3.14 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = negativeBinomial( 2, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = negativeBinomial( 2, 1.5 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = negativeBinomial( 2, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = negativeBinomial( 2, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -852,7 +852,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = negativeBinomial();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -868,7 +868,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = negativeBinomial( 40, 0.8 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/normal/test/test.factory.js b/lib/node_modules/@stdlib/random/base/normal/test/test.factory.js
index 62ed5d41e3be..14b45d317e0e 100644
--- a/lib/node_modules/@stdlib/random/base/normal/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/normal/test/test.factory.js
@@ -373,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	normal = factory( 0.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = normal();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	normal = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = normal( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -569,7 +569,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	normal = factory();
 	r = normal( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -580,7 +580,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	normal = factory();
 	r = normal( 0.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -591,7 +591,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	normal = factory();
 	r = normal( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -602,10 +602,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	normal = factory();
 
 	r = normal( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = normal( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -621,7 +621,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = normal();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -637,7 +637,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = normal( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/normal/test/test.js b/lib/node_modules/@stdlib/random/base/normal/test/test.js
index 53f4d0298095..03f73b309757 100644
--- a/lib/node_modules/@stdlib/random/base/normal/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/normal/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = normal( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.factory.js b/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.factory.js
index 0b7288533f26..1dfc5fec6233 100644
--- a/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.factory.js
@@ -375,14 +375,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	pareto1 = factory( 2.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = pareto1();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	pareto1 = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = pareto1( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -571,7 +571,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	pareto1 = factory();
 	r = pareto1( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -582,7 +582,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	pareto1 = factory();
 	r = pareto1( 1.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -593,7 +593,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	pareto1 = factory();
 	r = pareto1( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -604,10 +604,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	pareto1 = factory();
 
 	r = pareto1( 0.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = pareto1( -1.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -619,10 +619,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	pareto1 = factory();
 
 	r = pareto1( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = pareto1( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -638,7 +638,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = pareto1();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -654,7 +654,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = pareto1( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.js b/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.js
index 5ffa818c7115..ac737650c3f6 100644
--- a/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/pareto-type1/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = pareto1( 2.0, 1.2 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r >= 0.0, true, 'returns a nonnegative number' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/poisson/test/test.factory.js b/lib/node_modules/@stdlib/random/base/poisson/test/test.factory.js
index 539bd3f7fb7e..4f54825475d2 100644
--- a/lib/node_modules/@stdlib/random/base/poisson/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/poisson/test/test.factory.js
@@ -372,14 +372,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	poisson = factory( 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = poisson();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	poisson = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = poisson( 100.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -568,7 +568,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	poisson = factory();
 	r = poisson( NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -579,13 +579,13 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	poisson = factory();
 
 	r = poisson( 0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = poisson( -1 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = poisson( -3.14 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -601,7 +601,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = poisson();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -617,7 +617,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = poisson( 10.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/randi/test/test.factory.js b/lib/node_modules/@stdlib/random/base/randi/test/test.factory.js
index 41d042030202..eade43f5bb5f 100644
--- a/lib/node_modules/@stdlib/random/base/randi/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/randi/test/test.factory.js
@@ -195,7 +195,7 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	randi = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randi();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( v ), true, 'returns an integer' );
 		t.strictEqual( v >= randi.MIN && v <= randi.MAX, true, 'returns a number between MIN (inclusive) and MAX (inclusive)' );
 	}
diff --git a/lib/node_modules/@stdlib/random/base/randi/test/test.js b/lib/node_modules/@stdlib/random/base/randi/test/test.js
index c7772a8b4ee9..00804b3a51ca 100644
--- a/lib/node_modules/@stdlib/random/base/randi/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/randi/test/test.js
@@ -96,7 +96,7 @@ tape( 'the function returns pseudorandom numbers between a minimum (inclusive) a
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randi();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( isInteger( v ), true, 'returns an integer' );
 		t.strictEqual( v >= randi.MIN && v <= randi.MAX, true, 'returns a number between MIN (inclusive) and MAX (inclusive)' );
 	}
diff --git a/lib/node_modules/@stdlib/random/base/randn/test/test.factory.js b/lib/node_modules/@stdlib/random/base/randn/test/test.factory.js
index 69b4e0fd3a52..0de553dae585 100644
--- a/lib/node_modules/@stdlib/random/base/randn/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/randn/test/test.factory.js
@@ -235,7 +235,7 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	randn = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randn();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -424,7 +424,7 @@ tape( 'the function supports specifying the PRNG name', function test( t ) {
 
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randn();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -440,7 +440,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = randn();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/randn/test/test.js b/lib/node_modules/@stdlib/random/base/randn/test/test.js
index 200b9052a9c9..c58e1b0c037c 100644
--- a/lib/node_modules/@stdlib/random/base/randn/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/randn/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns standard normally distributed pseudorandom numbers',
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randn();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/randu/test/test.factory.js b/lib/node_modules/@stdlib/random/base/randu/test/test.factory.js
index cd9b520bf062..61f4d78302fa 100644
--- a/lib/node_modules/@stdlib/random/base/randu/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/randu/test/test.factory.js
@@ -204,7 +204,7 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	randu = factory();
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randu();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/randu/test/test.js b/lib/node_modules/@stdlib/random/base/randu/test/test.js
index 2e6da00c6241..e794df905227 100644
--- a/lib/node_modules/@stdlib/random/base/randu/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/randu/test/test.js
@@ -94,7 +94,7 @@ tape( 'the function returns pseudorandom numbers between 0 (inclusive) and 1 (ex
 	var i;
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randu();
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 		t.strictEqual( v >= 0.0 && v < 1.0, true, 'returns a number between 0 (inclusive) and 1 (exclusive)' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/rayleigh/test/test.factory.js b/lib/node_modules/@stdlib/random/base/rayleigh/test/test.factory.js
index aeae7af3db25..ffccbf1af01d 100644
--- a/lib/node_modules/@stdlib/random/base/rayleigh/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/rayleigh/test/test.factory.js
@@ -373,14 +373,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	rayleigh = factory( 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = rayleigh();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameter...
 	rayleigh = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = rayleigh( 10.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -569,7 +569,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	rayleigh = factory();
 	r = rayleigh( NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -580,13 +580,13 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	rayleigh = factory();
 
 	r = rayleigh( 0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = rayleigh( -1 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = rayleigh( -3.14 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -602,7 +602,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rayleigh();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -618,7 +618,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rayleigh( 10.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/rayleigh/test/test.js b/lib/node_modules/@stdlib/random/base/rayleigh/test/test.js
index c553f660d685..86c9d7379dca 100644
--- a/lib/node_modules/@stdlib/random/base/rayleigh/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/rayleigh/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rayleigh( 3.14 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r >= 0.0, true, 'returns a positive number' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/t/test/test.factory.js b/lib/node_modules/@stdlib/random/base/t/test/test.factory.js
index c8c3a26c13e3..d0b863a9a27a 100644
--- a/lib/node_modules/@stdlib/random/base/t/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/t/test/test.factory.js
@@ -514,14 +514,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	rt = factory( 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = rt();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameter...
 	rt = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = rt( 100.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -710,7 +710,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	rt = factory();
 	r = rt( NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -721,13 +721,13 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	rt = factory();
 
 	r = rt( 0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = rt( -1 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = rt( -3.14 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -798,7 +798,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rt();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -814,7 +814,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rt( 9.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/t/test/test.js b/lib/node_modules/@stdlib/random/base/t/test/test.js
index 26a12042d3a2..9e248065a62a 100644
--- a/lib/node_modules/@stdlib/random/base/t/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/t/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rt( 3.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/triangular/test/test.factory.js b/lib/node_modules/@stdlib/random/base/triangular/test/test.factory.js
index 5c09c8f21e5c..a329a7acc651 100644
--- a/lib/node_modules/@stdlib/random/base/triangular/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/triangular/test/test.factory.js
@@ -421,14 +421,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	triangular = factory( -10.0, 10.0, 5.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = triangular();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	triangular = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = triangular( -10.0, 10.0, 5.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -617,7 +617,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	triangular = factory();
 	r = triangular( NaN, 5.0, 2.5 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -628,7 +628,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	triangular = factory();
 	r = triangular( 0.0, NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -639,7 +639,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	triangular = factory();
 	r = triangular( 0.0, 10.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -650,7 +650,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	triangular = factory();
 	r = triangular( NaN, NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -685,7 +685,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = triangular();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -701,7 +701,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = triangular( 1.0, 2.0, 1.5 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/triangular/test/test.js b/lib/node_modules/@stdlib/random/base/triangular/test/test.js
index 7981243e1fe4..69b2f94f65f7 100644
--- a/lib/node_modules/@stdlib/random/base/triangular/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/triangular/test/test.js
@@ -90,7 +90,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	c = 211.33;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = triangular( a, b, c );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/uniform/test/test.factory.js b/lib/node_modules/@stdlib/random/base/uniform/test/test.factory.js
index a8bda039727e..0cb0a488d353 100644
--- a/lib/node_modules/@stdlib/random/base/uniform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/uniform/test/test.factory.js
@@ -393,14 +393,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	uniform = factory( -10.0, 10.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = uniform();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	uniform = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = uniform( -10.0, 10.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -588,7 +588,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	uniform = factory();
 	r = uniform( NaN, 5.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -599,7 +599,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	uniform = factory();
 	r = uniform( 0.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -610,7 +610,7 @@ tape( 'when called without arguments, the function returns a function that retur
 	uniform = factory();
 	r = uniform( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -645,7 +645,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = uniform();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -661,7 +661,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = uniform( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/uniform/test/test.js b/lib/node_modules/@stdlib/random/base/uniform/test/test.js
index 9de47691ccb5..c7df075003bb 100644
--- a/lib/node_modules/@stdlib/random/base/uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/uniform/test/test.js
@@ -88,7 +88,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	b = 4.0;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = uniform( a, b );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/weibull/test/test.factory.js b/lib/node_modules/@stdlib/random/base/weibull/test/test.factory.js
index 091bf686760b..fbc7ebcc502f 100644
--- a/lib/node_modules/@stdlib/random/base/weibull/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/weibull/test/test.factory.js
@@ -375,14 +375,14 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	weibull = factory( 2.0, 2.0 );
 	for ( i = 0; i < 100; i++ ) {
 		r = weibull();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
 	weibull = factory();
 	for ( i = 0; i < 100; i++ ) {
 		r = weibull( 2.5, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 
 	t.end();
@@ -571,7 +571,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	weibull = factory();
 	r = weibull( NaN, 1.0 );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -582,7 +582,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	weibull = factory();
 	r = weibull( 1.0, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -593,7 +593,7 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	weibull = factory();
 	r = weibull( NaN, NaN );
 
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -604,10 +604,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	weibull = factory();
 
 	r = weibull( 0.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = weibull( -1.0, 1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -619,10 +619,10 @@ tape( 'when called without arguments, the function returns a PRNG that returns `
 	weibull = factory();
 
 	r = weibull( 1.0, 0.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	r = weibull( 1.0, -1.0 );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -638,7 +638,7 @@ tape( 'the function supports specifying the underlying PRNG', function test( t )
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = weibull();
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -654,7 +654,7 @@ tape( 'the function supports specifying the underlying PRNG (parameters)', funct
 
 	for ( i = 0; i < 1e2; i++ ) {
 		r = weibull( 1.0, 2.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/weibull/test/test.js b/lib/node_modules/@stdlib/random/base/weibull/test/test.js
index f107b8c26878..25fd64174331 100644
--- a/lib/node_modules/@stdlib/random/base/weibull/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/weibull/test/test.js
@@ -83,7 +83,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	var i;
 	for ( i = 0; i < 1e2; i++ ) {
 		r = weibull( 2.0, 1.0 );
-		t.strictEqual( typeof r, 'number', 'returns a number' );
+		t.strictEqual( typeof r, 'number', 'returns expected value' );
 		t.strictEqual( r >= 0.0, true, 'returns a nonnegative number' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.main.js b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.main.js
index 106fb44b0f9f..afe57a3f5158 100644
--- a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.main.js
@@ -624,7 +624,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -872,7 +872,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.main.js b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.main.js
index 4649cc764302..1820bc33a6ff 100644
--- a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.main.js
@@ -577,7 +577,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -825,7 +825,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/beta/test/test.main.js b/lib/node_modules/@stdlib/random/streams/beta/test/test.main.js
index a85c5c60e72f..7fbe468ae680 100644
--- a/lib/node_modules/@stdlib/random/streams/beta/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/beta/test/test.main.js
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.main.js b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.main.js
index bf4893cf1406..70b058be8c93 100644
--- a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.main.js
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/binomial/test/test.main.js b/lib/node_modules/@stdlib/random/streams/binomial/test/test.main.js
index da3acc378542..706dd62a9d3b 100644
--- a/lib/node_modules/@stdlib/random/streams/binomial/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/binomial/test/test.main.js
@@ -607,7 +607,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -855,7 +855,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.main.js b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.main.js
index b431fb602a16..3c890755dabc 100644
--- a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.main.js
@@ -546,7 +546,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -794,7 +794,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.main.js b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.main.js
index 120012911741..4dc668dda951 100644
--- a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.main.js
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/chi/test/test.main.js b/lib/node_modules/@stdlib/random/streams/chi/test/test.main.js
index 4ccbc76ab0d0..35f0f6a29355 100644
--- a/lib/node_modules/@stdlib/random/streams/chi/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/chi/test/test.main.js
@@ -576,7 +576,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -824,7 +824,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.main.js b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.main.js
index 8122e62ba672..8b7df85c70a7 100644
--- a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.main.js
@@ -576,7 +576,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -824,7 +824,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/cosine/test/test.main.js b/lib/node_modules/@stdlib/random/streams/cosine/test/test.main.js
index 414c139e64a2..c732fe70d2eb 100644
--- a/lib/node_modules/@stdlib/random/streams/cosine/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/cosine/test/test.main.js
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.main.js b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.main.js
index 9be7382d63d6..c41ee283196f 100644
--- a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.main.js
@@ -626,7 +626,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -874,7 +874,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/erlang/test/test.main.js b/lib/node_modules/@stdlib/random/streams/erlang/test/test.main.js
index 73c9f4582453..590f5bc19e42 100644
--- a/lib/node_modules/@stdlib/random/streams/erlang/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/erlang/test/test.main.js
@@ -607,7 +607,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -855,7 +855,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/exponential/test/test.main.js b/lib/node_modules/@stdlib/random/streams/exponential/test/test.main.js
index b5f4a8951890..4a0ba4195316 100644
--- a/lib/node_modules/@stdlib/random/streams/exponential/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/exponential/test/test.main.js
@@ -576,7 +576,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -824,7 +824,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/f/test/test.main.js b/lib/node_modules/@stdlib/random/streams/f/test/test.main.js
index d5a9a72fd330..a9fe9f2ef05d 100644
--- a/lib/node_modules/@stdlib/random/streams/f/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/f/test/test.main.js
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/frechet/test/test.main.js b/lib/node_modules/@stdlib/random/streams/frechet/test/test.main.js
index 2cc29ec60767..109dd90002fd 100644
--- a/lib/node_modules/@stdlib/random/streams/frechet/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/frechet/test/test.main.js
@@ -634,7 +634,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -882,7 +882,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/gamma/test/test.main.js b/lib/node_modules/@stdlib/random/streams/gamma/test/test.main.js
index ee6988a1b189..64822c12d11e 100644
--- a/lib/node_modules/@stdlib/random/streams/gamma/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/gamma/test/test.main.js
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/geometric/test/test.main.js b/lib/node_modules/@stdlib/random/streams/geometric/test/test.main.js
index 09dcd7183da5..84d77a72c0fd 100644
--- a/lib/node_modules/@stdlib/random/streams/geometric/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/geometric/test/test.main.js
@@ -577,7 +577,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -825,7 +825,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.main.js b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.main.js
index eafbd8319484..844303bfbd62 100644
--- a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.main.js
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.main.js b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.main.js
index 703d54cb1ab1..5ba7bdc631b1 100644
--- a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.main.js
@@ -683,7 +683,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -931,7 +931,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.main.js b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.main.js
index e31a4907198c..2b325c790bab 100644
--- a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.main.js
@@ -546,7 +546,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -794,7 +794,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.main.js b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.main.js
index ab20faeeadc5..ae0ad0884669 100644
--- a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.main.js
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.main.js b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.main.js
index 97686295dcd2..9e5c03e57854 100644
--- a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.main.js
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/laplace/test/test.main.js b/lib/node_modules/@stdlib/random/streams/laplace/test/test.main.js
index 65a1d9b3e3e0..21492288b996 100644
--- a/lib/node_modules/@stdlib/random/streams/laplace/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/laplace/test/test.main.js
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/levy/test/test.main.js b/lib/node_modules/@stdlib/random/streams/levy/test/test.main.js
index 803f2b274dd2..2ad9fa357a26 100644
--- a/lib/node_modules/@stdlib/random/streams/levy/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/levy/test/test.main.js
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/logistic/test/test.main.js b/lib/node_modules/@stdlib/random/streams/logistic/test/test.main.js
index a47b971961e0..c71bfced63bb 100644
--- a/lib/node_modules/@stdlib/random/streams/logistic/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/logistic/test/test.main.js
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.main.js b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.main.js
index 5d845a2f8434..5a1e98cd627d 100644
--- a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.main.js
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.main.js b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.main.js
index 0a8dd3aad551..612a294050f1 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.main.js
@@ -497,7 +497,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers via
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -546,7 +546,7 @@ tape( 'the constructor returns a stream for generating normalized pseudorandom n
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/minstd/test/test.main.js b/lib/node_modules/@stdlib/random/streams/minstd/test/test.main.js
index c463a932abcd..0aa07591b33f 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd/test/test.main.js
@@ -497,7 +497,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers via
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -546,7 +546,7 @@ tape( 'the constructor returns a stream for generating normalized pseudorandom n
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.main.js b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.main.js
index 6464305bb98b..ae35dbdc1029 100644
--- a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.main.js
@@ -497,7 +497,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers via
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -546,7 +546,7 @@ tape( 'the constructor returns a stream for generating normalized pseudorandom n
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.main.js b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.main.js
index 54aca4b3e6d0..809309f0a622 100644
--- a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.main.js
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/normal/test/test.main.js b/lib/node_modules/@stdlib/random/streams/normal/test/test.main.js
index 4a93fc87d1d6..3d6804ecc658 100644
--- a/lib/node_modules/@stdlib/random/streams/normal/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/normal/test/test.main.js
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -852,7 +852,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.main.js b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.main.js
index f4fc7aaa832b..a755e829d034 100644
--- a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.main.js
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/poisson/test/test.main.js b/lib/node_modules/@stdlib/random/streams/poisson/test/test.main.js
index 5560a679e440..9bde6736e424 100644
--- a/lib/node_modules/@stdlib/random/streams/poisson/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/poisson/test/test.main.js
@@ -576,7 +576,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -824,7 +824,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/randi/test/test.main.js b/lib/node_modules/@stdlib/random/streams/randi/test/test.main.js
index 73a457d20f71..0ddb12315e9e 100644
--- a/lib/node_modules/@stdlib/random/streams/randi/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/randi/test/test.main.js
@@ -461,7 +461,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers havi
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/randn/test/test.main.js b/lib/node_modules/@stdlib/random/streams/randn/test/test.main.js
index 4d448e77b6e5..371fa5079c67 100644
--- a/lib/node_modules/@stdlib/random/streams/randn/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/randn/test/test.main.js
@@ -578,7 +578,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers draw
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/randu/test/test.main.js b/lib/node_modules/@stdlib/random/streams/randu/test/test.main.js
index 15f0fd1f9f46..0e2a3b816e0d 100644
--- a/lib/node_modules/@stdlib/random/streams/randu/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/randu/test/test.main.js
@@ -462,7 +462,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers on t
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
diff --git a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.main.js b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.main.js
index 2854521c307e..bfa6b3d24995 100644
--- a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.main.js
@@ -576,7 +576,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -824,7 +824,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/t/test/test.main.js b/lib/node_modules/@stdlib/random/streams/t/test/test.main.js
index a6b0ec1acf0c..d248f2ca10f3 100644
--- a/lib/node_modules/@stdlib/random/streams/t/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/t/test/test.main.js
@@ -576,7 +576,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -824,7 +824,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/triangular/test/test.main.js b/lib/node_modules/@stdlib/random/streams/triangular/test/test.main.js
index 2ad49af50dcd..54c6f0e2c034 100644
--- a/lib/node_modules/@stdlib/random/streams/triangular/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/triangular/test/test.main.js
@@ -652,7 +652,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -900,7 +900,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/uniform/test/test.main.js b/lib/node_modules/@stdlib/random/streams/uniform/test/test.main.js
index f12f66ce7eb8..868e2758d021 100644
--- a/lib/node_modules/@stdlib/random/streams/uniform/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/uniform/test/test.main.js
@@ -624,7 +624,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -872,7 +872,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/weibull/test/test.main.js b/lib/node_modules/@stdlib/random/streams/weibull/test/test.main.js
index 2299bbe8554e..6f395bbe554a 100644
--- a/lib/node_modules/@stdlib/random/streams/weibull/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/streams/weibull/test/test.main.js
@@ -606,7 +606,7 @@ tape( 'the constructor returns a stream for generating pseudorandom numbers from
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -854,7 +854,7 @@ tape( 'the constructor supports specifying the underlying PRNG', function test(
 	s.pipe( iStream );
 
 	function inspect( v ) {
-		t.strictEqual( typeof v, 'number', 'returns a number' );
+		t.strictEqual( typeof v, 'number', 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/strided/arcsine/test/test.main.js b/lib/node_modules/@stdlib/random/strided/arcsine/test/test.main.js
index 1eeef27d61d5..8614b3c8ec52 100644
--- a/lib/node_modules/@stdlib/random/strided/arcsine/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/arcsine/test/test.main.js
@@ -61,7 +61,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -70,7 +70,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -99,7 +99,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/arcsine/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/arcsine/test/test.ndarray.js
index ea85369f0b5c..0eeaf0822092 100644
--- a/lib/node_modules/@stdlib/random/strided/arcsine/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/arcsine/test/test.ndarray.js
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -69,7 +69,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -98,7 +98,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/beta/test/test.main.js b/lib/node_modules/@stdlib/random/strided/beta/test/test.main.js
index cbcaaf877c64..2ef586893487 100644
--- a/lib/node_modules/@stdlib/random/strided/beta/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/beta/test/test.main.js
@@ -61,7 +61,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -70,7 +70,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -99,7 +99,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/beta/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/beta/test/test.ndarray.js
index a001edabb699..9246a3d35632 100644
--- a/lib/node_modules/@stdlib/random/strided/beta/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/beta/test/test.ndarray.js
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -69,7 +69,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -98,7 +98,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/betaprime/test/test.main.js b/lib/node_modules/@stdlib/random/strided/betaprime/test/test.main.js
index e80cc3aa05e8..1bd29ffc36e4 100644
--- a/lib/node_modules/@stdlib/random/strided/betaprime/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/betaprime/test/test.main.js
@@ -61,7 +61,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -70,7 +70,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -99,7 +99,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/betaprime/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/betaprime/test/test.ndarray.js
index b05993fda387..af48d2c5200f 100644
--- a/lib/node_modules/@stdlib/random/strided/betaprime/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/betaprime/test/test.ndarray.js
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -69,7 +69,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -98,7 +98,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/cosine/test/test.main.js b/lib/node_modules/@stdlib/random/strided/cosine/test/test.main.js
index c3e4c80da1d9..e3af3ad70335 100644
--- a/lib/node_modules/@stdlib/random/strided/cosine/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/cosine/test/test.main.js
@@ -61,7 +61,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -70,7 +70,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -99,7 +99,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/cosine/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/cosine/test/test.ndarray.js
index 85fac8b0bfd4..54abe1625312 100644
--- a/lib/node_modules/@stdlib/random/strided/cosine/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/cosine/test/test.ndarray.js
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -69,7 +69,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -98,7 +98,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/discrete-uniform/test/test.main.js b/lib/node_modules/@stdlib/random/strided/discrete-uniform/test/test.main.js
index ba11622a5df9..817a2a8ff185 100644
--- a/lib/node_modules/@stdlib/random/strided/discrete-uniform/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/discrete-uniform/test/test.main.js
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', discreteUniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -69,7 +69,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', discreteUniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -98,7 +98,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/discrete-uniform/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/discrete-uniform/test/test.ndarray.js
index 55837f037ae9..0ae089502348 100644
--- a/lib/node_modules/@stdlib/random/strided/discrete-uniform/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/discrete-uniform/test/test.ndarray.js
@@ -59,7 +59,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', discreteUniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -68,7 +68,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', discreteUniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -97,7 +97,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/gamma/test/test.main.js b/lib/node_modules/@stdlib/random/strided/gamma/test/test.main.js
index 1a367e729373..276d03872819 100644
--- a/lib/node_modules/@stdlib/random/strided/gamma/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/gamma/test/test.main.js
@@ -61,7 +61,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -70,7 +70,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -99,7 +99,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/gamma/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/gamma/test/test.ndarray.js
index 3fcfc96da36b..86168536967c 100644
--- a/lib/node_modules/@stdlib/random/strided/gamma/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/gamma/test/test.ndarray.js
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -69,7 +69,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -98,7 +98,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/invgamma/test/test.main.js b/lib/node_modules/@stdlib/random/strided/invgamma/test/test.main.js
index 8b1dfd7cd4e1..27c7684f92cd 100644
--- a/lib/node_modules/@stdlib/random/strided/invgamma/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/invgamma/test/test.main.js
@@ -61,7 +61,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -70,7 +70,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -99,7 +99,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/invgamma/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/invgamma/test/test.ndarray.js
index 7210d5b8b445..1e0af495ec5a 100644
--- a/lib/node_modules/@stdlib/random/strided/invgamma/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/invgamma/test/test.ndarray.js
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -69,7 +69,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -98,7 +98,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/lognormal/test/test.main.js b/lib/node_modules/@stdlib/random/strided/lognormal/test/test.main.js
index 9df3c13e0959..bd2c7a8b5139 100644
--- a/lib/node_modules/@stdlib/random/strided/lognormal/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/lognormal/test/test.main.js
@@ -61,7 +61,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -70,7 +70,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -99,7 +99,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/lognormal/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/lognormal/test/test.ndarray.js
index 82d68c597513..185c52c379a1 100644
--- a/lib/node_modules/@stdlib/random/strided/lognormal/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/lognormal/test/test.ndarray.js
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -69,7 +69,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -98,7 +98,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.main.js b/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.main.js
index 57e5137e204f..986996ec6c28 100644
--- a/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.main.js
@@ -47,7 +47,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 	random( N, out, 1 );
 
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -62,7 +62,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.ndarray.js
index 54f929379006..831681590e93 100644
--- a/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.ndarray.js
@@ -45,7 +45,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.normalized.js b/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.normalized.js
index 31eb10065826..4bf287bb908e 100644
--- a/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.normalized.js
+++ b/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.normalized.js
@@ -47,7 +47,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 	random( N, out, 1 );
 
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -62,7 +62,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.normalized.ndarray.js b/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.normalized.ndarray.js
index 4cfea249f953..66c263ae774a 100644
--- a/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.normalized.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/minstd-shuffle/test/test.normalized.ndarray.js
@@ -45,7 +45,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/minstd/test/test.main.js b/lib/node_modules/@stdlib/random/strided/minstd/test/test.main.js
index 90f4edf4fe3e..e6c100111fc2 100644
--- a/lib/node_modules/@stdlib/random/strided/minstd/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/minstd/test/test.main.js
@@ -47,7 +47,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 	random( N, out, 1 );
 
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -62,7 +62,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/minstd/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/minstd/test/test.ndarray.js
index aa2b2965a62d..41e0162e5d56 100644
--- a/lib/node_modules/@stdlib/random/strided/minstd/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/minstd/test/test.ndarray.js
@@ -45,7 +45,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/minstd/test/test.normalized.js b/lib/node_modules/@stdlib/random/strided/minstd/test/test.normalized.js
index 24c6648c6d0f..54ba3bfc9d78 100644
--- a/lib/node_modules/@stdlib/random/strided/minstd/test/test.normalized.js
+++ b/lib/node_modules/@stdlib/random/strided/minstd/test/test.normalized.js
@@ -47,7 +47,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 	random( N, out, 1 );
 
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -62,7 +62,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/minstd/test/test.normalized.ndarray.js b/lib/node_modules/@stdlib/random/strided/minstd/test/test.normalized.ndarray.js
index 2f9d7e51a447..9c955be88153 100644
--- a/lib/node_modules/@stdlib/random/strided/minstd/test/test.normalized.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/minstd/test/test.normalized.ndarray.js
@@ -45,7 +45,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/mt19937/test/test.main.js b/lib/node_modules/@stdlib/random/strided/mt19937/test/test.main.js
index 6a3245c5fe4d..ac61cdc34de8 100644
--- a/lib/node_modules/@stdlib/random/strided/mt19937/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/mt19937/test/test.main.js
@@ -47,7 +47,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 	random( N, out, 1 );
 
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -62,7 +62,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/mt19937/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/mt19937/test/test.ndarray.js
index 5616d828e3e6..2aecba6e4884 100644
--- a/lib/node_modules/@stdlib/random/strided/mt19937/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/mt19937/test/test.ndarray.js
@@ -45,7 +45,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/mt19937/test/test.normalized.js b/lib/node_modules/@stdlib/random/strided/mt19937/test/test.normalized.js
index 018f26a26b5c..4ca9aa485631 100644
--- a/lib/node_modules/@stdlib/random/strided/mt19937/test/test.normalized.js
+++ b/lib/node_modules/@stdlib/random/strided/mt19937/test/test.normalized.js
@@ -47,7 +47,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 	random( N, out, 1 );
 
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -62,7 +62,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/mt19937/test/test.normalized.ndarray.js b/lib/node_modules/@stdlib/random/strided/mt19937/test/test.normalized.ndarray.js
index 1ad4ed65a6fa..af0c97c67769 100644
--- a/lib/node_modules/@stdlib/random/strided/mt19937/test/test.normalized.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/mt19937/test/test.normalized.ndarray.js
@@ -45,7 +45,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/normal/test/test.main.js b/lib/node_modules/@stdlib/random/strided/normal/test/test.main.js
index 3a489f2dd145..708f5948a54c 100644
--- a/lib/node_modules/@stdlib/random/strided/normal/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/normal/test/test.main.js
@@ -61,7 +61,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -70,7 +70,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -99,7 +99,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/normal/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/normal/test/test.ndarray.js
index 64eca7181961..353264bac532 100644
--- a/lib/node_modules/@stdlib/random/strided/normal/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/normal/test/test.ndarray.js
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -69,7 +69,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -98,7 +98,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/randu/test/test.main.js b/lib/node_modules/@stdlib/random/strided/randu/test/test.main.js
index 98c957209a29..0c86e45da342 100644
--- a/lib/node_modules/@stdlib/random/strided/randu/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/randu/test/test.main.js
@@ -47,7 +47,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 	random( N, out, 1 );
 
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -62,7 +62,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/randu/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/randu/test/test.ndarray.js
index f1ef22995428..ae3153258fe7 100644
--- a/lib/node_modules/@stdlib/random/strided/randu/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/randu/test/test.ndarray.js
@@ -45,7 +45,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out.get( i ), 'number', 'returns a number' );
+		t.strictEqual( typeof out.get( i ), 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/uniform/test/test.main.js b/lib/node_modules/@stdlib/random/strided/uniform/test/test.main.js
index 3b3baa7a520d..dccae942fef7 100644
--- a/lib/node_modules/@stdlib/random/strided/uniform/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/uniform/test/test.main.js
@@ -61,7 +61,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -70,7 +70,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -99,7 +99,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/uniform/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/uniform/test/test.ndarray.js
index acb10fe9db07..c440ca3f04bc 100644
--- a/lib/node_modules/@stdlib/random/strided/uniform/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/uniform/test/test.ndarray.js
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -69,7 +69,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -98,7 +98,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/weibull/test/test.main.js b/lib/node_modules/@stdlib/random/strided/weibull/test/test.main.js
index 160fb6291016..cfd0bc505313 100644
--- a/lib/node_modules/@stdlib/random/strided/weibull/test/test.main.js
+++ b/lib/node_modules/@stdlib/random/strided/weibull/test/test.main.js
@@ -61,7 +61,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -70,7 +70,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, x2, 0, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -99,7 +99,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, x2, 1, out, 1 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/strided/weibull/test/test.ndarray.js b/lib/node_modules/@stdlib/random/strided/weibull/test/test.ndarray.js
index e8a9dbae47c3..a3a0eadf9f94 100644
--- a/lib/node_modules/@stdlib/random/strided/weibull/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/random/strided/weibull/test/test.ndarray.js
@@ -60,7 +60,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) );
@@ -69,7 +69,7 @@ tape( 'the function fills a strided array with pseudorandom numbers', function t
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 0, 0, x2, 0, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 
 	x1 = toAccessorArray( filledarrayBy( N, 'generic', uniform( PARAM1[ 0 ], PARAM1[ 9 ] ) ) );
@@ -98,7 +98,7 @@ tape( 'the function fills a strided array with pseudorandom numbers (accessors)'
 
 	random( N, x1, 1, 0, x2, 1, 0, out, 1, 0 );
 	for ( i = 0; i < N; i++ ) {
-		t.strictEqual( typeof out[ i ], 'number', 'returns a number' );
+		t.strictEqual( typeof out[ i ], 'number', 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/anova1/test/test.js b/lib/node_modules/@stdlib/stats/anova1/test/test.js
index aaa22cb10f3c..816cb1093a96 100644
--- a/lib/node_modules/@stdlib/stats/anova1/test/test.js
+++ b/lib/node_modules/@stdlib/stats/anova1/test/test.js
@@ -221,7 +221,7 @@ tape( 'the `.print()` method allows printing a formatted output table', function
 	actual = anova1( group, vals );
 	table = actual.print();
 
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/bartlett-test/test/test.js b/lib/node_modules/@stdlib/stats/bartlett-test/test/test.js
index 0c99b477c994..2763108de65a 100644
--- a/lib/node_modules/@stdlib/stats/bartlett-test/test/test.js
+++ b/lib/node_modules/@stdlib/stats/bartlett-test/test/test.js
@@ -194,13 +194,13 @@ tape( 'the function returns an object with a `.print()` method for printing a fo
 
 	out = bartlettTest( x, y, z );
 	table = out.print();
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 
 	out = bartlettTest( x, y, z, {
 		'alpha': 0.01
 	});
 	table = out.print();
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.native.js
index 788cf2f8b450..6496b5097efe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.native.js
@@ -51,19 +51,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -71,16 +71,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = quantile( 0.5, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -2.0, -3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.quantile.js
index f55f148e491a..ac1bd0e9ac00 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,16 +66,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = quantile( 0.5, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -2.0, -3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.native.js
index 8048dad0f11f..17bc7b0b785f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.native.js
@@ -53,17 +53,17 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `r` and a valid `p`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 2.2, 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.2, 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -71,13 +71,13 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the function retur
 	var y;
 
 	y = quantile( 0.8, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.9, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.quantile.js
index 1bf95f29b2b3..86f05b69abdf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.quantile.js
@@ -44,17 +44,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `r` and a valid `p`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 2.2, 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.2, 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -62,13 +62,13 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the function alway
 	var y;
 
 	y = quantile( 0.8, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.9, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.mgf.js
index 741f5d9709d4..5a3f4701d927 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.mgf.js
@@ -115,7 +115,7 @@ tape( 'the function evaluates the mgf', function test( t ) {
 		alpha = ( randu()*20.0 ) + EPS;
 		beta = ( randu()*20.0 ) + EPS;
 		y = mgf( x, alpha, beta );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.native.js
index b1097193f3b6..51edc87ffb92 100755
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/mgf/test/test.native.js
@@ -49,11 +49,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mgf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,25 +88,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'the function evaluates the mgf', opts, function test( t ) {
 		alpha = ( randu()*20.0 ) + EPS;
 		beta = ( randu()*20.0 ) + EPS;
 		y = mgf( x, alpha, beta );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.native.js
index e01cc62502f9..c78e6b0beab5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `x0` and `gamma`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( PINF, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( PINF, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -75,28 +75,28 @@ tape( 'if provided a nonpositive `gamma`, the function always returns `NaN`', op
 	var y;
 
 	y = quantile( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.native.js
index 8542e7d21e3c..308d1a7a33cb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `mu` and `s`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -75,22 +75,22 @@ tape( 'if provided a negative `s`, the function always returns `NaN`', opts, fun
 	var y;
 
 	y = quantile( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.native.js
index fe970883dfbe..0c06f6cb3ff1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.native.js
@@ -53,15 +53,15 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -69,10 +69,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = quantile( 0.5, 2, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -2, -3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.quantile.js
index f7d7cdd3d754..67ffc297b1e4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, NaN, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, 1, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,13 +66,13 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = quantile( 0.5, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -2, -3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,10 +81,10 @@ tape( 'if provided a non-integer value for `a` or `b`, the function returns `NaN
 	var y;
 
 	y = quantile( 0.5, 1, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -0.1, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.quantile.js
index 120620117d96..491dbc00b324 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `k` and `lambda`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,28 +66,28 @@ tape( 'if provided a `k` which is not a nonnegative integer, the function return
 	var y;
 
 	y = quantile( 2.0, -1, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, -1, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 0.5, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 4.5, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -96,22 +96,22 @@ tape( 'if provided a negative `lambda`, the function returns `NaN`', function te
 	var y;
 
 	y = quantile( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.native.js
index 2e0c8411cf3d..04ff332d1833 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.native.js
@@ -62,17 +62,17 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 2.2, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.2, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -80,16 +80,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', opts,
 	var y;
 
 	y = quantile( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,13 +98,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', opts
 	var y;
 
 	y = quantile( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.quantile.js
index 68952e756657..72b92f69bd86 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.quantile.js
@@ -53,17 +53,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `lambda`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 2.2, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.2, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -71,16 +71,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', functi
 	var y;
 
 	y = quantile( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,13 +89,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = quantile( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.quantile.js
index a8a26420deae..eb3b968bef32 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `d1` and `d2`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,25 +66,25 @@ tape( 'if provided a nonpositive `d1`, the function returns `NaN`', function tes
 	var y;
 
 	y = quantile( 0.5, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,25 +93,25 @@ tape( 'if provided a nonpositive `d2`, the function returns `NaN`', function tes
 	var y;
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.quantile.js
index 7f534b501221..00f2e5ca5734 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.quantile.js
@@ -46,21 +46,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, NaN, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, 1.0, NaN, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -68,25 +68,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = quantile( 0.3, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.3, NINF, PINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.3, NINF, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -95,25 +95,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = quantile( 0.3, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.3, 1.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, PINF, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.1, NaN, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.quantile.js
index 21e9e610368f..7ab44e2499a0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `alpha` and `beta`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,22 +66,22 @@ tape( 'if provided a negative `alpha`, the function returns `NaN`', function tes
 	var y;
 
 	y = quantile( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -90,25 +90,25 @@ tape( 'if provided a nonpositive`beta`, the function returns `NaN`', function te
 	var y;
 
 	y = quantile( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -120,9 +120,9 @@ tape( 'if provided `alpha` equal to `0.0`, the function returns `0.0` for  a val
 	t.strictEqual( y, 0.0, 'returns 0' );
 
 	y = quantile( 1.1, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.native.js
index 8a9f7ef97254..e4e3cc7257ef 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.native.js
@@ -54,17 +54,17 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `r` and a valid `p`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 2.2, 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.2, 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -80,13 +80,13 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the function alway
 	var y;
 
 	y = quantile( 0.8, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.9, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.quantile.js
index e8ee975e8e31..7dd206bb8ca8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.quantile.js
@@ -45,17 +45,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `r` and a valid `p`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 2.2, 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.2, 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -71,13 +71,13 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the function alway
 	var y;
 
 	y = quantile( 0.8, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.9, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.mgf.js
index fae639549ff9..c9b7ba6722e7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.mgf.js
@@ -39,11 +39,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 10, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 10, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,28 +51,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns `NaN` for `x >= 1/beta`', function test( t ) {
 
 	for ( i = 1; i < 10; i++ ) {
 		y = mgf( i/2.0, 0.0, 2.0 );
-		t.strictEqual( isnan( y ), true, 'returns NaN' );
+		t.strictEqual( isnan( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -101,7 +101,7 @@ tape( 'the function evaluates the mgf', function test( t ) {
 		beta = randu() * 20.0;
 		x = randu() * (1/beta);
 		y = mgf( x, mu, beta );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.native.js
index 435508277263..9e43dd70264d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.native.js
@@ -48,11 +48,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 10, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 10, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,28 +60,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'the function returns `NaN` for `x >= 1/beta`', opts, function test( t ) {
 
 	for ( i = 1; i < 10; i++ ) {
 		y = mgf( i/2.0, 0.0, 2.0 );
-		t.strictEqual( isnan( y ), true, 'returns NaN' );
+		t.strictEqual( isnan( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'the function evaluates the mgf', opts, function test( t ) {
 		beta = randu() * 20.0;
 		x = randu() * (1/beta);
 		y = mgf( x, mu, beta );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.native.js
index c36763d06835..3ce57a509a08 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `beta`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -75,28 +75,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.quantile.js
index 2c065064c10a..eaa8380db4d9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `beta`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,28 +66,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.quantile.js
index e113899a1621..6e71828b1e95 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.quantile.js
@@ -42,21 +42,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 20, 20, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, NaN, 10, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, 20, NaN, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, 20, 20, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and valid parameters, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 20, 10, 10 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 20, 10, 10 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -64,22 +64,22 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = quantile( 0.5, 10.5, 10, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 10.5, 10, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, PINF, 10, 5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, 10, 5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -2.0, 10, 5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -0.5, 10, 5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,22 +88,22 @@ tape( 'if provided a `K` which is not a nonnegative integer, the function return
 	var y;
 
 	y = quantile( 0.5, 20, 10.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, 1.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, PINF, 5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, NINF, 5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, -2.0, 5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, -0.5, 5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -112,22 +112,22 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = quantile( 0.5, 20, 10, 10.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, 10, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, 10, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, 10, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, 5, -2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, 5, -0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.quantile.js
index f2c9721589ea..d0fd33d5ec7b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `alpha` and `beta`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,22 +66,22 @@ tape( 'if provided a negative `alpha`, the function returns `NaN`', function tes
 	var y;
 
 	y = quantile( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -90,22 +90,22 @@ tape( 'if provided a negative `beta`, the function returns `NaN`', function test
 	var y;
 
 	y = quantile( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.cdf.js
index 4a935779a705..91c83c19ed06 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.cdf.js
@@ -40,11 +40,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -84,25 +84,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -111,25 +111,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function evaluates the cdf of a Kumaraswamy\'s double bounded distrib
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = cdf( x, a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.native.js
index e44eda645c58..0ec75dc12d5b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.native.js
@@ -49,11 +49,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -93,25 +93,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -120,25 +120,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -155,7 +155,7 @@ tape( 'the function evaluates the cdf of a Kumaraswamy\'s double bounded distrib
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = cdf( x, a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.js
index e83eee35639b..39c010119435 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.js
@@ -40,10 +40,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = kurtosis( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function returns the excess kurtosis of a Kumaraswamy\'s double bound
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = kurtosis( a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.native.js
index 52237c5ee0fe..8c08d54f26cc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/kurtosis/test/test.native.js
@@ -49,10 +49,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = kurtosis( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,25 +88,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function returns the excess kurtosis of a Kumaraswamy\'s double bound
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = kurtosis( a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.logcdf.js
index 0d3893061ef9..247b96c5c61c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.logcdf.js
@@ -40,11 +40,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -84,25 +84,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -111,25 +111,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function evaluates the logcdf of a Kumaraswamy\'s double bounded dist
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = logcdf( x, a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.native.js
index 37e0abbce5d4..15f1a7aa925a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.native.js
@@ -49,11 +49,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -93,25 +93,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -120,25 +120,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -156,7 +156,7 @@ tape( 'the function evaluates the logcdf of a Kumaraswamy\'s double bounded dist
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = logcdf( x, a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.pdf.js
index 6fd5ba9bcff8..f3acae3794b0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.pdf.js
@@ -40,11 +40,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -84,25 +84,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = pdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -111,25 +111,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,7 +147,7 @@ tape( 'the function evaluates the pdf of a Kumaraswamy\'s double bounded distrib
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = pdf( x, a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.native.js
index 274f70cdcd8f..271ff6a8c4cc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.native.js
@@ -49,19 +49,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -69,25 +69,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = quantile( 0.2, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -96,25 +96,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = quantile( 0.2, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -132,7 +132,7 @@ tape( 'the function evaluates the quantile function of a Kumaraswamy\'s double b
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = quantile( p, a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.quantile.js
index 4ddba4c1edf7..f23bd9fbd2c9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.quantile.js
@@ -40,19 +40,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,25 +60,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = quantile( 0.2, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -87,25 +87,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = quantile( 0.2, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -123,7 +123,7 @@ tape( 'the function evaluates the quantile function of a Kumaraswamy\'s double b
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = quantile( p, a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.js
index c82557a3ba83..80fd6166fa5e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.js
@@ -40,10 +40,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = skewness( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -113,7 +113,7 @@ tape( 'the function returns the skewness of a Kumaraswamy\'s double bounded dist
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = skewness( a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.native.js
index 36a65ab90ca2..b8c4d7805267 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/skewness/test/test.native.js
@@ -49,10 +49,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = skewness( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,25 +88,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function returns the skewness of a Kumaraswamy\'s double bounded dist
 		a = ( randu()*5.0 ) + EPS;
 		b = ( randu()*5.0 ) + EPS;
 		y = skewness( a, b );
-		t.strictEqual( isNumber( y ), true, 'returns a number' );
+		t.strictEqual( isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.native.js
index 33a0e606fc8c..726e414cae42 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `b`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -75,28 +75,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.quantile.js
index 36b55bf69cf4..d46c13f9d157 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `b`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,28 +66,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.native.js
index fd21b05d79c4..3deac9d93433 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `c`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -75,22 +75,22 @@ tape( 'if provided a negative `c`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.quantile.js
index f63c87832750..149e29ab559e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `c`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,22 +66,22 @@ tape( 'if provided a negative `c`, the function returns `NaN`', function test( t
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.native.js
index 1e99b2872949..370fc1f22092 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.native.js
@@ -54,19 +54,19 @@ tape( 'main export is a function', opts, function test( t ) {
 });
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `s`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -74,22 +74,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.quantile.js
index 0637bf5929db..ee37df74d148 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `mu` and `s`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,22 +66,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.7, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.quantile.js
index 0bb26de10f3e..5c432114e461 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `mu` and `sigma`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,25 +66,25 @@ tape( 'if provided a nonpositive `sigma`, the function always returns `NaN`', fu
 	var y;
 
 	y = quantile( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.mgf.js
index 6c64a34ca149..d70bf3beadd3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.mgf.js
@@ -40,11 +40,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 10, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 10, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var y;
 
 	y = mgf( 2.0, -2.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, -1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 0.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, NINF, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,25 +70,25 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = mgf( 2.0, 20, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 20, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 20, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `t >= -ln( p )`, the function returns `NaN`', function test( t ) {
 	var y = mgf( 0.7, 10.0, 0.5 ); // -ln( p ) = ~0.693
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 1.7, 10.0, 0.2 ); // -ln( p ) = ~1.609
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -105,7 +105,7 @@ tape( 'the function evaluates the mgf', function test( t ) {
 		p = randu();
 		x = ln( p ) - randu();
 		y = mgf( x, r, p );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.native.js
index cb34a87db330..42d3858c4873 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.native.js
@@ -49,11 +49,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 10, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 10, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var y;
 
 	y = mgf( 2.0, -2.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, -1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 0.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, NINF, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,25 +79,25 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = mgf( 2.0, 20, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 20, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 20, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `t >= -ln( p )`, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( 0.7, 10.0, 0.5 ); // -ln( p ) = ~0.693
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 1.7, 10.0, 0.2 ); // -ln( p ) = ~1.609
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -113,7 +113,7 @@ tape( 'the function evaluates the mgf', opts, function test( t ) {
 		p = randu();
 		x = ln( p ) - randu();
 		y = mgf( x, r, p );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.quantile.js
index 492e57eaf059..089e1ad016e6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.quantile.js
@@ -45,19 +45,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 20, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 20, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `k` and a valid `r` and `p`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 20, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 20, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -65,13 +65,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var y;
 
 	y = quantile( 0.5, NINF, 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -2.0, 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -0.5, 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,16 +80,16 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the function retur
 	var y;
 
 	y = quantile( 0.5, 20, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.native.js
index 5ed46da4f199..14b4e3dbfb2b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.native.js
@@ -62,19 +62,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `mu` and `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -82,22 +82,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', opts,
 	var y;
 
 	y = quantile( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.quantile.js
index 0077bb502d10..3dd2dcde0342 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.quantile.js
@@ -53,19 +53,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `mu` and `sigma`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -73,22 +73,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', funct
 	var y;
 
 	y = quantile( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.native.js
index bab38fb6d50c..89db92dd043f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.1, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.1, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `alpha` and `beta`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -75,25 +75,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = quantile( 0.5, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -102,25 +102,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.quantile.js
index 71a5ee7ae3c7..47056d28671a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.1, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.1, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `alpha` and `beta`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,25 +66,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = quantile( 0.5, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,25 +93,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.quantile.js
index d1ea31a328b3..97be1e7cb849 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.quantile.js
@@ -44,17 +44,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `lambda`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 2.2, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.2, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -78,13 +78,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = quantile( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,13 +93,13 @@ tape( 'if provided a `lambda` equal to `0`, the function always returns `0`', fu
 	var y;
 
 	y = quantile( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 3.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 5.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.mgf.js
index fc24b61ab4fd..848bf70e09d7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.mgf.js
@@ -38,9 +38,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -48,10 +48,10 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', function tes
 	var y;
 
 	y = mgf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -67,7 +67,7 @@ tape( 'the function evaluates the mgf', function test( t ) {
 		x = randu();
 		sigma = randu() * 20.0;
 		y = mgf( x, sigma );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.native.js
index ece71463fb29..4f5c6de6a67d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.native.js
@@ -47,9 +47,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,10 +57,10 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = mgf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,7 +76,7 @@ tape( 'the function evaluates the mgf', opts, function test( t ) {
 		x = randu();
 		sigma = randu() * 20.0;
 		y = mgf( x, sigma );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.native.js
index d75c69c049b2..76520282c92a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.native.js
@@ -54,17 +54,17 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -72,13 +72,13 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = quantile( 0.5, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.quantile.js
index 7dc08f3d791a..ea60e5071710 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.quantile.js
@@ -45,17 +45,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `sigma`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,13 +63,13 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', function tes
 	var y;
 
 	y = quantile( 0.5, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.quantile.js
index 4cfff202e6b6..1ef0369547fc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.quantile.js
@@ -44,17 +44,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `n`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -62,19 +62,19 @@ tape( 'if provided a negative or non-integer `n`, the function returns `NaN`', f
 	var y;
 
 	y = quantile( 0.5, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 4.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.quantile.js
index 9bfc2e567969..b67723b63c8f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.quantile.js
@@ -44,17 +44,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a finite `v`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 2.2, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.2, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -62,16 +62,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', functi
 	var y;
 
 	y = quantile( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.native.js
index c34e622014f8..b288716b540a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.native.js
@@ -55,21 +55,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.1, NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.1, 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.1, 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and valid parameters, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -77,16 +77,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = quantile( 0.5, PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -10.0, 10.0, 11.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -10.0, 10.0, -11.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.quantile.js
index 4d92527aa3f3..d4fdb053d004 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.quantile.js
@@ -46,21 +46,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.1, NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.1, 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.1, 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and valid parameters, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -68,16 +68,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = quantile( 0.5, PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -10.0, 10.0, 11.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -10.0, 10.0, -11.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.native.js
index f71f5424eb68..49014f8dcaba 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.native.js
@@ -55,19 +55,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -75,16 +75,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = quantile( 0.5, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -2.0, -3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.quantile.js
index f55f148e491a..ac1bd0e9ac00 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.2, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `a` and `b`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,16 +66,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = quantile( 0.5, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -2.0, -3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.mgf.js
index 03deeaefe683..5bfc03040852 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.mgf.js
@@ -40,11 +40,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', function test
 	var y;
 
 	y = mgf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', function test
 	var y;
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -115,7 +115,7 @@ tape( 'the function evaluates the mgf', function test( t ) {
 		lambda = (randu() * 10.0) + EPS;
 		k = (randu() * 10.0) + EPS;
 		y = mgf( x, lambda, k );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.native.js
index 2d301f8eb2cd..dffb84e33de3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.native.js
@@ -49,11 +49,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mgf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,25 +88,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function evaluates the mgf', opts, function test( t ) {
 		lambda = (randu() * 10.0) + EPS;
 		k = (randu() * 10.0) + EPS;
 		y = mgf( x, lambda, k );
-		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns a number' );
+		t.strictEqual( !isnan( y ) && isNumber( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.quantile.js
index 1dbe738323b6..307611f13e46 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.quantile.js
@@ -46,19 +46,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number outside `[0,1]` for `p` and a valid `lambda` and `k`, the function returns `NaN`', function test( t ) {
 	var y = quantile( 1.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( -0.1, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns true' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,25 +66,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', function test
 	var y;
 
 	y = quantile( 0.5, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,25 +93,25 @@ tape( 'if provided a nonpositive `lambda`, the function returns `NaN`', function
 	var y;
 
 	y = quantile( 0.5, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/chi2gof/test/test.js b/lib/node_modules/@stdlib/stats/chi2gof/test/test.js
index cf3d07830f3a..d41c9a2a644b 100644
--- a/lib/node_modules/@stdlib/stats/chi2gof/test/test.js
+++ b/lib/node_modules/@stdlib/stats/chi2gof/test/test.js
@@ -352,7 +352,7 @@ tape( 'the function computes the p-value via Monte Carlo simulation when `simula
 		'iterations': 500
 	});
 
-	t.strictEqual( typeof out.pValue, 'number', 'returns a number' );
+	t.strictEqual( typeof out.pValue, 'number', 'returns expected value' );
 	t.end();
 });
 
@@ -402,7 +402,7 @@ tape( 'the function returns an object with a `.toString()` method for printing a
 
 		Test Decision: Reject null in favor of alternative at 5% significance level
 	*/
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 
 	out = chi2gof( x, p, {
 		'alpha': 0.01
@@ -420,7 +420,7 @@ tape( 'the function returns an object with a `.toString()` method for printing a
 
 		Test Decision: Fail to reject null in favor of alternative at 1% significance level
 	*/
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 
 	// FIXME: actually test for expected output; e.g., split into lines and do line-by-line comparison
 
diff --git a/lib/node_modules/@stdlib/stats/chi2test/test/test.js b/lib/node_modules/@stdlib/stats/chi2test/test/test.js
index c8e1b0f84376..db318c6043f2 100644
--- a/lib/node_modules/@stdlib/stats/chi2test/test/test.js
+++ b/lib/node_modules/@stdlib/stats/chi2test/test/test.js
@@ -316,13 +316,13 @@ tape( 'the function returns an object with a `.toString()` method for printing a
 
 	out = chi2test( x );
 	table = out.toString();
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 
 	out = chi2test( x, {
 		'alpha': 0.01
 	});
 	table = out.toString();
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/fligner-test/test/test.js b/lib/node_modules/@stdlib/stats/fligner-test/test/test.js
index f2c37ea587ff..fbadc70025ee 100644
--- a/lib/node_modules/@stdlib/stats/fligner-test/test/test.js
+++ b/lib/node_modules/@stdlib/stats/fligner-test/test/test.js
@@ -194,13 +194,13 @@ tape( 'the function returns an object with a `.print()` method for printing a fo
 
 	out = flignerTest( x, y, z );
 	table = out.print();
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 
 	out = flignerTest( x, y, z, {
 		'alpha': 0.01
 	});
 	table = out.print();
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/kruskal-test/test/test.js b/lib/node_modules/@stdlib/stats/kruskal-test/test/test.js
index c95c479f78de..5927758727be 100644
--- a/lib/node_modules/@stdlib/stats/kruskal-test/test/test.js
+++ b/lib/node_modules/@stdlib/stats/kruskal-test/test/test.js
@@ -219,13 +219,13 @@ tape( 'the function returns an object with a `.print()` method for printing a fo
 
 	out = kruskalTest( x, y, z );
 	table = out.print();
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 
 	out = kruskalTest( x, y, z, {
 		'alpha': 0.01
 	});
 	table = out.print();
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/kstest/test/test.js b/lib/node_modules/@stdlib/stats/kstest/test/test.js
index a2121616c94c..6033fa55326c 100644
--- a/lib/node_modules/@stdlib/stats/kstest/test/test.js
+++ b/lib/node_modules/@stdlib/stats/kstest/test/test.js
@@ -325,7 +325,7 @@ tape( 'the `.print()` method allows printing a formatted output table', function
 
 		Test Decision: Fail to reject null in favor of alternative at 5% significance level
 	*/
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 	t.end();
 });
 
@@ -374,7 +374,7 @@ tape( 'the `.print()` method allows printing a formatted output table for a one-
 		Test Decision: Reject null in favor of alternative at 5% significance level
 	*/
 
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/levene-test/test/test.js b/lib/node_modules/@stdlib/stats/levene-test/test/test.js
index 3bc2383126c3..2274b74306aa 100644
--- a/lib/node_modules/@stdlib/stats/levene-test/test/test.js
+++ b/lib/node_modules/@stdlib/stats/levene-test/test/test.js
@@ -194,13 +194,13 @@ tape( 'the function returns an object with a `.print()` method for printing a fo
 
 	out = leveneTest( x, y, z );
 	table = out.print();
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 
 	out = leveneTest( x, y, z, {
 		'alpha': 0.01
 	});
 	table = out.print();
-	t.strictEqual( typeof table, 'string', 'returns a string' );
+	t.strictEqual( typeof table, 'string', 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-array/test/test.main.js b/lib/node_modules/@stdlib/streams/node/from-array/test/test.main.js
index 4af3bb6d9608..3ed799ba40f7 100644
--- a/lib/node_modules/@stdlib/streams/node/from-array/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/from-array/test/test.main.js
@@ -284,7 +284,7 @@ tape( 'the constructor returns a stream which streams elements of an array-like
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -364,7 +364,7 @@ tape( 'the constructor returns a stream which streams elements of an array-like
 
 	function inspect( chunk ) {
 		count += 1;
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 		if ( count === 10 ) {
 			s.destroy();
@@ -506,7 +506,7 @@ tape( 'the constructor supports specifying the iteration direction (array)', fun
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.main.js b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.main.js
index bbc6090fbbec..01c011b9f6c6 100644
--- a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.main.js
@@ -285,7 +285,7 @@ tape( 'the constructor returns a stream which streams elements of a "circular" a
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -366,7 +366,7 @@ tape( 'the constructor returns a stream which streams elements of a "circular" a
 
 	function inspect( chunk ) {
 		count += 1;
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 		if ( count === 10 ) {
 			s.destroy();
@@ -452,7 +452,7 @@ tape( 'the constructor supports specifying the iteration direction (array)', fun
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.main.js b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.main.js
index cfb0e65135ef..4ddff0932f9f 100644
--- a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.main.js
@@ -315,7 +315,7 @@ tape( 'the constructor returns a stream which always streams the same value (str
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -352,7 +352,7 @@ tape( 'the constructor returns a stream which always streams the same value (Buf
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -393,7 +393,7 @@ tape( 'the constructor returns a stream which always streams the same value (Uin
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.main.js b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.main.js
index cbe3711c60a8..2ac249cc8c80 100644
--- a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.main.js
@@ -288,7 +288,7 @@ tape( 'the constructor returns a stream which streams iterated values', function
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -363,7 +363,7 @@ tape( 'the constructor returns a stream which streams iterated values (infinite
 
 	function inspect( chunk ) {
 		count += 1;
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 		if ( count === 10 ) {
 			s.destroy();
@@ -441,7 +441,7 @@ tape( 'the constructor returns a stream which streams iterated values (value+don
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -584,7 +584,7 @@ tape( 'the constructor returns a stream which streams iterated values (len=1; va
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.main.js b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.main.js
index 7f0435d922eb..b503957af231 100644
--- a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.main.js
+++ b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.main.js
@@ -604,7 +604,7 @@ tape( 'the constructor returns a stream which streams elements of a strided arra
 	s.pipe( iStream );
 
 	function inspect( chunk ) {
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 	}
 
@@ -686,7 +686,7 @@ tape( 'the constructor returns a stream which streams elements of a strided arra
 
 	function inspect( chunk ) {
 		count += 1;
-		t.strictEqual( isBuffer( chunk ), true, 'returns a buffer' );
+		t.strictEqual( isBuffer( chunk ), true, 'returns expected value' );
 		result += chunk.toString();
 		if ( count === 10 ) {
 			s.destroy();
diff --git a/lib/node_modules/@stdlib/string/base/starts-with/test/test.js b/lib/node_modules/@stdlib/string/base/starts-with/test/test.js
index 67253542cab1..d5b9e4654d69 100644
--- a/lib/node_modules/@stdlib/string/base/starts-with/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/starts-with/test/test.js
@@ -55,16 +55,16 @@ tape( 'the function returns `true` if the input string starts with the search va
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'Too', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Not too late, I\'m afraid', 'Not', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Welcome home!', 'Welcome home', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Welcome home!', 'Welcome home!', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -73,13 +73,13 @@ tape( 'the function returns `false` if the input string does not start with the
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'too', 0 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Not too late, I\'m afraid', 'Never', 0 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Welcome home!', 'Welcome at home', 0 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -88,16 +88,16 @@ tape( 'the function supports providing a starting search position relative to th
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'late', 3 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'late', 4 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'late', 5 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afraid', 14 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'the function supports providing a starting search position relative to th
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'i', -2 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afr', -7 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afr', -6 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afr', -5 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afraid', -6 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a search string which exceeds the input string length', function test( t ) {
 	var bool = startsWith( 'abc', 'abcde', 0 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -133,10 +133,10 @@ tape( 'the function returns `false` if provided a search string which exceeds th
 	var bool;
 
 	bool = startsWith( 'abc', 'bcd', 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'abc', 'bcd', -2 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -145,31 +145,31 @@ tape( 'the function returns `true` if provided an empty search string', function
 	var bool;
 
 	bool = startsWith( '', '', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', 10 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', -10 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a position exceeding the input string length (positive)', function test( t ) {
 	var bool = startsWith( 'abc', 'c', 99999 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a position exceeding the input string length (negative)', function test( t ) {
 	var bool = startsWith( 'abc', 'a', -5 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/starts-with/test/test.main.js b/lib/node_modules/@stdlib/string/base/starts-with/test/test.main.js
index 7d4cecd9b8e3..16a1b4408236 100644
--- a/lib/node_modules/@stdlib/string/base/starts-with/test/test.main.js
+++ b/lib/node_modules/@stdlib/string/base/starts-with/test/test.main.js
@@ -44,16 +44,16 @@ tape( 'the function returns `true` if the input string starts with the search va
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'Too', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Not too late, I\'m afraid', 'Not', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Welcome home!', 'Welcome home', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Welcome home!', 'Welcome home!', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -62,13 +62,13 @@ tape( 'the function returns `false` if the input string does not start with the
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'too', 0 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Not too late, I\'m afraid', 'Never', 0 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Welcome home!', 'Welcome at home', 0 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -77,16 +77,16 @@ tape( 'the function supports providing a starting search position relative to th
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'late', 3 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'late', 4 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'late', 5 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afraid', 14 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -95,26 +95,26 @@ tape( 'the function supports providing a starting search position relative to th
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'i', -2 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afr', -7 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afr', -6 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afr', -5 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afraid', -6 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a search string which exceeds the input string length', opts, function test( t ) {
 	var bool = startsWith( 'abc', 'abcde', 0 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -122,10 +122,10 @@ tape( 'the function returns `false` if provided a search string which exceeds th
 	var bool;
 
 	bool = startsWith( 'abc', 'bcd', 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'abc', 'bcd', -2 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -134,31 +134,31 @@ tape( 'the function returns `true` if provided an empty search string', opts, fu
 	var bool;
 
 	bool = startsWith( '', '', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', 10 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', -10 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a position exceeding the input string length (positive)', opts, function test( t ) {
 	var bool = startsWith( 'abc', 'c', 99999 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a position exceeding the input string length (negative)', opts, function test( t ) {
 	var bool = startsWith( 'abc', 'a', -5 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/starts-with/test/test.polyfill.js b/lib/node_modules/@stdlib/string/base/starts-with/test/test.polyfill.js
index 28b716c4483d..2e1b2595b268 100644
--- a/lib/node_modules/@stdlib/string/base/starts-with/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/string/base/starts-with/test/test.polyfill.js
@@ -36,16 +36,16 @@ tape( 'the function returns `true` if the input string starts with the search va
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'Too', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Not too late, I\'m afraid', 'Not', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Welcome home!', 'Welcome home', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Welcome home!', 'Welcome home!', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -54,13 +54,13 @@ tape( 'the function returns `false` if the input string does not start with the
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'too', 0 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Not too late, I\'m afraid', 'Never', 0 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Welcome home!', 'Welcome at home', 0 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -69,16 +69,16 @@ tape( 'the function supports providing a starting search position relative to th
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'late', 3 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'late', 4 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'late', 5 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afraid', 14 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -87,26 +87,26 @@ tape( 'the function supports providing a starting search position relative to th
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'i', -2 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afr', -7 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afr', -6 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afr', -5 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afraid', -6 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a search string which exceeds the input string length', function test( t ) {
 	var bool = startsWith( 'abc', 'abcde', 0 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -114,10 +114,10 @@ tape( 'the function returns `false` if provided a search string which exceeds th
 	var bool;
 
 	bool = startsWith( 'abc', 'bcd', 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'abc', 'bcd', -2 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -126,31 +126,31 @@ tape( 'the function returns `true` if provided an empty search string', function
 	var bool;
 
 	bool = startsWith( '', '', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', 10 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', -10 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a position exceeding the input string length (positive)', function test( t ) {
 	var bool = startsWith( 'abc', 'c', 99999 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a position exceeding the input string length (negative)', function test( t ) {
 	var bool = startsWith( 'abc', 'a', -5 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/stickycase/test/test.js b/lib/node_modules/@stdlib/string/base/stickycase/test/test.js
index 067a7c0c7528..805700cc8dd9 100644
--- a/lib/node_modules/@stdlib/string/base/stickycase/test/test.js
+++ b/lib/node_modules/@stdlib/string/base/stickycase/test/test.js
@@ -37,15 +37,15 @@ tape('the function converts a string to sticky caps case', function test( t ) {
 
 	// Test with default probability (p=0.5)
 	actual = stickycase( 'hello world' );
-	t.strictEqual( typeof actual, 'string', 'returns a string' );
+	t.strictEqual( typeof actual, 'string', 'returns expected value' );
 
 	// Test with lower probability (p=0.2):
 	actual = stickycase( 'hello world', 0.2 );
-	t.strictEqual( typeof actual, 'string', 'returns a string' );
+	t.strictEqual( typeof actual, 'string', 'returns expected value' );
 
 	// Test with higher probability (p=0.8):
 	actual = stickycase( 'hello world', 0.8 );
-	t.strictEqual( typeof actual, 'string', 'returns a string' );
+	t.strictEqual( typeof actual, 'string', 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/starts-with/test/test.js b/lib/node_modules/@stdlib/string/starts-with/test/test.js
index 8bcfdb24a15f..86d7f9e0d86f 100644
--- a/lib/node_modules/@stdlib/string/starts-with/test/test.js
+++ b/lib/node_modules/@stdlib/string/starts-with/test/test.js
@@ -121,16 +121,16 @@ tape( 'the function returns `true` if the input string starts with the search va
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'Too' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Not too late, I\'m afraid', 'Not' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Welcome home!', 'Welcome home' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Welcome home!', 'Welcome home!' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -139,13 +139,13 @@ tape( 'the function returns `false` if the input string does not start with the
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'too' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Not too late, I\'m afraid', 'Never' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Welcome home!', 'Welcome at home' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -154,16 +154,16 @@ tape( 'the function supports providing a starting search position relative to th
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'late', 3 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'late', 4 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'late', 5 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afraid', 14 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -172,26 +172,26 @@ tape( 'the function supports providing a starting search position relative to th
 	var bool;
 
 	bool = startsWith( 'Too late, I\'m afraid', 'i', -2 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afr', -7 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afr', -6 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afr', -5 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'Too late, I\'m afraid', 'afraid', -6 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a search string which exceeds the input string length', function test( t ) {
 	var bool = startsWith( 'abc', 'abcde' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -199,10 +199,10 @@ tape( 'the function returns `false` if provided a search string which exceeds th
 	var bool;
 
 	bool = startsWith( 'abc', 'bcd', 1 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = startsWith( 'abc', 'bcd', -2 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -211,31 +211,31 @@ tape( 'the function returns `true` if provided an empty search string', function
 	var bool;
 
 	bool = startsWith( '', '' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', 10 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', -10 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = startsWith( 'abc', '', 0 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a position exceeding the input string length (positive)', function test( t ) {
 	var bool = startsWith( 'abc', 'c', 99999 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `false` if provided a position exceeding the input string length (negative)', function test( t ) {
 	var bool = startsWith( 'abc', 'a', -5 );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/time/day-of-quarter/test/test.js b/lib/node_modules/@stdlib/time/day-of-quarter/test/test.js
index 4705c13c36aa..f14e2d4f31fb 100644
--- a/lib/node_modules/@stdlib/time/day-of-quarter/test/test.js
+++ b/lib/node_modules/@stdlib/time/day-of-quarter/test/test.js
@@ -231,7 +231,7 @@ tape( 'the function throws a range error if provided a day number outside the in
 
 tape( 'the function returns a number on the interval `[1,92]`', function test( t ) {
 	var num = dayOfQuarter();
-	t.strictEqual( typeof num, 'number', 'returns true' );
+	t.strictEqual( typeof num, 'number', 'returns expected value' );
 	t.strictEqual( num >= 1 && num <= 92, true, 'returns number of expected interval' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/time/day-of-year/test/test.js b/lib/node_modules/@stdlib/time/day-of-year/test/test.js
index 6e75d67e4ad7..c1bec3b8f642 100644
--- a/lib/node_modules/@stdlib/time/day-of-year/test/test.js
+++ b/lib/node_modules/@stdlib/time/day-of-year/test/test.js
@@ -231,7 +231,7 @@ tape( 'the function throws a range error if provided a day number outside the in
 
 tape( 'the function returns a number on the interval `[1,366]`', function test( t ) {
 	var num = dayOfYear();
-	t.strictEqual( typeof num, 'number', 'returns true' );
+	t.strictEqual( typeof num, 'number', 'returns expected value' );
 	t.strictEqual( num >= 1 && num <= 366, true, 'returns number on interval `[1,366]`' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/time/days-in-month/test/test.js b/lib/node_modules/@stdlib/time/days-in-month/test/test.js
index f877d820a54b..fc792832ca74 100644
--- a/lib/node_modules/@stdlib/time/days-in-month/test/test.js
+++ b/lib/node_modules/@stdlib/time/days-in-month/test/test.js
@@ -223,7 +223,7 @@ tape( 'the function throws a range error if provided an integer month value outs
 
 tape( 'the function returns a number on the interval `[28,31]`', function test( t ) {
 	var num = daysInMonth();
-	t.strictEqual( typeof num, 'number', 'returns a number' );
+	t.strictEqual( typeof num, 'number', 'returns expected value' );
 	t.strictEqual( num >= 28 && num <= 31, true, 'returns a number on interval `[28,31]`' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/time/days-in-year/test/test.js b/lib/node_modules/@stdlib/time/days-in-year/test/test.js
index 00060b5cf6b4..41b7987b5a26 100644
--- a/lib/node_modules/@stdlib/time/days-in-year/test/test.js
+++ b/lib/node_modules/@stdlib/time/days-in-year/test/test.js
@@ -64,7 +64,7 @@ tape( 'the function throws a type error if provided a value which is neither an
 
 tape( 'the function returns either `365` or `366`', function test( t ) {
 	var num = daysInYear();
-	t.strictEqual( num === 365 || num === 366, true, 'returns true' );
+	t.strictEqual( num === 365 || num === 366, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/time/hours-in-month/test/test.js b/lib/node_modules/@stdlib/time/hours-in-month/test/test.js
index 10be5808c379..3cf99ff5c90f 100644
--- a/lib/node_modules/@stdlib/time/hours-in-month/test/test.js
+++ b/lib/node_modules/@stdlib/time/hours-in-month/test/test.js
@@ -223,7 +223,7 @@ tape( 'the function throws a range error if provided an integer month value outs
 
 tape( 'the function returns a number', function test( t ) {
 	var num = hoursInMonth();
-	t.strictEqual( typeof num, 'number', 'returns a number' );
+	t.strictEqual( typeof num, 'number', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/time/hours-in-year/test/test.js b/lib/node_modules/@stdlib/time/hours-in-year/test/test.js
index b11fe2295e78..f3585e73b330 100644
--- a/lib/node_modules/@stdlib/time/hours-in-year/test/test.js
+++ b/lib/node_modules/@stdlib/time/hours-in-year/test/test.js
@@ -65,7 +65,7 @@ tape( 'the function throws a type error if provided a value which is neither an
 
 tape( 'the function returns either `8760` or `8784`', function test( t ) {
 	var num = hoursInYear();
-	t.strictEqual( num === 8760 || num === 8784, true, 'returns true' );
+	t.strictEqual( num === 8760 || num === 8784, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/time/iso-weeks-in-year/test/test.js b/lib/node_modules/@stdlib/time/iso-weeks-in-year/test/test.js
index 71abebcca452..75255d82bc39 100644
--- a/lib/node_modules/@stdlib/time/iso-weeks-in-year/test/test.js
+++ b/lib/node_modules/@stdlib/time/iso-weeks-in-year/test/test.js
@@ -90,7 +90,7 @@ tape( 'the function throws a type error if provided a value which is neither an
 
 tape( 'the function returns either `52` or `53`', function test( t ) {
 	var num = isoWeeksInYear();
-	t.strictEqual( num === 52 || num === 53, true, 'returns true' );
+	t.strictEqual( num === 52 || num === 53, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/time/minutes-in-month/test/test.js b/lib/node_modules/@stdlib/time/minutes-in-month/test/test.js
index ae5fa64fd705..03e724f9bc1e 100644
--- a/lib/node_modules/@stdlib/time/minutes-in-month/test/test.js
+++ b/lib/node_modules/@stdlib/time/minutes-in-month/test/test.js
@@ -223,7 +223,7 @@ tape( 'the function throws a range error if provided an integer month value outs
 
 tape( 'the function returns a number', function test( t ) {
 	var num = minutesInMonth();
-	t.strictEqual( typeof num, 'number', 'returns a number' );
+	t.strictEqual( typeof num, 'number', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/time/minutes-in-year/test/test.js b/lib/node_modules/@stdlib/time/minutes-in-year/test/test.js
index 2f113e0c6442..1dd064ecc3da 100644
--- a/lib/node_modules/@stdlib/time/minutes-in-year/test/test.js
+++ b/lib/node_modules/@stdlib/time/minutes-in-year/test/test.js
@@ -65,7 +65,7 @@ tape( 'the function throws a type error if provided a value which is neither an
 
 tape( 'the function returns either `525600` or `527040`', function test( t ) {
 	var num = minutesInYear();
-	t.strictEqual( num === 525600 || num === 527040, true, 'returns true' );
+	t.strictEqual( num === 525600 || num === 527040, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/time/quarter-of-year/test/test.js b/lib/node_modules/@stdlib/time/quarter-of-year/test/test.js
index 23e9a4aadca0..852c38928ea9 100644
--- a/lib/node_modules/@stdlib/time/quarter-of-year/test/test.js
+++ b/lib/node_modules/@stdlib/time/quarter-of-year/test/test.js
@@ -113,7 +113,7 @@ tape( 'the function throws a range error if provided an integer month value outs
 
 tape( 'the function returns a number on the interval `[1,4]`', function test( t ) {
 	var q = quarterOfYear();
-	t.strictEqual( q >= 1 && q <= 4, true, 'returns true' );
+	t.strictEqual( q >= 1 && q <= 4, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/time/seconds-in-month/test/test.js b/lib/node_modules/@stdlib/time/seconds-in-month/test/test.js
index f80614c578bf..1c11ced64fbe 100644
--- a/lib/node_modules/@stdlib/time/seconds-in-month/test/test.js
+++ b/lib/node_modules/@stdlib/time/seconds-in-month/test/test.js
@@ -223,7 +223,7 @@ tape( 'the function throws a range error if provided an integer month value outs
 
 tape( 'the function returns a number', function test( t ) {
 	var num = secondsInMonth();
-	t.strictEqual( typeof num, 'number', 'returns a number' );
+	t.strictEqual( typeof num, 'number', 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/time/seconds-in-year/test/test.js b/lib/node_modules/@stdlib/time/seconds-in-year/test/test.js
index f7e19f09a20c..d14a71a584bb 100644
--- a/lib/node_modules/@stdlib/time/seconds-in-year/test/test.js
+++ b/lib/node_modules/@stdlib/time/seconds-in-year/test/test.js
@@ -65,7 +65,7 @@ tape( 'the function throws a type error if provided a value which is neither an
 
 tape( 'the function returns either `31536000` or `31622400`', function test( t ) {
 	var num = secondsInYear();
-	t.strictEqual( num === 31536000 || num === 31622400, true, 'returns true' );
+	t.strictEqual( num === 31536000 || num === 31622400, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/any-by-right/test/test.js b/lib/node_modules/@stdlib/utils/any-by-right/test/test.js
index 87e127f2e721..7461fd527427 100644
--- a/lib/node_modules/@stdlib/utils/any-by-right/test/test.js
+++ b/lib/node_modules/@stdlib/utils/any-by-right/test/test.js
@@ -115,7 +115,7 @@ tape( 'if provided an empty collection, the function returns `false`', function
 	arr = [];
 	bool = anyByRight( arr, foo );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -127,7 +127,7 @@ tape( 'the function returns `true` if at least one element passes a test (array)
 
 	bool = anyByRight( arr, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -139,7 +139,7 @@ tape( 'the function returns `false` if all elements fail a test (array)', functi
 
 	bool = anyByRight( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -157,7 +157,7 @@ tape( 'the function returns `true` if at least one element passes a test (array-
 
 	bool = anyByRight( arr, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -174,7 +174,7 @@ tape( 'the function returns `false` if all elements fail a test (array-like obje
 
 	bool = anyByRight( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -186,7 +186,7 @@ tape( 'the function returns `true` if at least one element passes a test (typed
 
 	bool = anyByRight( arr, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -198,7 +198,7 @@ tape( 'the function returns `false` if all elements fail a test (typed array)',
 
 	bool = anyByRight( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -222,7 +222,7 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = anyByRight( arr, sum, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( ctx.sum/ctx.count, 1.25, 'expected result' );
 
 	t.end();
@@ -244,7 +244,7 @@ tape( 'the function provides basic support for dynamic arrays', function test( t
 	bool = anyByRight( arr, isNegative );
 
 	t.deepEqual( arr, [ -2, -1, 0, 1, 2, 3 ], 'expected result' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -267,6 +267,6 @@ tape( 'the function does not skip empty elements', function test( t ) {
 
 	bool = anyByRight( arr, verify );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/any-by/test/test.js b/lib/node_modules/@stdlib/utils/any-by/test/test.js
index 9cbc2b4fbaad..fb65260c0539 100644
--- a/lib/node_modules/@stdlib/utils/any-by/test/test.js
+++ b/lib/node_modules/@stdlib/utils/any-by/test/test.js
@@ -115,7 +115,7 @@ tape( 'if provided an empty collection, the function returns `false`', function
 	arr = [];
 	bool = anyBy( arr, foo );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -127,7 +127,7 @@ tape( 'the function returns `true` if at least one element passes a test (array)
 
 	bool = anyBy( arr, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -139,7 +139,7 @@ tape( 'the function returns `false` if all elements fail a test (array)', functi
 
 	bool = anyBy( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -157,7 +157,7 @@ tape( 'the function returns `true` if at least one element passes a test (array-
 
 	bool = anyBy( arr, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -174,7 +174,7 @@ tape( 'the function returns `false` if all elements fail a test (array-like obje
 
 	bool = anyBy( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -186,7 +186,7 @@ tape( 'the function returns `true` if at least one element passes a test (typed
 
 	bool = anyBy( arr, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -198,7 +198,7 @@ tape( 'the function returns `false` if all elements fail a test (typed array)',
 
 	bool = anyBy( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -222,7 +222,7 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = anyBy( arr, sum, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( ctx.sum/ctx.count, 1.25, 'expected result' );
 
 	t.end();
@@ -244,7 +244,7 @@ tape( 'the function provides basic support for dynamic arrays', function test( t
 	bool = anyBy( arr, isNegative );
 
 	t.deepEqual( arr, [ 1, 2, 3, 2, 1, 0, -1, -2 ], 'expected result' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -264,6 +264,6 @@ tape( 'the function does not skip empty elements', function test( t ) {
 
 	bool = anyBy( arr, verify );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/any-in-by/test/test.js b/lib/node_modules/@stdlib/utils/any-in-by/test/test.js
index aeb03c996a1b..d258b1caf654 100644
--- a/lib/node_modules/@stdlib/utils/any-in-by/test/test.js
+++ b/lib/node_modules/@stdlib/utils/any-in-by/test/test.js
@@ -136,7 +136,7 @@ tape( 'the function returns `true` if at least one own property passes a test',
 
 	bool = anyInBy( obj, overAge );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -156,7 +156,7 @@ tape( 'the function returns `true` if one or more own properties pass a test', f
 
 	bool = anyInBy( obj, underAge );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -176,6 +176,6 @@ tape( 'the function returns `false` if none of the own properties passes a test'
 
 	bool = anyInBy( obj, underAge );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/any-own-by/test/test.js b/lib/node_modules/@stdlib/utils/any-own-by/test/test.js
index 9723e4577a40..92f317a40774 100644
--- a/lib/node_modules/@stdlib/utils/any-own-by/test/test.js
+++ b/lib/node_modules/@stdlib/utils/any-own-by/test/test.js
@@ -109,7 +109,7 @@ tape( 'if provided an empty object, the function returns `false`', function test
 	obj = {};
 	bool = anyOwnBy( obj, foo );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -125,7 +125,7 @@ tape( 'the function returns `true` if any one property pass a test', function te
 
 	bool = anyOwnBy( obj, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -142,7 +142,7 @@ tape( 'the function returns `false` if no properties pass a test', function test
 
 	bool = anyOwnBy( obj, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -172,7 +172,7 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = anyOwnBy( obj, verify, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( ctx.sum/ctx.count, 0, 'expected result' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/any/test/test.js b/lib/node_modules/@stdlib/utils/any/test/test.js
index f202a30e7e26..d1058a2a5765 100644
--- a/lib/node_modules/@stdlib/utils/any/test/test.js
+++ b/lib/node_modules/@stdlib/utils/any/test/test.js
@@ -70,7 +70,7 @@ tape( 'if provided an empty collection, the function returns `false`', function
 	arr = [];
 	bool = any( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -81,7 +81,7 @@ tape( 'the function returns `true` if at least one element is truthy (array)', f
 	arr = [ 0, 0, 0, 0, 1 ];
 	bool = any( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -92,7 +92,7 @@ tape( 'the function returns `false` if all elements are falsy (array)', function
 	arr = [ 0, 0, 0 ];
 	bool = any( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -110,7 +110,7 @@ tape( 'the function returns `true` if at least one element is truthy (array-like
 
 	bool = any( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -127,7 +127,7 @@ tape( 'the function returns `false` if all elements are falsy (array-like object
 
 	bool = any( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -138,7 +138,7 @@ tape( 'the function returns `true` if at least one element is truthy (typed arra
 	arr = new Float64Array( [ 0.0, 0.0, 2.0, 0.0 ] );
 	bool = any( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -149,6 +149,6 @@ tape( 'the function returns `false` if all elements are falsy (typed array)', fu
 	arr = new Float64Array( 3 );
 	bool = any( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/async/any-by-right/test/test.main.js b/lib/node_modules/@stdlib/utils/async/any-by-right/test/test.main.js
index ee2818fdf629..8f4b5d510a0e 100644
--- a/lib/node_modules/@stdlib/utils/async/any-by-right/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/async/any-by-right/test/test.main.js
@@ -285,7 +285,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -322,7 +322,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -360,7 +360,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -400,7 +400,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function invo
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -440,7 +440,7 @@ tape( 'if a predicate function length is 0, the function invokes a predicate fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -472,7 +472,7 @@ tape( 'by default, the function processes collection elements concurrently', fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -508,7 +508,7 @@ tape( 'the function supports processing collection elements sequentially (in ser
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -545,7 +545,7 @@ tape( 'the function supports processing collection elements sequentially (limit
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -582,7 +582,7 @@ tape( 'the function supports limiting the maximum number of collection elements
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -618,7 +618,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -651,7 +651,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -687,7 +687,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -719,7 +719,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -748,7 +748,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -781,7 +781,7 @@ tape( 'if a predicate function returns a truthy test result, the function suspen
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -817,7 +817,7 @@ tape( 'if a predicate function returns a truthy test result, the function suspen
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -849,7 +849,7 @@ tape( 'if a predicate function returns a truthy test result, the function suspen
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -868,7 +868,7 @@ tape( 'if provided an empty collection, the function never invokes a predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -892,7 +892,7 @@ tape( 'the function does not guarantee asynchronous execution', function test( t
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/any-by/test/test.main.js b/lib/node_modules/@stdlib/utils/async/any-by/test/test.main.js
index e31291a2501a..760b2afe92f1 100644
--- a/lib/node_modules/@stdlib/utils/async/any-by/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/async/any-by/test/test.main.js
@@ -285,7 +285,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -319,7 +319,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -354,7 +354,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -391,7 +391,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function invo
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -428,7 +428,7 @@ tape( 'if a predicate function length is 0, the function invokes a predicate fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -460,7 +460,7 @@ tape( 'by default, the function processes collection elements concurrently', fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -496,7 +496,7 @@ tape( 'the function supports processing collection elements sequentially (in ser
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -533,7 +533,7 @@ tape( 'the function supports processing collection elements sequentially (limit
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -570,7 +570,7 @@ tape( 'the function supports limiting the maximum number of collection elements
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -606,7 +606,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -639,7 +639,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -675,7 +675,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -707,7 +707,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -736,7 +736,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -769,7 +769,7 @@ tape( 'if a predicate function returns a truthy test result, the function suspen
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -805,7 +805,7 @@ tape( 'if a predicate function returns a truthy test result, the function suspen
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -837,7 +837,7 @@ tape( 'if a predicate function returns a truthy test result, the function suspen
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -856,7 +856,7 @@ tape( 'if provided an empty collection, the function never invokes a predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -880,7 +880,7 @@ tape( 'the function does not guarantee asynchronous execution', function test( t
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/every-by-right/test/test.main.js b/lib/node_modules/@stdlib/utils/async/every-by-right/test/test.main.js
index 10b0621206d8..497c2681cce9 100644
--- a/lib/node_modules/@stdlib/utils/async/every-by-right/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/async/every-by-right/test/test.main.js
@@ -285,7 +285,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -322,7 +322,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -360,7 +360,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -400,7 +400,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function invo
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -440,7 +440,7 @@ tape( 'if a predicate function length is 0, the function invokes a predicate fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -472,7 +472,7 @@ tape( 'by default, the function processes collection elements concurrently', fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -508,7 +508,7 @@ tape( 'the function supports processing collection elements sequentially (in ser
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -545,7 +545,7 @@ tape( 'the function supports processing collection elements sequentially (limit
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -582,7 +582,7 @@ tape( 'the function supports limiting the maximum number of collection elements
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -618,7 +618,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -651,7 +651,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -687,7 +687,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -719,7 +719,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -748,7 +748,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -781,7 +781,7 @@ tape( 'if a predicate function returns a falsy test result, the function suspend
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -817,7 +817,7 @@ tape( 'if a predicate function returns a falsy test result, the function suspend
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -849,7 +849,7 @@ tape( 'if a predicate function returns a falsy test result, the function suspend
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -868,7 +868,7 @@ tape( 'if provided an empty collection, the function never invokes a predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -892,7 +892,7 @@ tape( 'the function does not guarantee asynchronous execution', function test( t
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/every-by/test/test.main.js b/lib/node_modules/@stdlib/utils/async/every-by/test/test.main.js
index 2917319cf311..a17f4f8e4cbe 100644
--- a/lib/node_modules/@stdlib/utils/async/every-by/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/async/every-by/test/test.main.js
@@ -285,7 +285,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -319,7 +319,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -354,7 +354,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -391,7 +391,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function invo
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -428,7 +428,7 @@ tape( 'if a predicate function length is 0, the function invokes a predicate fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -460,7 +460,7 @@ tape( 'by default, the function processes collection elements concurrently', fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -496,7 +496,7 @@ tape( 'the function supports processing collection elements sequentially (in ser
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -533,7 +533,7 @@ tape( 'the function supports processing collection elements sequentially (limit
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -570,7 +570,7 @@ tape( 'the function supports limiting the maximum number of collection elements
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -606,7 +606,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -639,7 +639,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -675,7 +675,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -707,7 +707,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -736,7 +736,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -769,7 +769,7 @@ tape( 'if a predicate function returns a falsy test result, the function suspend
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -805,7 +805,7 @@ tape( 'if a predicate function returns a falsy test result, the function suspend
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -837,7 +837,7 @@ tape( 'if a predicate function returns a falsy test result, the function suspend
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -856,7 +856,7 @@ tape( 'if provided an empty collection, the function never invokes a predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -880,7 +880,7 @@ tape( 'the function does not guarantee asynchronous execution', function test( t
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/none-by-right/test/test.main.js b/lib/node_modules/@stdlib/utils/async/none-by-right/test/test.main.js
index 3a3b2508c47e..797a1a7cf5fc 100644
--- a/lib/node_modules/@stdlib/utils/async/none-by-right/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/async/none-by-right/test/test.main.js
@@ -285,7 +285,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -322,7 +322,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -360,7 +360,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -400,7 +400,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function invo
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -440,7 +440,7 @@ tape( 'if a predicate function length is 0, the function invokes a predicate fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -472,7 +472,7 @@ tape( 'by default, the function processes collection elements concurrently', fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -508,7 +508,7 @@ tape( 'the function supports processing collection elements sequentially (in ser
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -545,7 +545,7 @@ tape( 'the function supports processing collection elements sequentially (limit
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -582,7 +582,7 @@ tape( 'the function supports limiting the maximum number of collection elements
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -618,7 +618,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -651,7 +651,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -687,7 +687,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -719,7 +719,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -748,7 +748,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -781,7 +781,7 @@ tape( 'if a predicate function returns a truthy test result, the function suspen
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -817,7 +817,7 @@ tape( 'if a predicate function returns a truthy test result, the function suspen
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -849,7 +849,7 @@ tape( 'if a predicate function returns a truthy test result, the function suspen
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -868,7 +868,7 @@ tape( 'if provided an empty collection, the function never invokes a predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -892,7 +892,7 @@ tape( 'the function does not guarantee asynchronous execution', function test( t
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/none-by/test/test.main.js b/lib/node_modules/@stdlib/utils/async/none-by/test/test.main.js
index 8958a7ff509b..534fef966a63 100644
--- a/lib/node_modules/@stdlib/utils/async/none-by/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/async/none-by/test/test.main.js
@@ -285,7 +285,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -319,7 +319,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -354,7 +354,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -391,7 +391,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function invo
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -428,7 +428,7 @@ tape( 'if a predicate function length is 0, the function invokes a predicate fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -460,7 +460,7 @@ tape( 'by default, the function processes collection elements concurrently', fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -496,7 +496,7 @@ tape( 'the function supports processing collection elements sequentially (in ser
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -533,7 +533,7 @@ tape( 'the function supports processing collection elements sequentially (limit
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -570,7 +570,7 @@ tape( 'the function supports limiting the maximum number of collection elements
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -606,7 +606,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -639,7 +639,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -675,7 +675,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -707,7 +707,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -736,7 +736,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -769,7 +769,7 @@ tape( 'if a predicate function returns a truthy test result, the function suspen
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -805,7 +805,7 @@ tape( 'if a predicate function returns a truthy test result, the function suspen
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -837,7 +837,7 @@ tape( 'if a predicate function returns a truthy test result, the function suspen
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -856,7 +856,7 @@ tape( 'if provided an empty collection, the function never invokes a predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -880,7 +880,7 @@ tape( 'the function does not guarantee asynchronous execution', function test( t
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/some-by-right/test/test.main.js b/lib/node_modules/@stdlib/utils/async/some-by-right/test/test.main.js
index 9e1ad7a35427..1a5d97425571 100644
--- a/lib/node_modules/@stdlib/utils/async/some-by-right/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/async/some-by-right/test/test.main.js
@@ -322,7 +322,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -359,7 +359,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -397,7 +397,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -437,7 +437,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function invo
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -477,7 +477,7 @@ tape( 'if a predicate function length is 0, the function invokes a predicate fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -509,7 +509,7 @@ tape( 'by default, the function processes collection elements concurrently', fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -545,7 +545,7 @@ tape( 'the function supports processing collection elements sequentially (in ser
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -582,7 +582,7 @@ tape( 'the function supports processing collection elements sequentially (limit
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -619,7 +619,7 @@ tape( 'the function supports limiting the maximum number of collection elements
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -655,7 +655,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -688,7 +688,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -724,7 +724,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -756,7 +756,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -785,7 +785,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -818,7 +818,7 @@ tape( 'if a predicate function returns `n` truthy test results, the function sus
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -854,7 +854,7 @@ tape( 'if a predicate function returns `n` truthy test results, the function sus
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -886,7 +886,7 @@ tape( 'if a predicate function returns `n` truthy test results, the function sus
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -905,7 +905,7 @@ tape( 'if provided an empty collection, the function never invokes a predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -929,7 +929,7 @@ tape( 'the function does not guarantee asynchronous execution', function test( t
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/some-by/test/test.main.js b/lib/node_modules/@stdlib/utils/async/some-by/test/test.main.js
index 782a3fe87cd2..95801430331d 100644
--- a/lib/node_modules/@stdlib/utils/async/some-by/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/async/some-by/test/test.main.js
@@ -322,7 +322,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -356,7 +356,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -391,7 +391,7 @@ tape( 'the function invokes a predicate function once for each element in a coll
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -428,7 +428,7 @@ tape( 'if a predicate function accepts fewer than 2 arguments, the function invo
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -465,7 +465,7 @@ tape( 'if a predicate function length is 0, the function invokes a predicate fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -497,7 +497,7 @@ tape( 'by default, the function processes collection elements concurrently', fun
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -533,7 +533,7 @@ tape( 'the function supports processing collection elements sequentially (in ser
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -570,7 +570,7 @@ tape( 'the function supports processing collection elements sequentially (limit
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -607,7 +607,7 @@ tape( 'the function supports limiting the maximum number of collection elements
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -643,7 +643,7 @@ tape( 'the function supports specifying an execution context for the predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -676,7 +676,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -712,7 +712,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -744,7 +744,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -773,7 +773,7 @@ tape( 'if an error is encountered while processing a collection element, the fun
 		} else {
 			t.fail( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -806,7 +806,7 @@ tape( 'if a predicate function returns `n` truthy test results, the function sus
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -842,7 +842,7 @@ tape( 'if a predicate function returns `n` truthy test results, the function sus
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -874,7 +874,7 @@ tape( 'if a predicate function returns `n` truthy test results, the function sus
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, true, 'returns true' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -893,7 +893,7 @@ tape( 'if provided an empty collection, the function never invokes a predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
 });
@@ -917,7 +917,7 @@ tape( 'the function does not guarantee asynchronous execution', function test( t
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.strictEqual( bool, false, 'returns false' );
+		t.strictEqual( bool, false, 'returns expected value' );
 		t.strictEqual( i, 0, 'releases the zalgo' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/deep-set/test/test.dset.js b/lib/node_modules/@stdlib/utils/deep-set/test/test.dset.js
index 3eeb4e78c902..0530f3ee5e04 100644
--- a/lib/node_modules/@stdlib/utils/deep-set/test/test.dset.js
+++ b/lib/node_modules/@stdlib/utils/deep-set/test/test.dset.js
@@ -76,7 +76,7 @@ tape( 'the function deep sets a nested property value', function test( t ) {
 
 	bool = dset( obj, ['a', 'b', 'c'], false, 'beep' );
 	t.deepEqual( obj, expected, 'deep sets object' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -104,7 +104,7 @@ tape( 'the function returns `true` if able to successfully set', function test(
 	};
 
 	bool = dset( obj, ['a', 'b', 'c'], false, 'beep' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -132,10 +132,10 @@ tape( 'the function returns `false` if unable to successfully set', function tes
 	};
 
 	bool = dset( obj, ['a', 'b', 'djfajdfaj'], false, 'beep' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	bool = dset( obj, ['null', 'e'], false, 'beep' );
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -183,7 +183,7 @@ tape( 'the function deep sets an array', function test( t ) {
 
 	bool = dset( obj, ['arr', 0, 'y'], false, 200 );
 	t.deepEqual( obj, expected, 'deep sets object' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -234,7 +234,7 @@ tape( 'the function creates properties which do not exist', function test( t ) {
 
 	bool = dset( obj, ['arr', 2, 'y'], true, 200 );
 	t.deepEqual( obj, expected, 'deep sets object' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -283,7 +283,7 @@ tape( 'the function deep sets using a callback function', function test( t ) {
 
 	bool = dset( obj, ['a', 'b', 'c'], false, set );
 	t.deepEqual( obj, expected, 'deep sets object' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 
 	function set( val ) {
diff --git a/lib/node_modules/@stdlib/utils/deep-set/test/test.js b/lib/node_modules/@stdlib/utils/deep-set/test/test.js
index 2f3a44bef5c0..be3ca4522125 100644
--- a/lib/node_modules/@stdlib/utils/deep-set/test/test.js
+++ b/lib/node_modules/@stdlib/utils/deep-set/test/test.js
@@ -52,7 +52,7 @@ tape( 'the function returns `false` if provided a non-object or null', function
 	];
 
 	for ( i = 0; i < values.length; i++ ) {
-		t.strictEqual( deepSet( values[ i ], 'a.b.c', 5 ), false, 'returns false' );
+		t.strictEqual( deepSet( values[ i ], 'a.b.c', 5 ), false, 'returns expected value' );
 	}
 	t.end();
 });
@@ -156,12 +156,12 @@ tape( 'the function returns a boolean', function test( t ) {
 		'a': 5
 	};
 	bool = deepSet( obj, 'a', 4 );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	bool = deepSet( obj, 'b', 4, {
 		'create': false
 	});
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 
 	t.end();
 });
@@ -184,7 +184,7 @@ tape( 'the function deep sets', function test( t ) {
 		}
 	};
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.deepEqual( obj, expected, 'deep sets object' );
 
 	bool = deepSet( obj, ['a', 'b'], 40 );
@@ -194,7 +194,7 @@ tape( 'the function deep sets', function test( t ) {
 		}
 	};
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.deepEqual( obj, expected, 'deep sets object' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/every-by-right/test/test.js b/lib/node_modules/@stdlib/utils/every-by-right/test/test.js
index 0528384eea71..35429a2f18be 100644
--- a/lib/node_modules/@stdlib/utils/every-by-right/test/test.js
+++ b/lib/node_modules/@stdlib/utils/every-by-right/test/test.js
@@ -111,7 +111,7 @@ tape( 'if provided an empty collection, the function returns `true`', function t
 	arr = [];
 	bool = everyByRight( arr, foo );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -123,7 +123,7 @@ tape( 'the function returns `true` if all elements pass a test (array)', functio
 
 	bool = everyByRight( arr, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -135,7 +135,7 @@ tape( 'the function returns `false` if one or more elements fail a test (array)'
 
 	bool = everyByRight( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -152,7 +152,7 @@ tape( 'the function returns `true` if all elements pass a test (array-like objec
 
 	bool = everyByRight( arr, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -169,7 +169,7 @@ tape( 'the function returns `false` if one or more elements fail a test (array-l
 
 	bool = everyByRight( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -181,7 +181,7 @@ tape( 'the function returns `true` if all elements pass a test (typed array)', f
 
 	bool = everyByRight( arr, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -193,7 +193,7 @@ tape( 'the function returns `false` if one or more elements fail a test (typed a
 
 	bool = everyByRight( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -220,7 +220,7 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = everyByRight( arr, sum, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( ctx.sum/ctx.count, 2.0, 'expected result' );
 
 	t.end();
@@ -245,7 +245,7 @@ tape( 'the function provides basic support for dynamic arrays', function test( t
 	bool = everyByRight( arr, isPositive );
 
 	t.deepEqual( arr, [ 10, 9, 8, 7, 6, 5, 4, 1, 2, 3 ], 'expected result' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -268,6 +268,6 @@ tape( 'the function does not skip empty elements', function test( t ) {
 
 	bool = everyByRight( arr, verify );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/every-by/test/test.js b/lib/node_modules/@stdlib/utils/every-by/test/test.js
index 4147d0171294..bdab5f0e12fe 100644
--- a/lib/node_modules/@stdlib/utils/every-by/test/test.js
+++ b/lib/node_modules/@stdlib/utils/every-by/test/test.js
@@ -111,7 +111,7 @@ tape( 'if provided an empty collection, the function returns `true`', function t
 	arr = [];
 	bool = everyBy( arr, foo );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -123,7 +123,7 @@ tape( 'the function returns `true` if all elements pass a test (array)', functio
 
 	bool = everyBy( arr, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -135,7 +135,7 @@ tape( 'the function returns `false` if one or more elements fail a test (array)'
 
 	bool = everyBy( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -152,7 +152,7 @@ tape( 'the function returns `true` if all elements pass a test (array-like objec
 
 	bool = everyBy( arr, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -169,7 +169,7 @@ tape( 'the function returns `false` if one or more elements fail a test (array-l
 
 	bool = everyBy( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -181,7 +181,7 @@ tape( 'the function returns `true` if all elements pass a test (typed array)', f
 
 	bool = everyBy( arr, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -193,7 +193,7 @@ tape( 'the function returns `false` if one or more elements fail a test (typed a
 
 	bool = everyBy( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -220,7 +220,7 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = everyBy( arr, sum, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( ctx.sum/ctx.count, 2.0, 'expected result' );
 
 	t.end();
@@ -242,7 +242,7 @@ tape( 'the function provides basic support for dynamic arrays', function test( t
 	bool = everyBy( arr, isPositive );
 
 	t.deepEqual( arr, [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ], 'expected result' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -262,6 +262,6 @@ tape( 'the function does not skip empty elements', function test( t ) {
 
 	bool = everyBy( arr, verify );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/every/test/test.js b/lib/node_modules/@stdlib/utils/every/test/test.js
index aeedc6cee29a..87587a30174c 100644
--- a/lib/node_modules/@stdlib/utils/every/test/test.js
+++ b/lib/node_modules/@stdlib/utils/every/test/test.js
@@ -70,7 +70,7 @@ tape( 'if provided an empty collection, the function returns `true`', function t
 	arr = [];
 	bool = every( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -81,7 +81,7 @@ tape( 'the function returns `true` if all elements are truthy (array)', function
 	arr = [ 1, 1, 1, 1, 1 ];
 	bool = every( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -92,7 +92,7 @@ tape( 'the function returns `false` if at least one element is falsy (array)', f
 	arr = [ 1, 1, 0 ];
 	bool = every( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -110,7 +110,7 @@ tape( 'the function returns `true` if all elements are truthy (array-like object
 
 	bool = every( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -127,7 +127,7 @@ tape( 'the function returns `false` if at least one element is falsy (array-like
 
 	bool = every( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -138,7 +138,7 @@ tape( 'the function returns `true` if all elements are truthy (typed array)', fu
 	arr = new Float64Array( [ 1.0, 1.0, 1.0, 1.0 ] );
 	bool = every( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -149,6 +149,6 @@ tape( 'the function returns `false` if at least one element is falsy (typed arra
 	arr = new Float64Array( [ 1.0, 0.0, 1.0 ] );
 	bool = every( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/none-by-right/test/test.js b/lib/node_modules/@stdlib/utils/none-by-right/test/test.js
index df65bc459a12..50f9277d835c 100644
--- a/lib/node_modules/@stdlib/utils/none-by-right/test/test.js
+++ b/lib/node_modules/@stdlib/utils/none-by-right/test/test.js
@@ -111,7 +111,7 @@ tape( 'if provided an empty collection, the function returns `true`', function t
 	arr = [];
 	bool = noneByRight( arr, foo );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -123,7 +123,7 @@ tape( 'the function returns `true` if all elements fail a test (array)', functio
 
 	bool = noneByRight( arr, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -135,7 +135,7 @@ tape( 'the function returns `false` if one or more elements pass a test (array)'
 
 	bool = noneByRight( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -152,7 +152,7 @@ tape( 'the function returns `true` if all elements fail a test (array-like objec
 
 	bool = noneByRight( arr, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -169,7 +169,7 @@ tape( 'the function returns `false` if one or more elements pass a test (array-l
 
 	bool = noneByRight( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -181,7 +181,7 @@ tape( 'the function returns `true` if all elements fail a test (typed array)', f
 
 	bool = noneByRight( arr, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -193,7 +193,7 @@ tape( 'the function returns `false` if one or more elements pass a test (typed a
 
 	bool = noneByRight( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -220,7 +220,7 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = noneByRight( arr, sum, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( ctx.sum/ctx.count, 2.0, 'expected result' );
 
 	t.end();
@@ -245,7 +245,7 @@ tape( 'the function provides basic support for dynamic arrays', function test( t
 	bool = noneByRight( arr, isNegative );
 
 	t.deepEqual( arr, [ 10, 9, 8, 7, 6, 5, 4, 1, 2, 3 ], 'expected result' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -268,6 +268,6 @@ tape( 'the function does not skip empty elements', function test( t ) {
 
 	bool = noneByRight( arr, verify );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/none-by/test/test.js b/lib/node_modules/@stdlib/utils/none-by/test/test.js
index 852245157457..27c1a0535bb1 100644
--- a/lib/node_modules/@stdlib/utils/none-by/test/test.js
+++ b/lib/node_modules/@stdlib/utils/none-by/test/test.js
@@ -111,7 +111,7 @@ tape( 'if provided an empty collection, the function returns `true`', function t
 	arr = [];
 	bool = noneBy( arr, foo );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -123,7 +123,7 @@ tape( 'the function returns `true` if all elements fail a test (array)', functio
 
 	bool = noneBy( arr, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -135,7 +135,7 @@ tape( 'the function returns `false` if one or more elements pass a test (array)'
 
 	bool = noneBy( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -152,7 +152,7 @@ tape( 'the function returns `true` if all elements fail a test (array-like objec
 
 	bool = noneBy( arr, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -169,7 +169,7 @@ tape( 'the function returns `false` if one or more elements pass a test (array-l
 
 	bool = noneBy( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -181,7 +181,7 @@ tape( 'the function returns `true` if all elements fail a test (typed array)', f
 
 	bool = noneBy( arr, isPositive );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -193,7 +193,7 @@ tape( 'the function returns `false` if one or more elements pass a test (typed a
 
 	bool = noneBy( arr, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -220,7 +220,7 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = noneBy( arr, sum, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( ctx.sum/ctx.count, 2.0, 'expected result' );
 
 	t.end();
@@ -242,7 +242,7 @@ tape( 'the function provides basic support for dynamic arrays', function test( t
 	bool = noneBy( arr, isNegative );
 
 	t.deepEqual( arr, [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ], 'expected result' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -262,6 +262,6 @@ tape( 'the function does not skip empty elements', function test( t ) {
 
 	bool = noneBy( arr, verify );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/none-own-by/test/test.js b/lib/node_modules/@stdlib/utils/none-own-by/test/test.js
index eac557e482e6..04f89b0cdd51 100644
--- a/lib/node_modules/@stdlib/utils/none-own-by/test/test.js
+++ b/lib/node_modules/@stdlib/utils/none-own-by/test/test.js
@@ -97,7 +97,7 @@ tape( 'the function returns `true` if all own properties fail a test ', function
 
 	bool = noneOwnBy( obj, underAge );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -117,6 +117,6 @@ tape( 'the function returns `false` if one or more own properties pass a test',
 
 	bool = noneOwnBy( obj, underAge );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/none/test/test.js b/lib/node_modules/@stdlib/utils/none/test/test.js
index 3ca149fd68cd..d1938e416bd0 100644
--- a/lib/node_modules/@stdlib/utils/none/test/test.js
+++ b/lib/node_modules/@stdlib/utils/none/test/test.js
@@ -70,7 +70,7 @@ tape( 'if provided an empty collection, the function returns `true`', function t
 	arr = [];
 	bool = none( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -81,7 +81,7 @@ tape( 'the function returns `true` if all elements are falsy (array)', function
 	arr = [ 0, 0, 0, 0, 0 ];
 	bool = none( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -92,7 +92,7 @@ tape( 'the function returns `false` if at least one element is truthy (array)',
 	arr = [ 0, 0, 1 ];
 	bool = none( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -110,7 +110,7 @@ tape( 'the function returns `true` if all elements are falsy (array-like object)
 
 	bool = none( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -127,7 +127,7 @@ tape( 'the function returns `false` if at least one element is truthy (array-lik
 
 	bool = none( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -138,7 +138,7 @@ tape( 'the function returns `true` if all elements are falsy (typed array)', fun
 	arr = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
 	bool = none( arr );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -149,6 +149,6 @@ tape( 'the function returns `false` if at least one element is truthy (typed arr
 	arr = new Float64Array( [ 0.0, 1.0, 0.0 ] );
 	bool = none( arr );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/some-by-right/test/test.js b/lib/node_modules/@stdlib/utils/some-by-right/test/test.js
index 1730afe270db..88fe8689ebd6 100644
--- a/lib/node_modules/@stdlib/utils/some-by-right/test/test.js
+++ b/lib/node_modules/@stdlib/utils/some-by-right/test/test.js
@@ -146,7 +146,7 @@ tape( 'if provided an empty collection, the function returns `false`', function
 	arr = [];
 	bool = someByRight( arr, 1, foo );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -158,7 +158,7 @@ tape( 'the function returns `true` if a collection contains at least `n` element
 
 	bool = someByRight( arr, 2, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -170,7 +170,7 @@ tape( 'the function returns `false` if a collection does not contain at least `n
 
 	bool = someByRight( arr, 1, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -192,7 +192,7 @@ tape( 'the function returns `true` if a collection contains at least `n` element
 
 	bool = someByRight( arr, 2, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -209,7 +209,7 @@ tape( 'the function returns `false` if a collection does not contain at least `n
 
 	bool = someByRight( arr, 1, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -221,7 +221,7 @@ tape( 'the function returns `true` if a collection contains at least `n` element
 
 	bool = someByRight( arr, 3, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -233,7 +233,7 @@ tape( 'the function returns `false` if a collection does not contain at least `n
 
 	bool = someByRight( arr, 1, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -257,7 +257,7 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = someByRight( arr, 2, sum, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( ctx.sum/ctx.count, -0.25, 'expected result' );
 
 	t.end();
@@ -279,7 +279,7 @@ tape( 'the function provides basic support for dynamic arrays', function test( t
 	bool = someByRight( arr, 1, isNegative );
 
 	t.deepEqual( arr, [ -2, -1, 0, 1, 2, 3 ], 'expected result' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -302,6 +302,6 @@ tape( 'the function does not skip empty elements', function test( t ) {
 
 	bool = someByRight( arr, 1, verify );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/some-by/test/test.js b/lib/node_modules/@stdlib/utils/some-by/test/test.js
index e40dc1a6555f..674191fb445d 100644
--- a/lib/node_modules/@stdlib/utils/some-by/test/test.js
+++ b/lib/node_modules/@stdlib/utils/some-by/test/test.js
@@ -146,7 +146,7 @@ tape( 'if provided an empty collection, the function returns `false`', function
 	arr = [];
 	bool = someBy( arr, 1, foo );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -158,7 +158,7 @@ tape( 'the function returns `true` if a collection contains at least `n` element
 
 	bool = someBy( arr, 2, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -170,7 +170,7 @@ tape( 'the function returns `false` if a collection does not contain at least `n
 
 	bool = someBy( arr, 1, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -188,7 +188,7 @@ tape( 'the function returns `true` if a collection contains at least `n` element
 
 	bool = someBy( arr, 2, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -205,7 +205,7 @@ tape( 'the function returns `false` if a collection does not contain at least `n
 
 	bool = someBy( arr, 2, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -217,7 +217,7 @@ tape( 'the function returns `true` if a collection contains at least `n` element
 
 	bool = someBy( arr, 2, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -229,7 +229,7 @@ tape( 'the function returns `false` if a collection does not contain at least `n
 
 	bool = someBy( arr, 4, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -253,7 +253,7 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = someBy( arr, 2, sum, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( ctx.sum/ctx.count, 0.25, 'expected result' );
 
 	t.end();
@@ -275,7 +275,7 @@ tape( 'the function provides basic support for dynamic arrays', function test( t
 	bool = someBy( arr, 1, isNegative );
 
 	t.deepEqual( arr, [ 1, 2, 3, 2, 1, 0, -1, -2 ], 'expected result' );
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 
 	t.end();
 });
@@ -295,6 +295,6 @@ tape( 'the function does not skip empty elements', function test( t ) {
 
 	bool = someBy( arr, 1, verify );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/some-own-by/test/test.js b/lib/node_modules/@stdlib/utils/some-own-by/test/test.js
index fa453fa2e71e..97ae50803b51 100644
--- a/lib/node_modules/@stdlib/utils/some-own-by/test/test.js
+++ b/lib/node_modules/@stdlib/utils/some-own-by/test/test.js
@@ -151,7 +151,7 @@ tape( 'if provided an empty object, the function returns `false`', function test
 	obj = {};
 	bool = someOwnBy( obj, 1, foo );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -168,7 +168,7 @@ tape( 'the function returns `true` if an object contains at least `n` own proper
 
 	bool = someOwnBy( obj, 2, isNegative );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -184,7 +184,7 @@ tape( 'the function returns `false` if an object does not contain at least `n` o
 
 	bool = someOwnBy( obj, 1, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -200,7 +200,7 @@ tape( 'the function returns `false` if an object does not contain at least `n` o
 
 	bool = someOwnBy( obj, 4, isPositive );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -229,7 +229,7 @@ tape( 'the function supports providing an execution context', function test( t )
 
 	bool = someOwnBy( obj, 2, sum, ctx );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.strictEqual( ctx.sum/ctx.count, 0.25, 'expected result' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/utils/some/test/test.js b/lib/node_modules/@stdlib/utils/some/test/test.js
index d32fd1653749..50c7e13a05ca 100644
--- a/lib/node_modules/@stdlib/utils/some/test/test.js
+++ b/lib/node_modules/@stdlib/utils/some/test/test.js
@@ -100,7 +100,7 @@ tape( 'if provided an empty collection, the function returns `false`', function
 	arr = [];
 	bool = some( arr, 1 );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -111,7 +111,7 @@ tape( 'the function returns `true` if at least `n` elements are truthy (array)',
 	arr = [ 0, 0, 1, 2, 3 ];
 	bool = some( arr, 3 );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -122,7 +122,7 @@ tape( 'the function returns `false` if fewer than `n` elements are truthy (array
 	arr = [ 1, 2, 3 ];
 	bool = some( arr, 4 );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -140,7 +140,7 @@ tape( 'the function returns `true` if at least `n` elements are truthy (array-li
 
 	bool = some( arr, 2 );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -157,7 +157,7 @@ tape( 'the function returns `false` if fewer than `n` elements are truthy (array
 
 	bool = some( arr, 1 );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
 
@@ -168,7 +168,7 @@ tape( 'the function returns `true` if at least `n` elements are truthy (typed ar
 	arr = new Float64Array( [ 0.0, 0.0, 2.0, 3.14 ] );
 	bool = some( arr, 2 );
 
-	t.strictEqual( bool, true, 'returns true' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -179,6 +179,6 @@ tape( 'the function returns `false` if fewer than `n` elements are truthy (typed
 	arr = new Float64Array( 3 );
 	bool = some( arr, 1 );
 
-	t.strictEqual( bool, false, 'returns false' );
+	t.strictEqual( bool, false, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/utils/type-of/test/test.check.js b/lib/node_modules/@stdlib/utils/type-of/test/test.check.js
index a815b72065d4..a784e69a3390 100644
--- a/lib/node_modules/@stdlib/utils/type-of/test/test.check.js
+++ b/lib/node_modules/@stdlib/utils/type-of/test/test.check.js
@@ -43,7 +43,7 @@ tape( 'the function returns `true` if the built-in `typeof` operator returns `\'
 		'./fixtures/re.js': noop
 	});
 
-	t.strictEqual( check(), true, 'returns true' );
+	t.strictEqual( check(), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,7 +52,7 @@ tape( 'the function returns `true` if the built-in `typeof` operator returns `\'
 		'./fixtures/typedarray.js': {}
 	});
 
-	t.strictEqual( check(), true, 'returns true' );
+	t.strictEqual( check(), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,7 +61,7 @@ tape( 'the function returns `true` if the built-in `typeof` operator returns `\'
 		'./fixtures/nodelist.js': noop
 	});
 
-	t.strictEqual( check(), true, 'returns true' );
+	t.strictEqual( check(), true, 'returns expected value' );
 	t.end();
 });
 
@@ -72,6 +72,6 @@ tape( 'the function returns `false` if the built-in `typeof` operator behaves ac
 		'./fixtures/nodelist.js': {} // rough proxy, as should return same result
 	});
 
-	t.strictEqual( check(), false, 'returns false' );
+	t.strictEqual( check(), false, 'returns expected value' );
 	t.end();
 });

From fc438e0edbad0689d6923d6f3edb959b96597662 Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Thu, 14 Aug 2025 16:40:06 -0500
Subject: [PATCH 16/32] test: use standardized assertion messages and fix lint
 errors

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../float64/base/div/test/test.main.js        | 28 ++++----
 .../float64/base/div/test/test.native.js      | 28 ++++----
 .../float64/base/div/test/test.strided.js     | 28 ++++----
 .../math/base/special/abs/test/test.abs.js    |  6 +-
 .../math/base/special/abs/test/test.js        |  6 +-
 .../math/base/special/abs/test/test.native.js |  6 +-
 .../math/base/special/asec/test/test.js       | 10 +--
 .../base/special/asec/test/test.native.js     | 10 +--
 .../math/base/special/asecd/test/test.js      |  2 +-
 .../base/special/asecd/test/test.native.js    |  2 +-
 .../math/base/special/asech/test/test.js      |  6 +-
 .../base/special/asech/test/test.native.js    |  6 +-
 .../math/base/special/asin/test/test.js       |  2 +-
 .../base/special/asin/test/test.native.js     |  2 +-
 .../base/special/asind/test/test.native.js    |  2 +-
 .../math/base/special/asinf/test/test.js      |  2 +-
 .../base/special/asinf/test/test.native.js    |  2 +-
 .../math/base/special/asinh/test/test.js      | 10 +--
 .../base/special/asinh/test/test.native.js    | 10 +--
 .../math/base/special/atand/test/test.js      |  2 +-
 .../base/special/atand/test/test.native.js    |  2 +-
 .../math/base/special/atanf/test/test.js      |  8 +--
 .../base/special/atanf/test/test.native.js    |  8 +--
 .../math/base/special/atanh/test/test.js      | 10 +--
 .../base/special/atanh/test/test.native.js    | 10 +--
 .../math/base/special/avercos/test/test.js    |  2 +-
 .../base/special/avercos/test/test.native.js  |  2 +-
 .../math/base/special/aversin/test/test.js    |  2 +-
 .../base/special/aversin/test/test.native.js  |  2 +-
 .../math/base/special/cabs2/test/test.js      |  6 +-
 .../base/special/cabs2/test/test.native.js    |  6 +-
 .../math/base/special/deg2rad/test/test.js    |  8 +--
 .../base/special/deg2rad/test/test.native.js  |  8 +--
 .../math/base/special/deg2radf/test/test.js   |  8 +--
 .../base/special/deg2radf/test/test.native.js |  8 +--
 .../math/base/special/digamma/test/test.js    |  4 +-
 .../base/special/dirac-delta/test/test.js     |  8 +--
 .../special/dirac-delta/test/test.native.js   |  8 +--
 .../base/special/dirac-deltaf/test/test.js    |  8 +--
 .../special/dirac-deltaf/test/test.native.js  |  8 +--
 .../math/base/special/erf/test/test.js        |  8 +--
 .../math/base/special/erf/test/test.native.js |  8 +--
 .../math/base/special/expit/test/test.js      |  6 +-
 .../base/special/expit/test/test.native.js    |  6 +-
 .../base/special/fast/min/test/test.native.js |  2 +-
 .../base/special/fresnel/test/test.assign.js  |  4 +-
 .../base/special/fresnel/test/test.main.js    |  4 +-
 .../math/base/special/fresnelc/test/test.js   |  2 +-
 .../math/base/special/fresnels/test/test.js   |  2 +-
 .../base/special/kronecker-delta/test/test.js |  6 +-
 .../kronecker-delta/test/test.native.js       |  6 +-
 .../special/kronecker-deltaf/test/test.js     |  6 +-
 .../kronecker-deltaf/test/test.native.js      |  6 +-
 .../math/base/special/ldexp/test/test.js      | 18 ++---
 .../base/special/ldexp/test/test.native.js    | 18 ++---
 .../@stdlib/math/base/special/ln/test/test.js |  2 +-
 .../math/base/special/ln/test/test.native.js  |  2 +-
 .../math/base/special/log/test/test.js        | 14 ++--
 .../math/base/special/log/test/test.native.js | 14 ++--
 .../math/base/special/lucas/test/test.js      |  4 +-
 .../math/base/special/polygamma/test/test.js  | 14 ++--
 .../utils/absolute-difference/test/test.js    | 22 +++---
 .../float64-epsilon-difference/test/test.js   | 40 +++++------
 .../utils/relative-difference/test/test.js    | 40 +++++------
 .../base/from-binary-string/test/test.js      | 10 +--
 .../number/float32/base/identity/test/test.js |  2 +-
 .../float32/base/identity/test/test.native.js |  2 +-
 .../base/from-binary-string/test/test.js      | 10 +--
 .../number/float64/base/identity/test/test.js |  2 +-
 .../float64/base/identity/test/test.native.js |  2 +-
 .../float64/base/to-float32/test/test.js      |  8 +--
 .../base/to-float32/test/test.polyfill.js     |  8 +--
 .../dists/arcsine/cdf/test/test.factory.js    | 26 +++----
 .../base/dists/arcsine/cdf/test/test.main.js  | 18 ++---
 .../dists/arcsine/cdf/test/test.native.js     | 18 ++---
 .../base/dists/arcsine/entropy/test/test.js   | 12 ++--
 .../dists/arcsine/entropy/test/test.native.js | 12 ++--
 .../base/dists/arcsine/kurtosis/test/test.js  | 12 ++--
 .../arcsine/kurtosis/test/test.native.js      | 12 ++--
 .../dists/arcsine/logcdf/test/test.factory.js | 26 +++----
 .../dists/arcsine/logcdf/test/test.logcdf.js  | 18 ++---
 .../dists/arcsine/logpdf/test/test.factory.js | 26 +++----
 .../dists/arcsine/logpdf/test/test.logpdf.js  | 18 ++---
 .../dists/arcsine/logpdf/test/test.native.js  | 18 ++---
 .../base/dists/arcsine/mean/test/test.js      | 12 ++--
 .../dists/arcsine/mean/test/test.native.js    | 12 ++--
 .../base/dists/arcsine/median/test/test.js    | 12 ++--
 .../dists/arcsine/median/test/test.native.js  | 12 ++--
 .../base/dists/arcsine/mode/test/test.js      | 12 ++--
 .../dists/arcsine/mode/test/test.native.js    | 12 ++--
 .../dists/arcsine/pdf/test/test.factory.js    | 26 +++----
 .../dists/arcsine/pdf/test/test.native.js     | 18 ++---
 .../base/dists/arcsine/pdf/test/test.pdf.js   | 18 ++---
 .../arcsine/quantile/test/test.factory.js     | 22 +++---
 .../base/dists/arcsine/skewness/test/test.js  | 14 ++--
 .../arcsine/skewness/test/test.native.js      | 14 ++--
 .../base/dists/arcsine/stdev/test/test.js     | 12 ++--
 .../dists/arcsine/stdev/test/test.native.js   | 12 ++--
 .../base/dists/arcsine/variance/test/test.js  | 12 ++--
 .../arcsine/variance/test/test.native.js      | 12 ++--
 .../base/dists/bernoulli/cdf/test/test.cdf.js | 20 +++---
 .../dists/bernoulli/cdf/test/test.factory.js  | 26 +++----
 .../dists/bernoulli/cdf/test/test.native.js   | 20 +++---
 .../base/dists/bernoulli/entropy/test/test.js | 14 ++--
 .../bernoulli/entropy/test/test.native.js     | 14 ++--
 .../dists/bernoulli/kurtosis/test/test.js     | 14 ++--
 .../bernoulli/kurtosis/test/test.native.js    | 14 ++--
 .../base/dists/bernoulli/mean/test/test.js    | 10 +--
 .../dists/bernoulli/mean/test/test.native.js  | 10 +--
 .../base/dists/bernoulli/median/test/test.js  | 10 +--
 .../bernoulli/median/test/test.native.js      | 10 +--
 .../dists/bernoulli/mgf/test/test.factory.js  | 20 +++---
 .../base/dists/bernoulli/mgf/test/test.mgf.js | 12 ++--
 .../dists/bernoulli/mgf/test/test.native.js   | 12 ++--
 .../base/dists/bernoulli/mode/test/test.js    | 10 +--
 .../dists/bernoulli/mode/test/test.native.js  | 10 +--
 .../dists/bernoulli/pmf/test/test.factory.js  | 28 ++++----
 .../dists/bernoulli/pmf/test/test.native.js   | 22 +++---
 .../base/dists/bernoulli/pmf/test/test.pmf.js | 22 +++---
 .../bernoulli/quantile/test/test.factory.js   | 16 ++---
 .../dists/bernoulli/skewness/test/test.js     | 14 ++--
 .../bernoulli/skewness/test/test.native.js    | 14 ++--
 .../base/dists/bernoulli/stdev/test/test.js   | 14 ++--
 .../dists/bernoulli/stdev/test/test.native.js | 14 ++--
 .../dists/bernoulli/variance/test/test.js     | 14 ++--
 .../bernoulli/variance/test/test.native.js    | 14 ++--
 .../binomial/entropy/test/test.native.js      | 36 +++++-----
 .../dists/binomial/mgf/test/test.native.js    | 16 ++---
 .../dists/binomial/pmf/test/test.native.js    | 52 +++++++-------
 .../dists/bradford/median/test/test.native.js |  8 +--
 .../base/dists/bradford/skewness/test/test.js |  8 +--
 .../dists/bradford/stdev/test/test.native.js  |  2 +-
 .../bradford/variance/test/test.native.js     |  2 +-
 .../base/dists/chi/cdf/test/test.native.js    | 24 +++----
 .../base/dists/chi/logpdf/test/test.native.js | 16 ++---
 .../base/dists/chi/pdf/test/test.native.js    | 12 ++--
 .../dists/chisquare/cdf/test/test.native.js   | 10 +--
 .../dists/degenerate/cdf/test/test.cdf.js     | 12 ++--
 .../dists/degenerate/cdf/test/test.factory.js | 12 ++--
 .../dists/degenerate/cdf/test/test.native.js  | 12 ++--
 .../dists/degenerate/entropy/test/test.js     |  8 +--
 .../degenerate/entropy/test/test.native.js    |  8 +--
 .../degenerate/logcdf/test/test.factory.js    | 12 ++--
 .../degenerate/logcdf/test/test.logcdf.js     | 14 ++--
 .../degenerate/logcdf/test/test.native.js     | 14 ++--
 .../degenerate/logpdf/test/test.factory.js    | 14 ++--
 .../degenerate/logpdf/test/test.logpdf.js     | 16 ++---
 .../degenerate/logpdf/test/test.native.js     | 16 ++---
 .../degenerate/logpmf/test/test.factory.js    | 14 ++--
 .../degenerate/logpmf/test/test.logpmf.js     | 16 ++---
 .../degenerate/logpmf/test/test.native.js     | 16 ++---
 .../base/dists/degenerate/mean/test/test.js   |  2 +-
 .../dists/degenerate/mean/test/test.native.js |  2 +-
 .../base/dists/degenerate/median/test/test.js |  2 +-
 .../degenerate/median/test/test.native.js     |  2 +-
 .../dists/degenerate/mgf/test/test.factory.js |  4 +-
 .../dists/degenerate/mgf/test/test.mgf.js     |  6 +-
 .../dists/degenerate/mgf/test/test.native.js  |  6 +-
 .../base/dists/degenerate/mode/test/test.js   |  2 +-
 .../dists/degenerate/mode/test/test.native.js |  2 +-
 .../dists/degenerate/pdf/test/test.factory.js | 14 ++--
 .../dists/degenerate/pdf/test/test.native.js  | 16 ++---
 .../dists/degenerate/pdf/test/test.pdf.js     | 16 ++---
 .../dists/degenerate/pmf/test/test.factory.js | 14 ++--
 .../dists/degenerate/pmf/test/test.native.js  | 16 ++---
 .../dists/degenerate/pmf/test/test.pmf.js     | 16 ++---
 .../degenerate/quantile/test/test.factory.js  |  8 +--
 .../degenerate/quantile/test/test.native.js   | 10 +--
 .../degenerate/quantile/test/test.quantile.js | 10 +--
 .../base/dists/degenerate/stdev/test/test.js  |  8 +--
 .../degenerate/stdev/test/test.native.js      |  8 +--
 .../dists/degenerate/variance/test/test.js    |  8 +--
 .../degenerate/variance/test/test.native.js   |  8 +--
 .../discrete-uniform/cdf/test/test.cdf.js     | 18 ++---
 .../discrete-uniform/cdf/test/test.factory.js | 28 ++++----
 .../discrete-uniform/cdf/test/test.native.js  |  8 +--
 .../discrete-uniform/entropy/test/test.js     | 12 ++--
 .../entropy/test/test.native.js               |  2 +-
 .../discrete-uniform/kurtosis/test/test.js    | 12 ++--
 .../kurtosis/test/test.native.js              |  2 +-
 .../logcdf/test/test.factory.js               | 28 ++++----
 .../logcdf/test/test.logcdf.js                | 18 ++---
 .../logcdf/test/test.native.js                |  8 +--
 .../logpmf/test/test.factory.js               | 28 ++++----
 .../logpmf/test/test.logpmf.js                | 18 ++---
 .../logpmf/test/test.native.js                |  8 +--
 .../dists/discrete-uniform/mean/test/test.js  | 12 ++--
 .../discrete-uniform/mean/test/test.native.js |  2 +-
 .../discrete-uniform/median/test/test.js      | 12 ++--
 .../median/test/test.native.js                |  2 +-
 .../discrete-uniform/mgf/test/test.factory.js | 28 ++++----
 .../discrete-uniform/mgf/test/test.mgf.js     | 20 +++---
 .../discrete-uniform/mgf/test/test.native.js  | 10 +--
 .../discrete-uniform/pmf/test/test.factory.js | 28 ++++----
 .../discrete-uniform/pmf/test/test.native.js  |  8 +--
 .../discrete-uniform/pmf/test/test.pmf.js     | 18 ++---
 .../quantile/test/test.factory.js             | 26 +++----
 .../discrete-uniform/skewness/test/test.js    | 14 ++--
 .../skewness/test/test.native.js              |  4 +-
 .../dists/discrete-uniform/stdev/test/test.js | 12 ++--
 .../stdev/test/test.native.js                 |  2 +-
 .../discrete-uniform/variance/test/test.js    | 12 ++--
 .../variance/test/test.native.js              |  2 +-
 .../base/dists/erlang/cdf/test/test.cdf.js    | 34 +++++-----
 .../dists/erlang/cdf/test/test.factory.js     | 38 +++++------
 .../base/dists/erlang/entropy/test/test.js    | 30 ++++----
 .../dists/erlang/entropy/test/test.native.js  | 26 +++----
 .../base/dists/erlang/kurtosis/test/test.js   | 30 ++++----
 .../dists/erlang/kurtosis/test/test.native.js | 18 ++---
 .../dists/erlang/logpdf/test/test.factory.js  | 42 ++++++------
 .../dists/erlang/logpdf/test/test.logpdf.js   | 34 +++++-----
 .../stats/base/dists/erlang/mean/test/test.js | 30 ++++----
 .../dists/erlang/mean/test/test.native.js     | 26 +++----
 .../dists/erlang/mgf/test/test.factory.js     | 38 +++++------
 .../base/dists/erlang/mgf/test/test.mgf.js    | 34 +++++-----
 .../stats/base/dists/erlang/mode/test/test.js | 30 ++++----
 .../dists/erlang/mode/test/test.native.js     | 26 +++----
 .../dists/erlang/pdf/test/test.factory.js     | 42 ++++++------
 .../base/dists/erlang/pdf/test/test.pdf.js    | 34 +++++-----
 .../erlang/quantile/test/test.factory.js      | 38 +++++------
 .../base/dists/erlang/skewness/test/test.js   | 30 ++++----
 .../dists/erlang/skewness/test/test.native.js | 26 +++----
 .../base/dists/erlang/stdev/test/test.js      | 30 ++++----
 .../dists/erlang/stdev/test/test.native.js    | 26 +++----
 .../base/dists/erlang/variance/test/test.js   | 30 ++++----
 .../dists/erlang/variance/test/test.native.js | 26 +++----
 .../dists/exponential/cdf/test/test.cdf.js    | 22 +++---
 .../exponential/cdf/test/test.factory.js      | 20 +++---
 .../dists/exponential/cdf/test/test.native.js | 22 +++---
 .../dists/exponential/entropy/test/test.js    |  6 +-
 .../exponential/entropy/test/test.native.js   |  6 +-
 .../dists/exponential/kurtosis/test/test.js   |  6 +-
 .../exponential/kurtosis/test/test.native.js  |  6 +-
 .../exponential/logcdf/test/test.factory.js   | 20 +++---
 .../exponential/logcdf/test/test.logcdf.js    | 22 +++---
 .../exponential/logcdf/test/test.native.js    | 22 +++---
 .../exponential/logpdf/test/test.factory.js   | 20 +++---
 .../exponential/logpdf/test/test.logpdf.js    | 22 +++---
 .../exponential/logpdf/test/test.native.js    | 22 +++---
 .../base/dists/exponential/mean/test/test.js  |  6 +-
 .../exponential/mean/test/test.native.js      |  6 +-
 .../dists/exponential/median/test/test.js     |  6 +-
 .../exponential/median/test/test.native.js    |  6 +-
 .../exponential/mgf/test/test.factory.js      | 24 +++----
 .../dists/exponential/mgf/test/test.mgf.js    | 26 +++----
 .../dists/exponential/mgf/test/test.native.js | 26 +++----
 .../base/dists/exponential/mode/test/test.js  |  6 +-
 .../exponential/mode/test/test.native.js      |  6 +-
 .../exponential/pdf/test/test.factory.js      | 20 +++---
 .../dists/exponential/pdf/test/test.native.js | 18 ++---
 .../dists/exponential/pdf/test/test.pdf.js    | 22 +++---
 .../exponential/quantile/test/test.factory.js | 20 +++---
 .../dists/exponential/skewness/test/test.js   |  6 +-
 .../exponential/skewness/test/test.native.js  |  6 +-
 .../base/dists/exponential/stdev/test/test.js |  6 +-
 .../exponential/stdev/test/test.native.js     |  6 +-
 .../dists/exponential/variance/test/test.js   |  6 +-
 .../exponential/variance/test/test.native.js  |  6 +-
 .../stats/base/dists/f/cdf/test/test.cdf.js   | 34 +++++-----
 .../base/dists/f/cdf/test/test.factory.js     | 38 +++++------
 .../stats/base/dists/f/entropy/test/test.js   | 24 +++----
 .../base/dists/f/entropy/test/test.native.js  | 24 +++----
 .../stats/base/dists/f/kurtosis/test/test.js  | 40 +++++------
 .../base/dists/f/kurtosis/test/test.native.js | 40 +++++------
 .../stats/base/dists/f/mean/test/test.js      | 28 ++++----
 .../base/dists/f/mean/test/test.native.js     | 28 ++++----
 .../stats/base/dists/f/mode/test/test.js      | 28 ++++----
 .../base/dists/f/mode/test/test.native.js     | 28 ++++----
 .../base/dists/f/pdf/test/test.factory.js     | 54 +++++++--------
 .../stats/base/dists/f/pdf/test/test.pdf.js   | 46 ++++++-------
 .../dists/f/quantile/test/test.factory.js     | 42 ++++++------
 .../stats/base/dists/f/skewness/test/test.js  | 36 +++++-----
 .../base/dists/f/skewness/test/test.native.js | 36 +++++-----
 .../stats/base/dists/f/stdev/test/test.js     | 32 ++++-----
 .../base/dists/f/stdev/test/test.native.js    | 32 ++++-----
 .../stats/base/dists/f/variance/test/test.js  | 32 ++++-----
 .../base/dists/f/variance/test/test.native.js | 32 ++++-----
 .../base/dists/frechet/cdf/test/test.cdf.js   | 46 ++++++-------
 .../dists/frechet/cdf/test/test.factory.js    | 38 +++++------
 .../dists/frechet/cdf/test/test.native.js     | 46 ++++++-------
 .../base/dists/frechet/entropy/test/test.js   | 30 ++++----
 .../dists/frechet/entropy/test/test.native.js | 30 ++++----
 .../base/dists/frechet/kurtosis/test/test.js  | 30 ++++----
 .../frechet/kurtosis/test/test.native.js      | 30 ++++----
 .../dists/frechet/logcdf/test/test.factory.js | 38 +++++------
 .../dists/frechet/logcdf/test/test.logcdf.js  | 46 ++++++-------
 .../dists/frechet/logcdf/test/test.native.js  | 46 ++++++-------
 .../dists/frechet/logpdf/test/test.factory.js | 36 +++++-----
 .../dists/frechet/logpdf/test/test.logpdf.js  | 44 ++++++------
 .../dists/frechet/logpdf/test/test.native.js  | 44 ++++++------
 .../base/dists/frechet/mean/test/test.js      | 30 ++++----
 .../dists/frechet/mean/test/test.native.js    | 30 ++++----
 .../base/dists/frechet/median/test/test.js    | 30 ++++----
 .../dists/frechet/median/test/test.native.js  | 30 ++++----
 .../base/dists/frechet/mode/test/test.js      | 30 ++++----
 .../dists/frechet/mode/test/test.native.js    | 30 ++++----
 .../dists/frechet/pdf/test/test.factory.js    | 36 +++++-----
 .../base/dists/frechet/pdf/test/test.pdf.js   | 44 ++++++------
 .../frechet/quantile/test/test.factory.js     | 26 +++----
 .../frechet/quantile/test/test.native.js      | 40 +++++------
 .../base/dists/frechet/skewness/test/test.js  | 30 ++++----
 .../frechet/skewness/test/test.native.js      | 30 ++++----
 .../base/dists/frechet/stdev/test/test.js     | 30 ++++----
 .../dists/frechet/stdev/test/test.native.js   | 30 ++++----
 .../base/dists/frechet/variance/test/test.js  | 30 ++++----
 .../frechet/variance/test/test.native.js      | 30 ++++----
 .../base/dists/gamma/cdf/test/test.cdf.js     | 38 +++++------
 .../base/dists/gamma/cdf/test/test.factory.js | 44 ++++++------
 .../base/dists/gamma/cdf/test/test.native.js  | 32 ++++-----
 .../base/dists/gamma/entropy/test/test.js     | 24 +++----
 .../dists/gamma/entropy/test/test.native.js   | 24 +++----
 .../base/dists/gamma/kurtosis/test/test.js    | 24 +++----
 .../dists/gamma/kurtosis/test/test.native.js  | 24 +++----
 .../dists/gamma/logcdf/test/test.factory.js   | 44 ++++++------
 .../dists/gamma/logpdf/test/test.factory.js   | 52 +++++++-------
 .../dists/gamma/logpdf/test/test.logpdf.js    | 46 ++++++-------
 .../dists/gamma/logpdf/test/test.native.js    | 46 ++++++-------
 .../stats/base/dists/gamma/mean/test/test.js  | 24 +++----
 .../base/dists/gamma/mean/test/test.native.js | 24 +++----
 .../base/dists/gamma/mgf/test/test.factory.js | 34 +++++-----
 .../base/dists/gamma/mgf/test/test.mgf.js     | 30 ++++----
 .../base/dists/gamma/mgf/test/test.native.js  | 30 ++++----
 .../stats/base/dists/gamma/mode/test/test.js  | 24 +++----
 .../base/dists/gamma/mode/test/test.native.js | 24 +++----
 .../base/dists/gamma/pdf/test/test.factory.js | 52 +++++++-------
 .../base/dists/gamma/pdf/test/test.native.js  | 46 ++++++-------
 .../base/dists/gamma/pdf/test/test.pdf.js     | 46 ++++++-------
 .../dists/gamma/quantile/test/test.factory.js | 42 ++++++------
 .../base/dists/gamma/skewness/test/test.js    | 24 +++----
 .../dists/gamma/skewness/test/test.native.js  | 24 +++----
 .../stats/base/dists/gamma/stdev/test/test.js | 24 +++----
 .../dists/gamma/stdev/test/test.native.js     | 24 +++----
 .../base/dists/gamma/variance/test/test.js    | 24 +++----
 .../dists/gamma/variance/test/test.native.js  | 24 +++----
 .../base/dists/geometric/cdf/test/test.cdf.js | 20 +++---
 .../dists/geometric/cdf/test/test.factory.js  | 26 +++----
 .../dists/geometric/cdf/test/test.native.js   | 20 +++---
 .../base/dists/geometric/entropy/test/test.js | 10 +--
 .../geometric/entropy/test/test.native.js     | 10 +--
 .../dists/geometric/kurtosis/test/test.js     | 10 +--
 .../geometric/kurtosis/test/test.native.js    | 10 +--
 .../geometric/logcdf/test/test.factory.js     | 26 +++----
 .../geometric/logcdf/test/test.logcdf.js      | 20 +++---
 .../geometric/logcdf/test/test.native.js      | 20 +++---
 .../geometric/logpmf/test/test.factory.js     | 28 ++++----
 .../geometric/logpmf/test/test.logpmf.js      | 22 +++---
 .../geometric/logpmf/test/test.native.js      | 22 +++---
 .../base/dists/geometric/mean/test/test.js    | 10 +--
 .../dists/geometric/mean/test/test.native.js  | 10 +--
 .../base/dists/geometric/median/test/test.js  | 10 +--
 .../geometric/median/test/test.native.js      | 10 +--
 .../dists/geometric/mgf/test/test.factory.js  | 20 +++---
 .../base/dists/geometric/mgf/test/test.mgf.js | 12 ++--
 .../dists/geometric/mgf/test/test.native.js   | 12 ++--
 .../base/dists/geometric/mode/test/test.js    | 10 +--
 .../dists/geometric/mode/test/test.native.js  | 10 +--
 .../dists/geometric/pmf/test/test.factory.js  | 28 ++++----
 .../dists/geometric/pmf/test/test.native.js   | 22 +++---
 .../base/dists/geometric/pmf/test/test.pmf.js | 22 +++---
 .../geometric/quantile/test/test.factory.js   | 18 ++---
 .../dists/geometric/skewness/test/test.js     | 10 +--
 .../geometric/skewness/test/test.native.js    | 10 +--
 .../base/dists/geometric/stdev/test/test.js   | 10 +--
 .../dists/geometric/stdev/test/test.native.js | 10 +--
 .../dists/geometric/variance/test/test.js     | 10 +--
 .../geometric/variance/test/test.native.js    | 10 +--
 .../base/dists/gumbel/cdf/test/test.cdf.js    | 26 +++----
 .../dists/gumbel/cdf/test/test.factory.js     | 30 ++++----
 .../base/dists/gumbel/cdf/test/test.native.js | 26 +++----
 .../base/dists/gumbel/entropy/test/test.js    | 18 ++---
 .../dists/gumbel/entropy/test/test.native.js  | 18 ++---
 .../base/dists/gumbel/kurtosis/test/test.js   | 18 ++---
 .../dists/gumbel/kurtosis/test/test.native.js | 18 ++---
 .../dists/gumbel/logcdf/test/test.factory.js  | 30 ++++----
 .../dists/gumbel/logcdf/test/test.logcdf.js   | 26 +++----
 .../dists/gumbel/logcdf/test/test.native.js   | 26 +++----
 .../dists/gumbel/logpdf/test/test.factory.js  | 30 ++++----
 .../dists/gumbel/logpdf/test/test.logpdf.js   | 26 +++----
 .../dists/gumbel/logpdf/test/test.native.js   | 26 +++----
 .../stats/base/dists/gumbel/mean/test/test.js | 18 ++---
 .../dists/gumbel/mean/test/test.native.js     | 18 ++---
 .../base/dists/gumbel/median/test/test.js     | 18 ++---
 .../dists/gumbel/median/test/test.native.js   | 16 ++---
 .../dists/gumbel/mgf/test/test.factory.js     | 28 ++++----
 .../stats/base/dists/gumbel/mode/test/test.js | 18 ++---
 .../dists/gumbel/mode/test/test.native.js     | 18 ++---
 .../dists/gumbel/pdf/test/test.factory.js     | 30 ++++----
 .../base/dists/gumbel/pdf/test/test.native.js | 26 +++----
 .../base/dists/gumbel/pdf/test/test.pdf.js    | 26 +++----
 .../gumbel/quantile/test/test.factory.js      | 30 ++++----
 .../base/dists/gumbel/skewness/test/test.js   | 18 ++---
 .../dists/gumbel/skewness/test/test.native.js | 18 ++---
 .../base/dists/gumbel/stdev/test/test.js      | 18 ++---
 .../dists/gumbel/stdev/test/test.native.js    | 18 ++---
 .../base/dists/gumbel/variance/test/test.js   | 18 ++---
 .../dists/gumbel/variance/test/test.native.js | 18 ++---
 .../dists/hypergeometric/cdf/test/test.cdf.js | 52 +++++++-------
 .../hypergeometric/cdf/test/test.factory.js   | 68 +++++++++----------
 .../hypergeometric/kurtosis/test/test.js      | 36 +++++-----
 .../dists/hypergeometric/mean/test/test.js    | 36 +++++-----
 .../hypergeometric/mean/test/test.native.js   | 12 ++--
 .../dists/hypergeometric/mode/test/test.js    | 36 +++++-----
 .../hypergeometric/mode/test/test.native.js   | 12 ++--
 .../quantile/test/test.factory.js             | 54 +++++++--------
 .../hypergeometric/skewness/test/test.js      | 36 +++++-----
 .../skewness/test/test.native.js              | 12 ++--
 .../dists/hypergeometric/stdev/test/test.js   | 36 +++++-----
 .../hypergeometric/stdev/test/test.native.js  | 12 ++--
 .../hypergeometric/variance/test/test.js      | 36 +++++-----
 .../variance/test/test.native.js              | 12 ++--
 .../base/dists/invgamma/cdf/test/test.cdf.js  | 26 +++----
 .../dists/invgamma/cdf/test/test.factory.js   | 38 +++++------
 .../dists/invgamma/cdf/test/test.native.js    | 26 +++----
 .../base/dists/invgamma/entropy/test/test.js  | 24 +++----
 .../invgamma/entropy/test/test.native.js      | 24 +++----
 .../base/dists/invgamma/kurtosis/test/test.js | 30 ++++----
 .../invgamma/kurtosis/test/test.native.js     | 30 ++++----
 .../invgamma/logpdf/test/test.factory.js      | 38 +++++------
 .../dists/invgamma/logpdf/test/test.logpdf.js | 34 +++++-----
 .../dists/invgamma/logpdf/test/test.nativs.js | 34 +++++-----
 .../base/dists/invgamma/mean/test/test.js     | 24 +++----
 .../dists/invgamma/mean/test/test.native.js   | 24 +++----
 .../base/dists/invgamma/mode/test/test.js     | 24 +++----
 .../dists/invgamma/mode/test/test.native.js   | 24 +++----
 .../dists/invgamma/pdf/test/test.factory.js   | 38 +++++------
 .../dists/invgamma/pdf/test/test.native.js    | 34 +++++-----
 .../base/dists/invgamma/pdf/test/test.pdf.js  | 34 +++++-----
 .../invgamma/quantile/test/test.factory.js    | 38 +++++------
 .../base/dists/invgamma/skewness/test/test.js | 24 +++----
 .../invgamma/skewness/test/test.native.js     | 24 +++----
 .../base/dists/invgamma/stdev/test/test.js    | 28 ++++----
 .../dists/invgamma/stdev/test/test.native.js  | 28 ++++----
 .../base/dists/invgamma/variance/test/test.js | 28 ++++----
 .../invgamma/variance/test/test.native.js     | 28 ++++----
 .../kumaraswamy/cdf/test/test.factory.js      | 56 +++++++--------
 .../kumaraswamy/logcdf/test/test.factory.js   | 56 +++++++--------
 .../kumaraswamy/logpdf/test/test.factory.js   | 56 +++++++--------
 .../kumaraswamy/logpdf/test/test.logpdf.js    | 50 +++++++-------
 .../kumaraswamy/logpdf/test/test.native.js    | 50 +++++++-------
 .../base/dists/kumaraswamy/mean/test/test.js  | 32 ++++-----
 .../kumaraswamy/mean/test/test.native.js      | 32 ++++-----
 .../base/dists/kumaraswamy/mode/test/test.js  | 38 +++++------
 .../kumaraswamy/mode/test/test.native.js      | 38 +++++------
 .../kumaraswamy/pdf/test/test.factory.js      | 56 +++++++--------
 .../kumaraswamy/quantile/test/test.factory.js | 38 +++++------
 .../base/dists/kumaraswamy/stdev/test/test.js | 32 ++++-----
 .../kumaraswamy/stdev/test/test.native.js     | 32 ++++-----
 .../dists/kumaraswamy/variance/test/test.js   | 32 ++++-----
 .../kumaraswamy/variance/test/test.native.js  | 32 ++++-----
 .../base/dists/laplace/cdf/test/test.cdf.js   | 22 +++---
 .../dists/laplace/cdf/test/test.factory.js    | 30 ++++----
 .../dists/laplace/cdf/test/test.native.js     | 22 +++---
 .../base/dists/laplace/entropy/test/test.js   | 18 ++---
 .../dists/laplace/entropy/test/test.native.js | 18 ++---
 .../base/dists/laplace/kurtosis/test/test.js  | 18 ++---
 .../laplace/kurtosis/test/test.native.js      | 18 ++---
 .../dists/laplace/logcdf/test/test.factory.js | 30 ++++----
 .../dists/laplace/logcdf/test/test.logcdf.js  | 22 +++---
 .../dists/laplace/logcdf/test/test.native.js  | 22 +++---
 .../dists/laplace/logpdf/test/test.factory.js | 30 ++++----
 .../dists/laplace/logpdf/test/test.logpdf.js  | 26 +++----
 .../dists/laplace/logpdf/test/test.native.js  | 26 +++----
 .../base/dists/laplace/mean/test/test.js      | 18 ++---
 .../dists/laplace/mean/test/test.native.js    | 18 ++---
 .../base/dists/laplace/median/test/test.js    | 18 ++---
 .../dists/laplace/median/test/test.native.js  | 18 ++---
 .../dists/laplace/mgf/test/test.factory.js    | 42 ++++++------
 .../base/dists/laplace/mgf/test/test.mgf.js   | 38 +++++------
 .../dists/laplace/mgf/test/test.native.js     | 38 +++++------
 .../base/dists/laplace/mode/test/test.js      | 18 ++---
 .../dists/laplace/mode/test/test.native.js    | 18 ++---
 .../dists/laplace/pdf/test/test.factory.js    | 30 ++++----
 .../dists/laplace/pdf/test/test.native.js     | 26 +++----
 .../base/dists/laplace/pdf/test/test.pdf.js   | 26 +++----
 .../laplace/quantile/test/test.factory.js     | 30 ++++----
 .../base/dists/laplace/skewness/test/test.js  | 18 ++---
 .../laplace/skewness/test/test.native.js      | 18 ++---
 .../base/dists/laplace/stdev/test/test.js     | 18 ++---
 .../dists/laplace/stdev/test/test.native.js   | 18 ++---
 .../base/dists/laplace/variance/test/test.js  | 18 ++---
 .../laplace/variance/test/test.native.js      | 18 ++---
 .../base/dists/levy/cdf/test/test.cdf.js      | 28 ++++----
 .../base/dists/levy/cdf/test/test.factory.js  | 34 +++++-----
 .../base/dists/levy/cdf/test/test.native.js   | 28 ++++----
 .../base/dists/levy/entropy/test/test.js      | 18 ++---
 .../dists/levy/entropy/test/test.native.js    | 18 ++---
 .../dists/levy/logcdf/test/test.factory.js    | 34 +++++-----
 .../dists/levy/logcdf/test/test.logcdf.js     | 28 ++++----
 .../dists/levy/logcdf/test/test.native.js     | 28 ++++----
 .../dists/levy/logpdf/test/test.factory.js    | 32 ++++-----
 .../dists/levy/logpdf/test/test.logpdf.js     | 28 ++++----
 .../dists/levy/logpdf/test/test.native.js     | 24 +++----
 .../stats/base/dists/levy/mean/test/test.js   | 20 +++---
 .../base/dists/levy/mean/test/test.native.js  | 20 +++---
 .../stats/base/dists/levy/mode/test/test.js   | 18 ++---
 .../base/dists/levy/mode/test/test.native.js  | 18 ++---
 .../base/dists/levy/pdf/test/test.factory.js  | 28 ++++----
 .../base/dists/levy/pdf/test/test.native.js   | 24 +++----
 .../base/dists/levy/pdf/test/test.pdf.js      | 24 +++----
 .../dists/levy/quantile/test/test.factory.js  | 26 +++----
 .../stats/base/dists/levy/stdev/test/test.js  | 20 +++---
 .../base/dists/levy/stdev/test/test.native.js | 20 +++---
 .../base/dists/levy/variance/test/test.js     | 20 +++---
 .../dists/levy/variance/test/test.native.js   | 20 +++---
 .../base/dists/logistic/cdf/test/test.cdf.js  | 22 +++---
 .../dists/logistic/cdf/test/test.factory.js   | 26 +++----
 .../dists/logistic/cdf/test/test.native.js    | 22 +++---
 .../base/dists/logistic/entropy/test/test.js  | 18 ++---
 .../logistic/entropy/test/test.native.js      | 18 ++---
 .../base/dists/logistic/kurtosis/test/test.js | 18 ++---
 .../logistic/kurtosis/test/test.native.js     | 16 ++---
 .../logistic/logcdf/test/test.factory.js      | 26 +++----
 .../dists/logistic/logcdf/test/test.logcdf.js | 22 +++---
 .../dists/logistic/logcdf/test/test.native.js | 22 +++---
 .../logistic/logpdf/test/test.factory.js      | 34 +++++-----
 .../dists/logistic/logpdf/test/test.logpdf.js | 24 +++----
 .../dists/logistic/logpdf/test/test.native.js | 24 +++----
 .../base/dists/logistic/mean/test/test.js     | 18 ++---
 .../dists/logistic/mean/test/test.native.js   | 16 ++---
 .../base/dists/logistic/median/test/test.js   | 18 ++---
 .../dists/logistic/median/test/test.native.js | 16 ++---
 .../dists/logistic/mgf/test/test.factory.js   | 22 +++---
 .../base/dists/logistic/mgf/test/test.mgf.js  | 18 ++---
 .../dists/logistic/mgf/test/test.native.js    | 18 ++---
 .../base/dists/logistic/mode/test/test.js     | 18 ++---
 .../dists/logistic/mode/test/test.native.js   | 16 ++---
 .../dists/logistic/pdf/test/test.factory.js   | 34 +++++-----
 .../dists/logistic/pdf/test/test.native.js    | 30 ++++----
 .../base/dists/logistic/pdf/test/test.pdf.js  | 30 ++++----
 .../logistic/quantile/test/test.factory.js    | 26 +++----
 .../base/dists/logistic/skewness/test/test.js | 18 ++---
 .../logistic/skewness/test/test.native.js     | 16 ++---
 .../base/dists/logistic/stdev/test/test.js    | 18 ++---
 .../dists/logistic/stdev/test/test.native.js  | 18 ++---
 .../base/dists/logistic/variance/test/test.js | 18 ++---
 .../logistic/variance/test/test.native.js     | 18 ++---
 .../base/dists/lognormal/cdf/test/test.cdf.js | 24 +++----
 .../dists/lognormal/cdf/test/test.factory.js  | 26 +++----
 .../base/dists/lognormal/entropy/test/test.js | 18 ++---
 .../lognormal/entropy/test/test.native.js     | 18 ++---
 .../dists/lognormal/kurtosis/test/test.js     | 18 ++---
 .../lognormal/kurtosis/test/test.native.js    | 18 ++---
 .../lognormal/logcdf/test/test.factory.js     | 34 +++++-----
 .../lognormal/logcdf/test/test.logcdf.js      | 38 +++++------
 .../lognormal/logpdf/test/test.factory.js     | 28 ++++----
 .../lognormal/logpdf/test/test.logpdf.js      | 24 +++----
 .../base/dists/lognormal/mean/test/test.js    | 18 ++---
 .../dists/lognormal/mean/test/test.native.js  | 18 ++---
 .../base/dists/lognormal/median/test/test.js  | 18 ++---
 .../lognormal/median/test/test.native.js      | 18 ++---
 .../base/dists/lognormal/mode/test/test.js    | 18 ++---
 .../dists/lognormal/mode/test/test.native.js  | 18 ++---
 .../dists/lognormal/pdf/test/test.factory.js  | 28 ++++----
 .../dists/lognormal/pdf/test/test.native.js   | 24 +++----
 .../base/dists/lognormal/pdf/test/test.pdf.js | 24 +++----
 .../lognormal/quantile/test/test.factory.js   | 28 ++++----
 .../dists/lognormal/skewness/test/test.js     | 18 ++---
 .../lognormal/skewness/test/test.native.js    | 18 ++---
 .../base/dists/lognormal/stdev/test/test.js   | 18 ++---
 .../dists/lognormal/stdev/test/test.native.js | 18 ++---
 .../dists/lognormal/variance/test/test.js     | 18 ++---
 .../lognormal/variance/test/test.native.js    | 18 ++---
 .../negative-binomial/cdf/test/test.cdf.js    | 30 ++++----
 .../cdf/test/test.factory.js                  | 38 +++++------
 .../negative-binomial/kurtosis/test/test.js   | 18 ++---
 .../kurtosis/test/test.native.js              | 18 ++---
 .../logpmf/test/test.factory.js               | 46 ++++++-------
 .../logpmf/test/test.logpmf.js                | 36 +++++-----
 .../dists/negative-binomial/mean/test/test.js | 18 ++---
 .../mean/test/test.native.js                  | 18 ++---
 .../mgf/test/test.factory.js                  | 32 ++++-----
 .../dists/negative-binomial/mode/test/test.js | 18 ++---
 .../mode/test/test.native.js                  | 18 ++---
 .../pmf/test/test.factory.js                  | 46 ++++++-------
 .../negative-binomial/pmf/test/test.pmf.js    | 36 +++++-----
 .../quantile/test/test.factory.js             | 36 +++++-----
 .../negative-binomial/skewness/test/test.js   | 18 ++---
 .../skewness/test/test.native.js              | 18 ++---
 .../negative-binomial/stdev/test/test.js      | 18 ++---
 .../stdev/test/test.native.js                 | 18 ++---
 .../negative-binomial/variance/test/test.js   | 18 ++---
 .../variance/test/test.native.js              | 12 ++--
 .../base/dists/normal/cdf/test/test.cdf.js    | 22 +++---
 .../dists/normal/cdf/test/test.factory.js     | 26 +++----
 .../base/dists/normal/cdf/test/test.native.js | 22 +++---
 .../base/dists/normal/entropy/test/test.js    | 18 ++---
 .../dists/normal/entropy/test/test.native.js  | 18 ++---
 .../base/dists/normal/kurtosis/test/test.js   | 18 ++---
 .../dists/normal/kurtosis/test/test.native.js | 18 ++---
 .../dists/normal/logcdf/test/test.factory.js  | 34 +++++-----
 .../dists/normal/logcdf/test/test.logcdf.js   | 38 +++++------
 .../dists/normal/logcdf/test/test.native.js   | 38 +++++------
 .../dists/normal/logpdf/test/test.factory.js  | 34 +++++-----
 .../dists/normal/logpdf/test/test.logpdf.js   | 38 +++++------
 .../dists/normal/logpdf/test/test.native.js   | 38 +++++------
 .../stats/base/dists/normal/mean/test/test.js | 18 ++---
 .../dists/normal/mean/test/test.native.js     | 18 ++---
 .../base/dists/normal/median/test/test.js     | 18 ++---
 .../dists/normal/median/test/test.native.js   | 18 ++---
 .../dists/normal/mgf/test/test.factory.js     | 24 +++----
 .../base/dists/normal/mgf/test/test.mgf.js    | 20 +++---
 .../base/dists/normal/mgf/test/test.native.js | 20 +++---
 .../stats/base/dists/normal/mode/test/test.js | 18 ++---
 .../dists/normal/mode/test/test.native.js     | 18 ++---
 .../dists/normal/pdf/test/test.factory.js     | 34 +++++-----
 .../base/dists/normal/pdf/test/test.native.js | 38 +++++------
 .../base/dists/normal/pdf/test/test.pdf.js    | 38 +++++------
 .../normal/quantile/test/test.factory.js      | 26 +++----
 .../base/dists/normal/skewness/test/test.js   | 18 ++---
 .../dists/normal/skewness/test/test.native.js | 18 ++---
 .../base/dists/normal/stdev/test/test.js      | 16 ++---
 .../dists/normal/stdev/test/test.native.js    | 18 ++---
 .../base/dists/normal/variance/test/test.js   | 18 ++---
 .../dists/normal/variance/test/test.native.js | 18 ++---
 .../dists/pareto-type1/cdf/test/test.cdf.js   | 42 ++++++------
 .../pareto-type1/cdf/test/test.factory.js     | 52 +++++++-------
 .../pareto-type1/cdf/test/test.native.js      | 42 ++++++------
 .../dists/pareto-type1/entropy/test/test.js   | 24 +++----
 .../pareto-type1/entropy/test/test.native.js  | 24 +++----
 .../dists/pareto-type1/kurtosis/test/test.js  | 30 ++++----
 .../pareto-type1/kurtosis/test/test.native.js | 30 ++++----
 .../pareto-type1/logcdf/test/test.factory.js  | 52 +++++++-------
 .../pareto-type1/logcdf/test/test.logcdf.js   | 42 ++++++------
 .../pareto-type1/logcdf/test/test.native.js   | 42 ++++++------
 .../pareto-type1/logpdf/test/test.factory.js  | 44 ++++++------
 .../pareto-type1/logpdf/test/test.logpdf.js   | 40 +++++------
 .../pareto-type1/logpdf/test/test.native.js   | 40 +++++------
 .../dists/pareto-type1/median/test/test.js    | 24 +++----
 .../base/dists/pareto-type1/mode/test/test.js | 24 +++----
 .../pareto-type1/mode/test/test.native.js     | 24 +++----
 .../pareto-type1/pdf/test/test.factory.js     | 44 ++++++------
 .../pareto-type1/pdf/test/test.native.js      | 40 +++++------
 .../dists/pareto-type1/pdf/test/test.pdf.js   | 40 +++++------
 .../quantile/test/test.factory.js             | 40 +++++------
 .../dists/pareto-type1/skewness/test/test.js  | 30 ++++----
 .../pareto-type1/skewness/test/test.native.js | 30 ++++----
 .../dists/pareto-type1/stdev/test/test.js     | 30 ++++----
 .../pareto-type1/stdev/test/test.native.js    | 30 ++++----
 .../dists/pareto-type1/variance/test/test.js  | 30 ++++----
 .../pareto-type1/variance/test/test.native.js | 30 ++++----
 .../dists/planck/cdf/test/test.factory.js     | 12 ++--
 .../base/dists/planck/kurtosis/test/test.js   |  6 +-
 .../dists/planck/kurtosis/test/test.native.js |  6 +-
 .../base/dists/poisson/cdf/test/test.cdf.js   | 20 +++---
 .../dists/poisson/cdf/test/test.factory.js    | 18 ++---
 .../dists/poisson/cdf/test/test.native.js     | 20 +++---
 .../base/dists/poisson/entropy/test/test.js   |  8 +--
 .../base/dists/poisson/kurtosis/test/test.js  |  8 +--
 .../poisson/kurtosis/test/test.native.js      |  8 +--
 .../dists/poisson/logpmf/test/test.factory.js | 24 +++----
 .../dists/poisson/logpmf/test/test.logpmf.js  | 24 +++----
 .../dists/poisson/logpmf/test/test.native.js  | 24 +++----
 .../base/dists/poisson/mean/test/test.js      |  6 +-
 .../dists/poisson/mean/test/test.native.js    |  6 +-
 .../base/dists/poisson/median/test/test.js    |  8 +--
 .../dists/poisson/median/test/test.native.js  |  8 +--
 .../dists/poisson/mgf/test/test.factory.js    | 12 ++--
 .../base/dists/poisson/mgf/test/test.mgf.js   | 10 +--
 .../dists/poisson/mgf/test/test.native.js     | 10 +--
 .../base/dists/poisson/mode/test/test.js      |  6 +-
 .../dists/poisson/mode/test/test.native.js    |  6 +-
 .../dists/poisson/pmf/test/test.factory.js    | 24 +++----
 .../base/dists/poisson/pmf/test/test.pmf.js   | 24 +++----
 .../poisson/quantile/test/test.factory.js     | 20 +++---
 .../base/dists/poisson/skewness/test/test.js  |  8 +--
 .../poisson/skewness/test/test.native.js      |  8 +--
 .../base/dists/poisson/stdev/test/test.js     |  6 +-
 .../dists/poisson/stdev/test/test.native.js   |  6 +-
 .../base/dists/poisson/variance/test/test.js  |  6 +-
 .../poisson/variance/test/test.native.js      |  6 +-
 .../base/dists/rayleigh/cdf/test/test.cdf.js  | 12 ++--
 .../dists/rayleigh/cdf/test/test.factory.js   | 14 ++--
 .../dists/rayleigh/cdf/test/test.native.js    | 12 ++--
 .../base/dists/rayleigh/entropy/test/test.js  |  8 +--
 .../rayleigh/entropy/test/test.native.js      |  8 +--
 .../base/dists/rayleigh/kurtosis/test/test.js |  6 +-
 .../rayleigh/kurtosis/test/test.native.js     |  6 +-
 .../rayleigh/logcdf/test/test.factory.js      | 14 ++--
 .../dists/rayleigh/logcdf/test/test.logcdf.js | 12 ++--
 .../dists/rayleigh/logcdf/test/test.native.js | 12 ++--
 .../rayleigh/logpdf/test/test.factory.js      | 20 +++---
 .../dists/rayleigh/logpdf/test/test.logpdf.js | 16 ++---
 .../dists/rayleigh/logpdf/test/test.native.js | 16 ++---
 .../base/dists/rayleigh/mean/test/test.js     |  6 +-
 .../dists/rayleigh/mean/test/test.native.js   |  6 +-
 .../base/dists/rayleigh/median/test/test.js   |  6 +-
 .../dists/rayleigh/median/test/test.native.js |  6 +-
 .../dists/rayleigh/mgf/test/test.factory.js   | 10 +--
 .../base/dists/rayleigh/mode/test/test.js     |  6 +-
 .../dists/rayleigh/mode/test/test.native.js   |  6 +-
 .../dists/rayleigh/pdf/test/test.factory.js   | 20 +++---
 .../dists/rayleigh/pdf/test/test.native.js    | 22 +++---
 .../base/dists/rayleigh/pdf/test/test.pdf.js  | 22 +++---
 .../rayleigh/quantile/test/test.factory.js    | 14 ++--
 .../base/dists/rayleigh/skewness/test/test.js |  6 +-
 .../rayleigh/skewness/test/test.native.js     |  6 +-
 .../base/dists/rayleigh/stdev/test/test.js    |  6 +-
 .../dists/rayleigh/stdev/test/test.native.js  |  6 +-
 .../base/dists/rayleigh/variance/test/test.js |  6 +-
 .../rayleigh/variance/test/test.native.js     |  6 +-
 .../base/dists/signrank/cdf/test/test.cdf.js  | 16 ++---
 .../dists/signrank/cdf/test/test.factory.js   | 16 ++---
 .../dists/signrank/pdf/test/test.factory.js   | 16 ++---
 .../dists/signrank/pdf/test/test.native.js    | 14 ++--
 .../base/dists/signrank/pdf/test/test.pdf.js  | 16 ++---
 .../signrank/quantile/test/test.factory.js    | 18 ++---
 .../studentized-range/cdf/test/test.cdf.js    | 10 +--
 .../cdf/test/test.factory.js                  | 26 +++----
 .../quantile/test/test.factory.js             | 22 +++---
 .../quantile/test/test.quantile.js            |  6 +-
 .../stats/base/dists/t/cdf/test/test.cdf.js   | 16 ++---
 .../base/dists/t/cdf/test/test.factory.js     | 14 ++--
 .../stats/base/dists/t/entropy/test/test.js   |  8 +--
 .../base/dists/t/entropy/test/test.native.js  |  8 +--
 .../stats/base/dists/t/kurtosis/test/test.js  | 18 ++---
 .../base/dists/t/kurtosis/test/test.native.js | 18 ++---
 .../base/dists/t/logcdf/test/test.factory.js  | 14 ++--
 .../base/dists/t/logcdf/test/test.logcdf.js   | 16 ++---
 .../base/dists/t/logpdf/test/test.factory.js  | 22 +++---
 .../base/dists/t/logpdf/test/test.logpdf.js   | 24 +++----
 .../base/dists/t/logpdf/test/test.native.js   | 24 +++----
 .../stats/base/dists/t/mean/test/test.js      |  6 +-
 .../base/dists/t/mean/test/test.native.js     | 10 +--
 .../stats/base/dists/t/median/test/test.js    |  6 +-
 .../base/dists/t/median/test/test.native.js   |  6 +-
 .../stats/base/dists/t/mode/test/test.js      |  6 +-
 .../base/dists/t/mode/test/test.native.js     |  6 +-
 .../base/dists/t/pdf/test/test.factory.js     | 22 +++---
 .../base/dists/t/pdf/test/test.native.js      | 24 +++----
 .../stats/base/dists/t/pdf/test/test.pdf.js   | 24 +++----
 .../dists/t/quantile/test/test.factory.js     | 14 ++--
 .../stats/base/dists/t/skewness/test/test.js  | 14 ++--
 .../base/dists/t/skewness/test/test.native.js | 14 ++--
 .../stats/base/dists/t/stdev/test/test.js     | 12 ++--
 .../base/dists/t/stdev/test/test.native.js    | 12 ++--
 .../stats/base/dists/t/variance/test/test.js  | 12 ++--
 .../base/dists/t/variance/test/test.native.js | 14 ++--
 .../dists/triangular/cdf/test/test.cdf.js     | 20 +++---
 .../dists/triangular/cdf/test/test.factory.js | 38 +++++------
 .../dists/triangular/cdf/test/test.native.js  | 20 +++---
 .../dists/triangular/entropy/test/test.js     | 14 ++--
 .../triangular/entropy/test/test.native.js    | 14 ++--
 .../dists/triangular/kurtosis/test/test.js    | 14 ++--
 .../triangular/kurtosis/test/test.native.js   | 14 ++--
 .../triangular/logcdf/test/test.factory.js    | 38 +++++------
 .../triangular/logcdf/test/test.logcdf.js     | 20 +++---
 .../triangular/logcdf/test/test.native.js     | 20 +++---
 .../triangular/logpdf/test/test.factory.js    | 46 ++++++-------
 .../triangular/logpdf/test/test.logpdf.js     | 30 ++++----
 .../triangular/logpdf/test/test.native.js     | 32 ++++-----
 .../base/dists/triangular/mean/test/test.js   | 14 ++--
 .../dists/triangular/mean/test/test.native.js | 14 ++--
 .../dists/triangular/mgf/test/test.native.js  | 16 ++---
 .../base/dists/triangular/mode/test/test.js   | 14 ++--
 .../dists/triangular/mode/test/test.native.js | 14 ++--
 .../dists/triangular/pdf/test/test.factory.js | 46 ++++++-------
 .../dists/triangular/pdf/test/test.native.js  | 32 ++++-----
 .../dists/triangular/pdf/test/test.pdf.js     | 32 ++++-----
 .../triangular/quantile/test/test.factory.js  | 26 +++----
 .../dists/triangular/skewness/test/test.js    | 14 ++--
 .../triangular/skewness/test/test.native.js   | 14 ++--
 .../base/dists/triangular/stdev/test/test.js  | 14 ++--
 .../triangular/stdev/test/test.native.js      | 14 ++--
 .../dists/triangular/variance/test/test.js    | 14 ++--
 .../triangular/variance/test/test.native.js   | 14 ++--
 .../base/dists/uniform/cdf/test/test.cdf.js   | 18 ++---
 .../dists/uniform/cdf/test/test.factory.js    | 26 +++----
 .../dists/uniform/cdf/test/test.native.js     | 18 ++---
 .../base/dists/uniform/entropy/test/test.js   | 12 ++--
 .../dists/uniform/entropy/test/test.native.js | 12 ++--
 .../base/dists/uniform/kurtosis/test/test.js  | 12 ++--
 .../uniform/kurtosis/test/test.native.js      | 12 ++--
 .../dists/uniform/logcdf/test/test.factory.js | 26 +++----
 .../dists/uniform/logcdf/test/test.logcdf.js  | 18 ++---
 .../dists/uniform/logcdf/test/test.native.js  | 18 ++---
 .../dists/uniform/logpdf/test/test.factory.js | 26 +++----
 .../dists/uniform/logpdf/test/test.logpdf.js  | 18 ++---
 .../dists/uniform/logpdf/test/test.native.js  | 18 ++---
 .../base/dists/uniform/mean/test/test.js      | 12 ++--
 .../dists/uniform/mean/test/test.native.js    | 12 ++--
 .../base/dists/uniform/median/test/test.js    | 12 ++--
 .../dists/uniform/median/test/test.native.js  | 12 ++--
 .../dists/uniform/mgf/test/test.factory.js    | 26 +++----
 .../base/dists/uniform/mgf/test/test.mgf.js   | 20 +++---
 .../dists/uniform/mgf/test/test.native.js     | 20 +++---
 .../dists/uniform/pdf/test/test.factory.js    | 26 +++----
 .../dists/uniform/pdf/test/test.native.js     | 18 ++---
 .../base/dists/uniform/pdf/test/test.pdf.js   | 18 ++---
 .../uniform/quantile/test/test.factory.js     | 22 +++---
 .../base/dists/uniform/skewness/test/test.js  | 14 ++--
 .../uniform/skewness/test/test.native.js      | 12 ++--
 .../base/dists/uniform/stdev/test/test.js     | 12 ++--
 .../dists/uniform/stdev/test/test.native.js   | 12 ++--
 .../base/dists/uniform/variance/test/test.js  | 12 ++--
 .../uniform/variance/test/test.native.js      | 12 ++--
 .../base/dists/weibull/cdf/test/test.cdf.js   | 38 +++++------
 .../dists/weibull/cdf/test/test.factory.js    | 46 ++++++-------
 .../dists/weibull/cdf/test/test.native.js     | 38 +++++------
 .../base/dists/weibull/entropy/test/test.js   | 24 +++----
 .../dists/weibull/entropy/test/test.native.js | 24 +++----
 .../base/dists/weibull/kurtosis/test/test.js  | 24 +++----
 .../weibull/kurtosis/test/test.native.js      | 24 +++----
 .../dists/weibull/logcdf/test/test.factory.js | 46 ++++++-------
 .../dists/weibull/logcdf/test/test.logcdf.js  | 38 +++++------
 .../dists/weibull/logcdf/test/test.native.js  | 38 +++++------
 .../dists/weibull/logpdf/test/test.factory.js | 48 ++++++-------
 .../dists/weibull/logpdf/test/test.logpdf.js  | 40 +++++------
 .../dists/weibull/logpdf/test/test.native.js  | 40 +++++------
 .../base/dists/weibull/mean/test/test.js      | 24 +++----
 .../dists/weibull/mean/test/test.native.js    | 24 +++----
 .../base/dists/weibull/median/test/test.js    | 24 +++----
 .../dists/weibull/median/test/test.native.js  | 24 +++----
 .../dists/weibull/mgf/test/test.factory.js    | 38 +++++------
 .../base/dists/weibull/mode/test/test.js      | 28 ++++----
 .../dists/weibull/mode/test/test.native.js    | 28 ++++----
 .../dists/weibull/pdf/test/test.factory.js    | 48 ++++++-------
 .../dists/weibull/pdf/test/test.native.js     | 40 +++++------
 .../base/dists/weibull/pdf/test/test.pdf.js   | 40 +++++------
 .../weibull/quantile/test/test.factory.js     | 46 ++++++-------
 .../weibull/quantile/test/test.native.js      | 18 ++---
 .../base/dists/weibull/skewness/test/test.js  | 24 +++----
 .../weibull/skewness/test/test.native.js      | 24 +++----
 .../base/dists/weibull/stdev/test/test.js     | 24 +++----
 .../dists/weibull/stdev/test/test.native.js   | 24 +++----
 .../base/dists/weibull/variance/test/test.js  | 24 +++----
 .../weibull/variance/test/test.native.js      | 24 +++----
 .../@stdlib/stats/incr/gmean/test/test.js     |  8 +--
 .../@stdlib/stats/incr/grubbs/test/test.js    | 30 ++++----
 .../@stdlib/stats/incr/mgrubbs/test/test.js   | 40 +++++------
 .../@stdlib/stats/incr/mprod/test/test.js     | 48 ++++++-------
 .../@stdlib/stats/incr/prod/test/test.js      | 32 ++++-----
 .../@stdlib/stats/incr/wmean/test/test.js     | 16 ++---
 832 files changed, 8675 insertions(+), 8675 deletions(-)

diff --git a/lib/node_modules/@stdlib/complex/float64/base/div/test/test.main.js b/lib/node_modules/@stdlib/complex/float64/base/div/test/test.main.js
index 4b8c1091b434..2b2ce1e71237 100644
--- a/lib/node_modules/@stdlib/complex/float64/base/div/test/test.main.js
+++ b/lib/node_modules/@stdlib/complex/float64/base/div/test/test.main.js
@@ -1014,44 +1014,44 @@ tape( 'if a real or imaginary component is `NaN`, all components are `NaN`', fun
 	z1 = new Complex128( NaN, 3.0 );
 	z2 = new Complex128( -2.0, 1.0 );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	z1 = new Complex128( 5.0, NaN );
 	z2 = new Complex128( -2.0, 1.0 );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	z1 = new Complex128( 5.0, 3.0 );
 	z2 = new Complex128( NaN, 1.0 );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	z1 = new Complex128( 5.0, 3.0 );
 	z2 = new Complex128( -2.0, NaN );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	z1 = new Complex128( 5.0, 3.0 );
 	z2 = new Complex128( NaN, NaN );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	z1 = new Complex128( NaN, NaN );
 	z2 = new Complex128( -2.0, 1.0 );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	z1 = new Complex128( NaN, NaN );
 	z2 = new Complex128( NaN, NaN );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/float64/base/div/test/test.native.js b/lib/node_modules/@stdlib/complex/float64/base/div/test/test.native.js
index 74f1a15a7d84..9033da22333c 100644
--- a/lib/node_modules/@stdlib/complex/float64/base/div/test/test.native.js
+++ b/lib/node_modules/@stdlib/complex/float64/base/div/test/test.native.js
@@ -1031,44 +1031,44 @@ tape( 'if a real or imaginary component is `NaN`, all components are `NaN`', opt
 	z1 = new Complex128( NaN, 3.0 );
 	z2 = new Complex128( -2.0, 1.0 );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	z1 = new Complex128( 5.0, NaN );
 	z2 = new Complex128( -2.0, 1.0 );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	z1 = new Complex128( 5.0, 3.0 );
 	z2 = new Complex128( NaN, 1.0 );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	z1 = new Complex128( 5.0, 3.0 );
 	z2 = new Complex128( -2.0, NaN );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	z1 = new Complex128( 5.0, 3.0 );
 	z2 = new Complex128( NaN, NaN );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	z1 = new Complex128( NaN, NaN );
 	z2 = new Complex128( -2.0, 1.0 );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	z1 = new Complex128( NaN, NaN );
 	z2 = new Complex128( NaN, NaN );
 	v = cdiv( z1, z2 );
-	t.strictEqual( isnan( real( v ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( imag( v ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/float64/base/div/test/test.strided.js b/lib/node_modules/@stdlib/complex/float64/base/div/test/test.strided.js
index 26f3579434cb..d825ba684149 100644
--- a/lib/node_modules/@stdlib/complex/float64/base/div/test/test.strided.js
+++ b/lib/node_modules/@stdlib/complex/float64/base/div/test/test.strided.js
@@ -1011,44 +1011,44 @@ tape( 'if a real or imaginary component is `NaN`, all components are `NaN`', fun
 	z1 = new Float64Array( [ NaN, 3.0 ] );
 	z2 = new Float64Array( [ -2.0, 1.0 ] );
 	v = cdiv( z1, 1, 0, z2, 1, 0, new Float64Array( 2 ), 1, 0 );
-	t.strictEqual( isnan( v[ 0 ] ), true, 'returns NaN' );
-	t.strictEqual( isnan( v[ 1 ] ), true, 'returns NaN' );
+	t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value' );
 
 	z1 = new Float64Array( [ 5.0, NaN ] );
 	z2 = new Float64Array( [ -2.0, 1.0 ] );
 	v = cdiv( z1, 1, 0, z2, 1, 0, new Float64Array( 2 ), 1, 0 );
-	t.strictEqual( isnan( v[ 0 ] ), true, 'returns NaN' );
-	t.strictEqual( isnan( v[ 1 ] ), true, 'returns NaN' );
+	t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value' );
 
 	z1 = new Float64Array( [ 5.0, 3.0 ] );
 	z2 = new Float64Array( [ NaN, 1.0 ] );
 	v = cdiv( z1, 1, 0, z2, 1, 0, new Float64Array( 2 ), 1, 0 );
-	t.strictEqual( isnan( v[ 0 ] ), true, 'returns NaN' );
-	t.strictEqual( isnan( v[ 1 ] ), true, 'returns NaN' );
+	t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value' );
 
 	z1 = new Float64Array( [ 5.0, 3.0 ] );
 	z2 = new Float64Array( [ -2.0, NaN ] );
 	v = cdiv( z1, 1, 0, z2, 1, 0, new Float64Array( 2 ), 1, 0 );
-	t.strictEqual( isnan( v[ 0 ] ), true, 'returns NaN' );
-	t.strictEqual( isnan( v[ 1 ] ), true, 'returns NaN' );
+	t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value' );
 
 	z1 = new Float64Array( [ 5.0, 3.0 ] );
 	z2 = new Float64Array( [ NaN, NaN ] );
 	v = cdiv( z1, 1, 0, z2, 1, 0, new Float64Array( 2 ), 1, 0 );
-	t.strictEqual( isnan( v[ 0 ] ), true, 'returns NaN' );
-	t.strictEqual( isnan( v[ 1 ] ), true, 'returns NaN' );
+	t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value' );
 
 	z1 = new Float64Array( [ NaN, NaN ] );
 	z2 = new Float64Array( [ -2.0, 1.0 ] );
 	v = cdiv( z1, 1, 0, z2, 1, 0, new Float64Array( 2 ), 1, 0 );
-	t.strictEqual( isnan( v[ 0 ] ), true, 'returns NaN' );
-	t.strictEqual( isnan( v[ 1 ] ), true, 'returns NaN' );
+	t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value' );
 
 	z1 = new Float64Array( [ NaN, NaN ] );
 	z2 = new Float64Array( [ NaN, NaN ] );
 	v = cdiv( z1, 1, 0, z2, 1, 0, new Float64Array( 2 ), 1, 0 );
-	t.strictEqual( isnan( v[ 0 ] ), true, 'returns NaN' );
-	t.strictEqual( isnan( v[ 1 ] ), true, 'returns NaN' );
+	t.strictEqual( isnan( v[ 0 ] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[ 1 ] ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/abs/test/test.abs.js b/lib/node_modules/@stdlib/math/base/special/abs/test/test.abs.js
index 8824da9cf382..b846599be3eb 100644
--- a/lib/node_modules/@stdlib/math/base/special/abs/test/test.abs.js
+++ b/lib/node_modules/@stdlib/math/base/special/abs/test/test.abs.js
@@ -51,13 +51,13 @@ tape( 'the function computes the absolute value of negative zero', function test
 });
 
 tape( 'the function computes the absolute value of infinity', function test( t ) {
-	t.strictEqual( abs( PINF ), PINF, 'returns +infinity' );
-	t.strictEqual( abs( NINF ), PINF, 'returns +infinity' );
+	t.strictEqual( abs( PINF ), PINF, 'returns expected value' );
+	t.strictEqual( abs( NINF ), PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = abs( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/abs/test/test.js b/lib/node_modules/@stdlib/math/base/special/abs/test/test.js
index e91a982d1d42..77c5741dd597 100644
--- a/lib/node_modules/@stdlib/math/base/special/abs/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/abs/test/test.js
@@ -51,13 +51,13 @@ tape( 'the function computes the absolute value of negative zero', function test
 });
 
 tape( 'the function computes the absolute value of infinity', function test( t ) {
-	t.strictEqual( abs( PINF ), PINF, 'returns +infinity' );
-	t.strictEqual( abs( NINF ), PINF, 'returns +infinity' );
+	t.strictEqual( abs( PINF ), PINF, 'returns expected value' );
+	t.strictEqual( abs( NINF ), PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = abs( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/abs/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/abs/test/test.native.js
index b2f0140bea84..892e472a09d8 100644
--- a/lib/node_modules/@stdlib/math/base/special/abs/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/abs/test/test.native.js
@@ -60,13 +60,13 @@ tape( 'the function computes the absolute value of negative zero', opts, functio
 });
 
 tape( 'the function computes the absolute value of infinity', opts, function test( t ) {
-	t.strictEqual( abs( PINF ), PINF, 'returns +infinity' );
-	t.strictEqual( abs( NINF ), PINF, 'returns +infinity' );
+	t.strictEqual( abs( PINF ), PINF, 'returns expected value' );
+	t.strictEqual( abs( NINF ), PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var v = abs( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/asec/test/test.js b/lib/node_modules/@stdlib/math/base/special/asec/test/test.js
index f903610519d6..aec33b99921c 100644
--- a/lib/node_modules/@stdlib/math/base/special/asec/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/asec/test/test.js
@@ -241,19 +241,19 @@ tape( 'the function computes the inverse (arc) secant on the interval `[1e300,1e
 
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var v = asec( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `+0`', function test( t ) {
 	var v = asec( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `-0`', function test( t ) {
 	var v = asec( -0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -261,7 +261,7 @@ tape( 'the function returns `NaN` on the interval `(-1, 1)`', function test( t )
 	var v = asec( 0.5 );
 	var w = asec( -0.5 );
 
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
-	t.strictEqual( isnan( w ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( w ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/asec/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/asec/test/test.native.js
index 930ecbafb666..b9bbd4ed708a 100644
--- a/lib/node_modules/@stdlib/math/base/special/asec/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/asec/test/test.native.js
@@ -250,19 +250,19 @@ tape( 'the function computes the inverse (arc) secant on the interval `[1e300,1e
 
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var v = asec( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `+0`', opts, function test( t ) {
 	var v = asec( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `-0`', opts, function test( t ) {
 	var v = asec( -0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -270,7 +270,7 @@ tape( 'the function returns `NaN` on the interval `(-1, 1)`', opts, function tes
 	var v = asec( 0.5 );
 	var w = asec( -0.5 );
 
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
-	t.strictEqual( isnan( w ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+	t.strictEqual( isnan( w ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/asecd/test/test.js b/lib/node_modules/@stdlib/math/base/special/asecd/test/test.js
index b7e0c9fbb297..03bb2a6e284e 100644
--- a/lib/node_modules/@stdlib/math/base/special/asecd/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/asecd/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var v = asecd( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asecd/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/asecd/test/test.native.js
index 07aaef09c969..d30a934fc2b9 100644
--- a/lib/node_modules/@stdlib/math/base/special/asecd/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/asecd/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var v = asecd( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asech/test/test.js b/lib/node_modules/@stdlib/math/base/special/asech/test/test.js
index ca70195d3ff5..9cb0ba82b46e 100644
--- a/lib/node_modules/@stdlib/math/base/special/asech/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/asech/test/test.js
@@ -68,19 +68,19 @@ tape( 'the function computes the hyperbolic arcsecant on the interval (0, 1]', f
 
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var v = asech( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+infinity` if provided `+0`', function test( t ) {
 	var v = asech( 0.0 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `-0`', function test( t ) {
 	var v = asech( -0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asech/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/asech/test/test.native.js
index 3f09a6610d14..cfc9e9b4c1ec 100644
--- a/lib/node_modules/@stdlib/math/base/special/asech/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/asech/test/test.native.js
@@ -77,19 +77,19 @@ tape( 'the function computes the hyperbolic arcsecant on the interval (0, 1]', o
 
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var v = asech( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+infinity` if provided `+0`', opts, function test( t ) {
 	var v = asech( 0.0 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `-0`', opts, function test( t ) {
 	var v = asech( -0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asin/test/test.js b/lib/node_modules/@stdlib/math/base/special/asin/test/test.js
index ad029e22845d..a896e206c6bc 100644
--- a/lib/node_modules/@stdlib/math/base/special/asin/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/asin/test/test.js
@@ -119,7 +119,7 @@ tape( 'the function computes the arcsine (small positive values)', function test
 
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var v = asin( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asin/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/asin/test/test.native.js
index d88295cdb3e8..aa90cce3e475 100644
--- a/lib/node_modules/@stdlib/math/base/special/asin/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/asin/test/test.native.js
@@ -128,7 +128,7 @@ tape( 'the function computes the arcsine (small positive values)', opts, functio
 
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var v = asin( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asind/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/asind/test/test.native.js
index 243613ba27cb..13a83373c0bf 100644
--- a/lib/node_modules/@stdlib/math/base/special/asind/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/asind/test/test.native.js
@@ -103,7 +103,7 @@ tape( 'the function computes the arcsine in degrees (positive values)', opts, fu
 
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var v = asind( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asinf/test/test.js b/lib/node_modules/@stdlib/math/base/special/asinf/test/test.js
index ab81b4613c5c..298dbec7d1b7 100644
--- a/lib/node_modules/@stdlib/math/base/special/asinf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/asinf/test/test.js
@@ -126,7 +126,7 @@ tape( 'the function computes the arcsine (small positive values)', function test
 
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var v = asinf( NaN );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asinf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/asinf/test/test.native.js
index 03aa94bf5cc0..6804101160b8 100644
--- a/lib/node_modules/@stdlib/math/base/special/asinf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/asinf/test/test.native.js
@@ -135,7 +135,7 @@ tape( 'the function computes the arcsine (small positive values)', opts, functio
 
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var v = asinf( NaN );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asinh/test/test.js b/lib/node_modules/@stdlib/math/base/special/asinh/test/test.js
index 86defdc19d30..2dab4dcfa413 100644
--- a/lib/node_modules/@stdlib/math/base/special/asinh/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/asinh/test/test.js
@@ -370,30 +370,30 @@ tape( 'the function computes the hyperbolic arcsine on the interval `[1e300,1e30
 
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var v = asinh( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+infinity` if provided `+infinity`', function test( t ) {
 	var v = asinh( PINF );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', function test( t ) {
 	var v = asinh( NINF );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-0` if provided `-0`', function test( t ) {
 	var v = asinh( -0 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+0` if provided `+0`', function test( t ) {
 	var v = asinh( +0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/asinh/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/asinh/test/test.native.js
index 3cdd2eef60fb..9f9b5388aef4 100644
--- a/lib/node_modules/@stdlib/math/base/special/asinh/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/asinh/test/test.native.js
@@ -379,30 +379,30 @@ tape( 'the function computes the hyperbolic arcsine on the interval `[1e300,1e30
 
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var v = asinh( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+infinity` if provided `+infinity`', opts, function test( t ) {
 	var v = asinh( PINF );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', opts, function test( t ) {
 	var v = asinh( NINF );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-0` if provided `-0`', opts, function test( t ) {
 	var v = asinh( -0 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+0` if provided `+0`', opts, function test( t ) {
 	var v = asinh( +0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/atand/test/test.js b/lib/node_modules/@stdlib/math/base/special/atand/test/test.js
index f0af82cb0937..bf869ba2e7e9 100644
--- a/lib/node_modules/@stdlib/math/base/special/atand/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/atand/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var v = atand( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/atand/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/atand/test/test.native.js
index 4f49a6c12b7b..5b1df1b463ed 100644
--- a/lib/node_modules/@stdlib/math/base/special/atand/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/atand/test/test.native.js
@@ -100,6 +100,6 @@ tape( 'the function computes the arctangent in degrees (positive values)', opts,
 
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var v = atand( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/atanf/test/test.js b/lib/node_modules/@stdlib/math/base/special/atanf/test/test.js
index 0a5c15ccc8d4..088f4d722489 100644
--- a/lib/node_modules/@stdlib/math/base/special/atanf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/atanf/test/test.js
@@ -398,7 +398,7 @@ tape( 'the function computes the arctangent on the interval `[ 1e30, 1e38 ]`', f
 
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var v = atanf( NaN );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -416,7 +416,7 @@ tape( 'the function returns `-pi/2` if provided `-infinity`', function test( t )
 
 tape( 'the function returns `-0` if provided `-0`', function test( t ) {
 	var v = atanf( -0.0 );
-	t.strictEqual( isNegativeZerof( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZerof( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -424,10 +424,10 @@ tape( 'the function returns `0` if provided +0', function test( t ) {
 	var v;
 
 	v = atanf( 0.0 );
-	t.strictEqual( isPositiveZerof( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' );
 
 	v = atanf( +0.0 );
-	t.strictEqual( isPositiveZerof( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/atanf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/atanf/test/test.native.js
index 822ec9721077..f8dd05be3ecc 100644
--- a/lib/node_modules/@stdlib/math/base/special/atanf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/atanf/test/test.native.js
@@ -407,7 +407,7 @@ tape( 'the function computes the arctangent on the interval `[ 1e30, 1e38 ]`', o
 
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var v = atanf( NaN );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -425,7 +425,7 @@ tape( 'the function returns `-pi/2` if provided `-infinity`', opts, function tes
 
 tape( 'the function returns `-0` if provided `-0`', opts, function test( t ) {
 	var v = atanf( -0.0 );
-	t.strictEqual( isNegativeZerof( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZerof( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -433,10 +433,10 @@ tape( 'the function returns `0` if provided +0', opts, function test( t ) {
 	var v;
 
 	v = atanf( 0.0 );
-	t.strictEqual( isPositiveZerof( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' );
 
 	v = atanf( +0.0 );
-	t.strictEqual( isPositiveZerof( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/atanh/test/test.js b/lib/node_modules/@stdlib/math/base/special/atanh/test/test.js
index 43e407b7e0ce..c4ede67c26cf 100644
--- a/lib/node_modules/@stdlib/math/base/special/atanh/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/atanh/test/test.js
@@ -146,13 +146,13 @@ tape( 'the function computes the hyperbolic arctangent (small positive)', functi
 
 tape( 'the function returns `+Infinity` if provided `1.0`', function test( t ) {
 	var v = atanh( 1.0 );
-	t.strictEqual( v, PINF, 'returns +Infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-Infinity` if provided `-1.0`', function test( t ) {
 	var v = atanh( -1.0 );
-	t.strictEqual( v, NINF, 'returns -Infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -180,18 +180,18 @@ tape( 'the function returns `NaN` if provided a value greater than `1`', functio
 
 tape( 'the function returns `-0` if provided `-0`', function test( t ) {
 	var v = atanh( -0.0 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+0` if provided `+0`', function test( t ) {
 	var v = atanh( 0.0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns 0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var v = atanh( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/atanh/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/atanh/test/test.native.js
index 84ee90a41633..a217359051f9 100644
--- a/lib/node_modules/@stdlib/math/base/special/atanh/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/atanh/test/test.native.js
@@ -155,13 +155,13 @@ tape( 'the function computes the hyperbolic arctangent (small positive)', opts,
 
 tape( 'the function returns `+Infinity` if provided `1.0`', opts, function test( t ) {
 	var v = atanh( 1.0 );
-	t.strictEqual( v, PINF, 'returns +Infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-Infinity` if provided `-1.0`', opts, function test( t ) {
 	var v = atanh( -1.0 );
-	t.strictEqual( v, NINF, 'returns -Infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -189,18 +189,18 @@ tape( 'the function returns `NaN` if provided a value greater than `1`', opts, f
 
 tape( 'the function returns `-0` if provided `-0`', opts, function test( t ) {
 	var v = atanh( -0.0 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+0` if provided `+0`', opts, function test( t ) {
 	var v = atanh( 0.0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns 0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var v = atanh( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/avercos/test/test.js b/lib/node_modules/@stdlib/math/base/special/avercos/test/test.js
index fb17b6dff23b..0d458f7a3c18 100644
--- a/lib/node_modules/@stdlib/math/base/special/avercos/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/avercos/test/test.js
@@ -92,7 +92,7 @@ tape( 'the function computes the inverse versed cosine (small negative numbers)'
 
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var v = avercos( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/avercos/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/avercos/test/test.native.js
index 26479b4a8ab2..90d5f41cb4db 100644
--- a/lib/node_modules/@stdlib/math/base/special/avercos/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/avercos/test/test.native.js
@@ -101,7 +101,7 @@ tape( 'the function computes the inverse versed cosine (small negative numbers)'
 
 tape( 'the function returns `NaN` if provided a `NaN`', opts, function test( t ) {
 	var v = avercos( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/aversin/test/test.js b/lib/node_modules/@stdlib/math/base/special/aversin/test/test.js
index 777bd6bc89b0..c730d8777809 100644
--- a/lib/node_modules/@stdlib/math/base/special/aversin/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/aversin/test/test.js
@@ -92,7 +92,7 @@ tape( 'the function computes the inverse versed sine (small positive numbers)',
 
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var v = aversin( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/aversin/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/aversin/test/test.native.js
index 4a93977080f3..8e79c6bf5d87 100644
--- a/lib/node_modules/@stdlib/math/base/special/aversin/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/aversin/test/test.native.js
@@ -101,7 +101,7 @@ tape( 'the function computes the inverse versed sine (small positive numbers)',
 
 tape( 'the function returns `NaN` if provided a `NaN`', opts, function test( t ) {
 	var v = aversin( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/cabs2/test/test.js b/lib/node_modules/@stdlib/math/base/special/cabs2/test/test.js
index b2a599489836..ef0018c790e5 100644
--- a/lib/node_modules/@stdlib/math/base/special/cabs2/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/cabs2/test/test.js
@@ -71,13 +71,13 @@ tape( 'if either the real or imaginary component is `NaN`, the function returns
 	var v;
 
 	v = cabs2( new Complex128( NaN, 3.0 ) );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = cabs2( new Complex128( 5.0, NaN ) );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = cabs2( new Complex128( NaN, NaN ) );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/cabs2/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/cabs2/test/test.native.js
index 098771f16ff5..6449a25c3eeb 100644
--- a/lib/node_modules/@stdlib/math/base/special/cabs2/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/cabs2/test/test.native.js
@@ -80,13 +80,13 @@ tape( 'if either the real or imaginary component is `NaN`, the function returns
 	var v;
 
 	v = cabs2( new Complex128( NaN, 3.0 ) );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = cabs2( new Complex128( 5.0, NaN ) );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = cabs2( new Complex128( NaN, NaN ) );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/deg2rad/test/test.js b/lib/node_modules/@stdlib/math/base/special/deg2rad/test/test.js
index c80a90eac747..9f69244f110a 100644
--- a/lib/node_modules/@stdlib/math/base/special/deg2rad/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/deg2rad/test/test.js
@@ -42,19 +42,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `+infinity`, the function returns `+infinity`', function test( t ) {
 	var r = deg2rad( PINF );
-	t.strictEqual( r, PINF, 'returns +infinity' );
+	t.strictEqual( r, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `-infinity`', function test( t ) {
 	var r = deg2rad( NINF );
-	t.strictEqual( r, NINF, 'returns -infinity' );
+	t.strictEqual( r, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var r = deg2rad( NaN );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -76,6 +76,6 @@ tape( 'the function converts an angle from degrees to radians', function test( t
 
 tape( 'if provided a value less than `~5e-324*180/pi`, the function will underflow', function test( t ) {
 	var r = deg2rad( 1.0e-322 );
-	t.strictEqual( r, 0.0, 'returns 0' );
+	t.strictEqual( r, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/deg2rad/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/deg2rad/test/test.native.js
index d0fd62773700..73b3e743b4f9 100644
--- a/lib/node_modules/@stdlib/math/base/special/deg2rad/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/deg2rad/test/test.native.js
@@ -51,19 +51,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `+infinity`, the function returns `+infinity`', opts, function test( t ) {
 	var r = deg2rad( PINF );
-	t.strictEqual( r, PINF, 'returns +infinity' );
+	t.strictEqual( r, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `-infinity`', opts, function test( t ) {
 	var r = deg2rad( NINF );
-	t.strictEqual( r, NINF, 'returns -infinity' );
+	t.strictEqual( r, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var r = deg2rad( NaN );
-	t.strictEqual( isnan( r ), true, 'returns NaN' );
+	t.strictEqual( isnan( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -85,6 +85,6 @@ tape( 'the function converts an angle from degrees to radians', opts, function t
 
 tape( 'if provided a value less than `~5e-324*180/pi`, the function will underflow', opts, function test( t ) {
 	var r = deg2rad( 1.0e-322 );
-	t.strictEqual( r, 0.0, 'returns 0' );
+	t.strictEqual( r, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/deg2radf/test/test.js b/lib/node_modules/@stdlib/math/base/special/deg2radf/test/test.js
index 15210e9e83c2..7e54ebec32a9 100644
--- a/lib/node_modules/@stdlib/math/base/special/deg2radf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/deg2radf/test/test.js
@@ -44,19 +44,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `+infinity`, the function returns `+infinity`', function test( t ) {
 	var r = deg2radf( PINF );
-	t.strictEqual( r, PINF, 'returns +infinity' );
+	t.strictEqual( r, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `-infinity`', function test( t ) {
 	var r = deg2radf( NINF );
-	t.strictEqual( r, NINF, 'returns -infinity' );
+	t.strictEqual( r, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var r = deg2radf( NaN );
-	t.strictEqual( isnanf( r ), true, 'returns NaN' );
+	t.strictEqual( isnanf( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -86,6 +86,6 @@ tape( 'the function converts an angle from degrees to radians', function test( t
 
 tape( 'if provided a value less than `~1.4e-45*180/pi`, the function will underflow', function test( t ) {
 	var r = deg2radf( 1.0e-45 );
-	t.strictEqual( r, 0.0, 'returns 0' );
+	t.strictEqual( r, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/deg2radf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/deg2radf/test/test.native.js
index 561c09009de0..cbf6f5d68b05 100644
--- a/lib/node_modules/@stdlib/math/base/special/deg2radf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/deg2radf/test/test.native.js
@@ -51,19 +51,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `+infinity`, the function returns `+infinity`', opts, function test( t ) {
 	var r = deg2radf( PINF );
-	t.strictEqual( r, PINF, 'returns +infinity' );
+	t.strictEqual( r, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `-infinity`', opts, function test( t ) {
 	var r = deg2radf( NINF );
-	t.strictEqual( r, NINF, 'returns -infinity' );
+	t.strictEqual( r, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var r = deg2radf( NaN );
-	t.strictEqual( isnanf( r ), true, 'returns NaN' );
+	t.strictEqual( isnanf( r ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -85,6 +85,6 @@ tape( 'the function converts an angle from degrees to radians', opts, function t
 
 tape( 'if provided a value less than `~1.4e-45*180/pi`, the function will underflow', opts, function test( t ) {
 	var r = deg2radf( 1.0e-45 );
-	t.strictEqual( r, 0.0, 'returns 0' );
+	t.strictEqual( r, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/digamma/test/test.js b/lib/node_modules/@stdlib/math/base/special/digamma/test/test.js
index 69c904adfce3..949323ed8909 100644
--- a/lib/node_modules/@stdlib/math/base/special/digamma/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/digamma/test/test.js
@@ -55,13 +55,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 	var val = digamma( NaN );
-	t.strictEqual( isnan( val ), true, 'returns NaN' );
+	t.strictEqual( isnan( val ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `0`', function test( t ) {
 	var val = digamma( 0.0 );
-	t.strictEqual( isnan( val ), true, 'returns NaN' );
+	t.strictEqual( isnan( val ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.js b/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.js
index 12ee0ce34138..c0f19a654b50 100644
--- a/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.js
@@ -56,24 +56,24 @@ tape( 'the function returns `0` if `x` does not.strictEqual `0`', function test(
 
 tape( 'the function returns `+infinity` if `x` equals `0`', function test( t ) {
 	var v = diracDelta( 0.0 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 	var v = diracDelta( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0` if provided `+infinity`', function test( t ) {
 	var v = diracDelta( PINF );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0` if provided `-infinity`', function test( t ) {
 	var v = diracDelta( NINF );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.native.js
index dcffb6f31103..511d833db8b6 100644
--- a/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/dirac-delta/test/test.native.js
@@ -65,24 +65,24 @@ tape( 'the function returns `0` if `x` does not.strictEqual `0`', opts, function
 
 tape( 'the function returns `+infinity` if `x` equals `0`', opts, function test( t ) {
 	var v = diracDelta( 0.0 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided a `NaN`', opts, function test( t ) {
 	var v = diracDelta( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0` if provided `+infinity`', opts, function test( t ) {
 	var v = diracDelta( PINF );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0` if provided `-infinity`', opts, function test( t ) {
 	var v = diracDelta( NINF );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.js b/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.js
index d28d0a70c7dc..e3e36c2c7d80 100644
--- a/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.js
@@ -56,24 +56,24 @@ tape( 'the function returns `0` if `x` does not.strictEqual `0`', function test(
 
 tape( 'the function returns `+infinity` if `x` equals `0`', function test( t ) {
 	var v = diracDeltaf( 0.0 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 	var v = diracDeltaf( NaN );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0` if provided `+infinity`', function test( t ) {
 	var v = diracDeltaf( PINF );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0` if provided `-infinity`', function test( t ) {
 	var v = diracDeltaf( NINF );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.native.js
index fe233fd28e00..1c7e73d572cd 100644
--- a/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/dirac-deltaf/test/test.native.js
@@ -65,24 +65,24 @@ tape( 'the function returns `0` if `x` does not.strictEqual `0`', opts, function
 
 tape( 'the function returns `+infinity` if `x` equals `0`', opts, function test( t ) {
 	var v = diracDeltaf( 0.0 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided a `NaN`', opts, function test( t ) {
 	var v = diracDeltaf( NaN );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0` if provided `+infinity`', opts, function test( t ) {
 	var v = diracDeltaf( PINF );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0` if provided `-infinity`', opts, function test( t ) {
 	var v = diracDeltaf( NINF );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/erf/test/test.js b/lib/node_modules/@stdlib/math/base/special/erf/test/test.js
index b56d09408995..74d5e05db90a 100644
--- a/lib/node_modules/@stdlib/math/base/special/erf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/erf/test/test.js
@@ -285,13 +285,13 @@ tape( 'the function evaluates the error function for subnormal `x`', function te
 
 tape( 'if provided `-0`, the function returns `-0`', function test( t ) {
 	var y = erf( -0.0 );
-	t.strictEqual( isNegativeZero( y ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+0`, the function returns `+0`', function test( t ) {
 	var y = erf( +0.0 );
-	t.strictEqual( isPositiveZero( y ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -303,12 +303,12 @@ tape( 'if provided `-infinity`, the function returns `-1`', function test( t ) {
 
 tape( 'if provided `+infinity`, the function returns `+1`', function test( t ) {
 	var y = erf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var y = erf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/erf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/erf/test/test.native.js
index 01e6710c4c8b..117b82caafc1 100644
--- a/lib/node_modules/@stdlib/math/base/special/erf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/erf/test/test.native.js
@@ -342,13 +342,13 @@ tape( 'the function evaluates the error function for subnormal `x`', opts, funct
 
 tape( 'if provided `-0`, the function returns `-0`', opts, function test( t ) {
 	var y = erf( -0.0 );
-	t.strictEqual( isNegativeZero( y ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+0`, the function returns `+0`', opts, function test( t ) {
 	var y = erf( +0.0 );
-	t.strictEqual( isPositiveZero( y ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -360,12 +360,12 @@ tape( 'if provided `-infinity`, the function returns `-1`', opts, function test(
 
 tape( 'if provided `+infinity`, the function returns `+1`', opts, function test( t ) {
 	var y = erf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var y = erf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/expit/test/test.js b/lib/node_modules/@stdlib/math/base/special/expit/test/test.js
index 4adba776aa1a..9949d6a5998b 100644
--- a/lib/node_modules/@stdlib/math/base/special/expit/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/expit/test/test.js
@@ -45,7 +45,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns `NaN` when provided `NaN`', function test( t ) {
 	var y = expit( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,13 +57,13 @@ tape( 'the function returns `0.5` when provided `0`', function test( t ) {
 
 tape( 'the function returns `1.0` when provided `+Infinity`', function test( t ) {
 	var y = expit( PINF );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0.0` when provided `-Infinity`', function test( t ) {
 	var y = expit( NINF );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/expit/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/expit/test/test.native.js
index 768163869986..dfba0fbc0ff8 100644
--- a/lib/node_modules/@stdlib/math/base/special/expit/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/expit/test/test.native.js
@@ -54,7 +54,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'the function returns `NaN` when provided `NaN`', opts, function test( t ) {
 	var y = expit( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,13 +66,13 @@ tape( 'the function returns `0.5` when provided `0`', opts, function test( t ) {
 
 tape( 'the function returns `1.0` when provided `+Infinity`', opts, function test( t ) {
 	var y = expit( PINF );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0.0` when provided `-Infinity`', opts, function test( t ) {
 	var y = expit( NINF );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/fast/min/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/fast/min/test/test.native.js
index ab4289cae4ef..112c7ab30725 100644
--- a/lib/node_modules/@stdlib/math/base/special/fast/min/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/fast/min/test/test.native.js
@@ -57,7 +57,7 @@ tape( 'the function may not return `NaN` if provided a `NaN`', opts, function te
 	t.strictEqual( v, 3.14, 'returns expected value' );
 
 	v = min( 3.14, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.assign.js b/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.assign.js
index 9b6a6258c8c4..0d4f29c205c5 100644
--- a/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.assign.js
+++ b/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.assign.js
@@ -245,8 +245,8 @@ tape( 'the function returns `[NaN, NaN]` if provided a `NaN`', function test( t
 	z = [ 0.0, 0.0 ];
 	v = fresnel( NaN, z, 1, 0 );
 	t.strictEqual( v, z, 'returns expected value' );
-	t.strictEqual( isnan( v[0] ), true, 'returns NaN' );
-	t.strictEqual( isnan( v[1] ), true, 'returns NaN' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.main.js b/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.main.js
index b431532b9826..e1fe43841c61 100644
--- a/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.main.js
+++ b/lib/node_modules/@stdlib/math/base/special/fresnel/test/test.main.js
@@ -211,7 +211,7 @@ tape( 'the function returns `[-0.5, -0.5]` if provided `-infinity`', function te
 
 tape( 'the function returns `[NaN, NaN]` if provided a `NaN`', function test( t ) {
 	var v = fresnel( NaN );
-	t.strictEqual( isnan( v[0] ), true, 'returns NaN' );
-	t.strictEqual( isnan( v[1] ), true, 'returns NaN' );
+	t.strictEqual( isnan( v[0] ), true, 'returns expected value' );
+	t.strictEqual( isnan( v[1] ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/fresnelc/test/test.js b/lib/node_modules/@stdlib/math/base/special/fresnelc/test/test.js
index 767c48c96bc4..6ac5f39772a6 100644
--- a/lib/node_modules/@stdlib/math/base/special/fresnelc/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/fresnelc/test/test.js
@@ -172,6 +172,6 @@ tape( 'the function returns `-0.5` if provided `-infinity`', function test( t )
 
 tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 	var v = fresnelc( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/fresnels/test/test.js b/lib/node_modules/@stdlib/math/base/special/fresnels/test/test.js
index 27851bf7dc7e..dc5bed23daba 100644
--- a/lib/node_modules/@stdlib/math/base/special/fresnels/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/fresnels/test/test.js
@@ -172,6 +172,6 @@ tape( 'the function returns `-0.5` if provided `-infinity`', function test( t )
 
 tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 	var v = fresnels( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.js b/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.js
index fad361591f7f..4a02987292dc 100644
--- a/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.js
@@ -80,13 +80,13 @@ tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 	var v;
 
 	v = kroneckerDelta( NaN, 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kroneckerDelta( 0.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kroneckerDelta( NaN, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.native.js
index d43d5bc926b2..d12889111a5e 100644
--- a/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/kronecker-delta/test/test.native.js
@@ -89,13 +89,13 @@ tape( 'the function returns `NaN` if provided a `NaN`', opts, function test( t )
 	var v;
 
 	v = kroneckerDelta( NaN, 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kroneckerDelta( 0.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kroneckerDelta( NaN, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.js b/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.js
index 43a196b74c1c..52552ac0d500 100644
--- a/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.js
@@ -80,13 +80,13 @@ tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 	var v;
 
 	v = kroneckerDeltaf( NaN, 0.0 );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = kroneckerDeltaf( 0.0, NaN );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = kroneckerDeltaf( NaN, NaN );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.native.js
index 3309f6e37d3d..7d54c469f71e 100644
--- a/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/kronecker-deltaf/test/test.native.js
@@ -89,13 +89,13 @@ tape( 'the function returns `NaN` if provided a `NaN`', opts, function test( t )
 	var v;
 
 	v = kroneckerDeltaf( NaN, 0.0 );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = kroneckerDeltaf( 0.0, NaN );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	v = kroneckerDeltaf( NaN, NaN );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.js b/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.js
index 7ace1e527f6d..7cf135ebce1e 100644
--- a/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.js
@@ -115,25 +115,25 @@ tape( 'the function multiplies a number by an integer power of two (subnormals)'
 
 tape( 'if provided a fraction equal to `+0`, the function returns `+0`', function test( t ) {
 	var v = ldexp( 0.0, 10 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a fraction equal to `-0`, the function returns `-0`', function test( t ) {
 	var v = ldexp( -0.0, 10 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a fraction equal to `+infinity`, the function returns `+infinity`', function test( t ) {
 	var v = ldexp( PINF, 10 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a fraction equal to `-infinity`, the function returns `-infinity`', function test( t ) {
 	var v = ldexp( NINF, 10 );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -145,34 +145,34 @@ tape( 'if provided an exponent.strictEqual to `0`, the function returns the prov
 
 tape( 'if provided a fraction equal to `NaN`, the function returns `NaN`', function test( t ) {
 	var v = ldexp( NaN, 10 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0` if the result of multiplying a positive fraction and an integer power of two underflows', function test( t ) {
 	// Min subnormal ~5e-324 ~ 2**-1074
 	var v = ldexp( 0.005, -1073 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-0` if the result of multiplying a negative fraction and an integer power of two underflows', function test( t ) {
 	// Min subnormal ~5e-324 ~ 2**-1074
 	var v = ldexp( -0.005, -1073 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+infinity` if the result of multiplying a positive fraction and an integer power of two overflows', function test( t ) {
 	// Max double ~1e308 ~ 2**1023
 	var v = ldexp( 1.0e3, 1021 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if the result of multiplying a negative fraction and an integer power of two overflows', function test( t ) {
 	// Max double ~1e308 ~ 2**1023
 	var v = ldexp( -1.0e3, 1021 );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.native.js
index e448252c7fbd..e425f06370bc 100644
--- a/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/ldexp/test/test.native.js
@@ -124,25 +124,25 @@ tape( 'the function multiplies a number by an integer power of two (subnormals)'
 
 tape( 'if provided a fraction equal to `+0`, the function returns `+0`', opts, function test( t ) {
 	var v = ldexp( 0.0, 10 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a fraction equal to `-0`, the function returns `-0`', opts, function test( t ) {
 	var v = ldexp( -0.0, 10 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a fraction equal to `+infinity`, the function returns `+infinity`', opts, function test( t ) {
 	var v = ldexp( PINF, 10 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a fraction equal to `-infinity`, the function returns `-infinity`', opts, function test( t ) {
 	var v = ldexp( NINF, 10 );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -154,34 +154,34 @@ tape( 'if provided an exponent.strictEqual to `0`, the function returns the prov
 
 tape( 'if provided a fraction equal to `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var v = ldexp( NaN, 10 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0` if the result of multiplying a positive fraction and an integer power of two underflows', opts, function test( t ) {
 	// Min subnormal ~5e-324 ~ 2**-1074
 	var v = ldexp( 0.005, -1073 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-0` if the result of multiplying a negative fraction and an integer power of two underflows', opts, function test( t ) {
 	// Min subnormal ~5e-324 ~ 2**-1074
 	var v = ldexp( -0.005, -1073 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+infinity` if the result of multiplying a positive fraction and an integer power of two overflows', opts, function test( t ) {
 	// Max double ~1e308 ~ 2**1023
 	var v = ldexp( 1.0e3, 1021 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if the result of multiplying a negative fraction and an integer power of two overflows', opts, function test( t ) {
 	// Max double ~1e308 ~ 2**1023
 	var v = ldexp( -1.0e3, 1021 );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ln/test/test.js b/lib/node_modules/@stdlib/math/base/special/ln/test/test.js
index 1b7098b80ff5..339fbbce5417 100644
--- a/lib/node_modules/@stdlib/math/base/special/ln/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/ln/test/test.js
@@ -223,7 +223,7 @@ tape( 'the function returns `+infinity` if provided `+infinity`', function test(
 
 tape( 'the function returns `NaN` if provided a negative number', function test( t ) {
 	var v = ln( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/ln/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/ln/test/test.native.js
index 27cf0b403993..f781cbcd89b2 100644
--- a/lib/node_modules/@stdlib/math/base/special/ln/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/ln/test/test.native.js
@@ -232,7 +232,7 @@ tape( 'the function returns `+infinity` if provided `+infinity`', opts, function
 
 tape( 'the function returns `NaN` if provided a negative number', opts, function test( t ) {
 	var v = ln( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/log/test/test.js b/lib/node_modules/@stdlib/math/base/special/log/test/test.js
index 11a03eee78e9..957a12b019c2 100644
--- a/lib/node_modules/@stdlib/math/base/special/log/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/log/test/test.js
@@ -45,27 +45,27 @@ tape( 'the function has two parameters', function test( t ) {
 });
 
 tape( 'the function returns `NaN` if provided `NaN` as either of the arguments', function test( t ) {
-	t.strictEqual( isnan( log( 2.0, NaN ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( log( NaN, 3.0 ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( log( 2.0, NaN ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( log( NaN, 3.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided a negative number as either of the arguments', function test( t ) {
-	t.strictEqual( isnan( log( 2.0, -0.4 ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( log( -1.0, 3.0 ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( log( 2.0, -0.4 ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( log( -1.0, 3.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `1` or `0` for both arguments', function test( t ) {
-	t.strictEqual( isnan( log( 0.0, 0.0 ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( log( 1.0, 1.0 ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( log( 0.0, 0.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( log( 1.0, 1.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `1.0` if provided `x` and `b` such that `x = b` (except for zero and one)', function test( t ) {
 	var i;
 	for ( i = 2; i < 100; i++ ) {
-		t.strictEqual( log( i, i ), 1.0, 'returns 1.0' );
+		t.strictEqual( log( i, i ), 1.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/log/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/log/test/test.native.js
index 0f01dceb5fc3..f533e544442f 100644
--- a/lib/node_modules/@stdlib/math/base/special/log/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/log/test/test.native.js
@@ -54,27 +54,27 @@ tape( 'the function has two parameters', opts, function test( t ) {
 });
 
 tape( 'the function returns `NaN` if provided `NaN` as either of the arguments', opts, function test( t ) {
-	t.strictEqual( isnan( log( 2.0, NaN ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( log( NaN, 3.0 ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( log( 2.0, NaN ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( log( NaN, 3.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided a negative number as either of the arguments', opts, function test( t ) {
-	t.strictEqual( isnan( log( 2.0, -0.4 ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( log( -1.0, 3.0 ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( log( 2.0, -0.4 ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( log( -1.0, 3.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `NaN` if provided `1` or `0` for both arguments', opts, function test( t ) {
-	t.strictEqual( isnan( log( 0.0, 0.0 ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( log( 1.0, 1.0 ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( log( 0.0, 0.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( log( 1.0, 1.0 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `1.0` if provided `x` and `b` such that `x = b` (except for zero and one)', opts, function test( t ) {
 	var i;
 	for ( i = 2; i < 100; i++ ) {
-		t.strictEqual( log( i, i ), 1.0, 'returns 1.0' );
+		t.strictEqual( log( i, i ), 1.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/lucas/test/test.js b/lib/node_modules/@stdlib/math/base/special/lucas/test/test.js
index 7af5f8d679ad..70a97e394895 100644
--- a/lib/node_modules/@stdlib/math/base/special/lucas/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/lucas/test/test.js
@@ -44,7 +44,7 @@ tape( 'if provided a negative number, the function returns `NaN`', function test
 	var v;
 	var i;
 
-	t.strictEqual( isnan( lucas( -3.14 ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( lucas( -3.14 ) ), true, 'returns expected value' );
 
 	for ( i = -1; i > -100; i-- ) {
 		v = lucas( i );
@@ -67,7 +67,7 @@ tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 
 tape( 'if provided a non-integer, the function returns `NaN`', function test( t ) {
 	var v = lucas( 3.14 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/polygamma/test/test.js b/lib/node_modules/@stdlib/math/base/special/polygamma/test/test.js
index 95c5b1120925..1f8229213982 100644
--- a/lib/node_modules/@stdlib/math/base/special/polygamma/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/polygamma/test/test.js
@@ -52,31 +52,31 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided a `NaN` for either parameter, the function returns `NaN` ', function test( t ) {
 	var val = polygamma( NaN, 1.7 );
-	t.strictEqual( isnan( val ), true, 'returns NaN' );
+	t.strictEqual( isnan( val ), true, 'returns expected value' );
 
 	val = polygamma( 4, NaN );
-	t.strictEqual( isnan( val ), true, 'returns NaN' );
+	t.strictEqual( isnan( val ), true, 'returns expected value' );
 
 	val = polygamma( NaN, NaN );
-	t.strictEqual( isnan( val ), true, 'returns NaN' );
+	t.strictEqual( isnan( val ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided an even negative integer for `x`, the function returns `NaN` ', function test( t ) {
 	var val = polygamma( 2, -2.0 );
-	t.strictEqual( isnan( val ), true, 'returns NaN' );
+	t.strictEqual( isnan( val ), true, 'returns expected value' );
 
 	val = polygamma( 2, -4.0 );
-	t.strictEqual( isnan( val ), true, 'returns NaN' );
+	t.strictEqual( isnan( val ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided an odd negative integer for `x`, the function returns positive infinity', function test( t ) {
 	var val = polygamma( 4, -1.0 );
-	t.strictEqual( val, PINF, 'returns +infinity' );
+	t.strictEqual( val, PINF, 'returns expected value' );
 
 	val = polygamma( 4, -3.0 );
-	t.strictEqual( val, PINF, true, 'returns +infinity' );
+	t.strictEqual( val, PINF, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/utils/absolute-difference/test/test.js b/lib/node_modules/@stdlib/math/base/utils/absolute-difference/test/test.js
index 266609c5e534..52e25e85cbf1 100644
--- a/lib/node_modules/@stdlib/math/base/utils/absolute-difference/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/utils/absolute-difference/test/test.js
@@ -40,13 +40,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if both `x` and `y` equal `+infinity`, the function returns `NaN`', function test( t ) {
 	var d = diff( PINF, PINF );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if both `x` and `y` equal `-infinity`, the function returns `NaN`', function test( t ) {
 	var d = diff( NINF, NINF );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -65,10 +65,10 @@ tape( 'if `x` or `y` equals `+infinity` and the other value equals any other num
 
 	for ( i = 0; i < values.length; i++ ) {
 		d = diff( PINF, values[i] );
-		t.strictEqual( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns expected value' );
 
 		d = diff( values[i], PINF );
-		t.strictEqual( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns expected value' );
 	}
 	t.end();
 });
@@ -88,10 +88,10 @@ tape( 'if `x` or `y` equals `-infinity` and the other value equals any other num
 
 	for ( i = 0; i < values.length; i++ ) {
 		d = diff( NINF, values[i] );
-		t.strictEqual( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns expected value' );
 
 		d = diff( values[i], NINF );
-		t.strictEqual( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns expected value' );
 	}
 	t.end();
 });
@@ -100,13 +100,13 @@ tape( 'if `x` and/or `y` is `NaN`, the function returns `NaN`', function test( t
 	var d;
 
 	d = diff( NaN, 5.0 );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( 3.0, NaN );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( NaN, NaN );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -130,10 +130,10 @@ tape( 'the function computes the absolute difference', function test( t ) {
 	t.ok( delta <= tol, 'returns ~12.05' );
 
 	d = diff( -0.0, 0.0 );
-	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns expected value' );
 
 	d = diff( 0.0, -0.0 );
-	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/utils/float64-epsilon-difference/test/test.js b/lib/node_modules/@stdlib/math/base/utils/float64-epsilon-difference/test/test.js
index e7635c19030b..812287d1997e 100644
--- a/lib/node_modules/@stdlib/math/base/utils/float64-epsilon-difference/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/utils/float64-epsilon-difference/test/test.js
@@ -49,13 +49,13 @@ tape( 'the function throws an error if provided an unrecognized/unsupported `sca
 
 tape( 'if both `x` and `y` equal `+infinity`, the function returns `NaN`', function test( t ) {
 	var d = diff( PINF, PINF );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if both `x` and `y` equal `-infinity`, the function returns `NaN`', function test( t ) {
 	var d = diff( NINF, NINF );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -74,10 +74,10 @@ tape( 'if `x` or `y` equals `+infinity` and the other value equals any other num
 
 	for ( i = 0; i < values.length; i++ ) {
 		d = diff( PINF, values[i] );
-		t.strictEqual( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns expected value' );
 
 		d = diff( values[i], PINF );
-		t.strictEqual( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns expected value' );
 	}
 	t.end();
 });
@@ -97,10 +97,10 @@ tape( 'if `x` or `y` equals `-infinity` and the other value equals any other num
 
 	for ( i = 0; i < values.length; i++ ) {
 		d = diff( NINF, values[i] );
-		t.strictEqual( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns expected value' );
 
 		d = diff( values[i], NINF );
-		t.strictEqual( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns expected value' );
 	}
 	t.end();
 });
@@ -109,10 +109,10 @@ tape( 'if `x` and/or `y` is `NaN`, the function returns `NaN`', function test( t
 	var d;
 
 	d = diff( NaN, 5.0 );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( 3.0, NaN );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'if `x = y` and `x` and `y` are both finite, the function always returns `
 	for ( i = 0; i < values.length; i++ ) {
 		v = values[ i ];
 		d = diff( v, v );
-		t.strictEqual( d, 0.0, 'returns 0' );
+		t.strictEqual( d, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -146,16 +146,16 @@ tape( 'if `x` and `y` both equal `+-0`, the function returns `0`', function test
 	var d;
 
 	d = diff( -0.0, 0.0 );
-	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns expected value' );
 
 	d = diff( -0.0, -0.0 );
-	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns expected value' );
 
 	d = diff( 0.0, 0.0 );
-	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns expected value' );
 
 	d = diff( 0.0, -0.0 );
-	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,25 +164,25 @@ tape( 'if a scale function returns `0`, the function returns `NaN`', function te
 	var d;
 
 	d = diff( -1.0, 1.0, 'mean' );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( -1.0, 0.0, 'max' );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( 0.0, 1.0, 'min' );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( 0.0, -1.0, 'min-abs' );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( 0.0, 5.0, 'x' );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( 5.0, 0.0, 'y' );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( 2.0, 5.0, scale );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/math/base/utils/relative-difference/test/test.js b/lib/node_modules/@stdlib/math/base/utils/relative-difference/test/test.js
index b68e1295bcc9..f3d77991b8ee 100644
--- a/lib/node_modules/@stdlib/math/base/utils/relative-difference/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/utils/relative-difference/test/test.js
@@ -49,13 +49,13 @@ tape( 'the function throws an error if provided an unrecognized/unsupported `sca
 
 tape( 'if both `x` and `y` equal `+infinity`, the function returns `NaN`', function test( t ) {
 	var d = diff( PINF, PINF );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if both `x` and `y` equal `-infinity`, the function returns `NaN`', function test( t ) {
 	var d = diff( NINF, NINF );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -74,10 +74,10 @@ tape( 'if `x` or `y` equals `+infinity` and the other value equals any other num
 
 	for ( i = 0; i < values.length; i++ ) {
 		d = diff( PINF, values[i] );
-		t.strictEqual( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns expected value' );
 
 		d = diff( values[i], PINF );
-		t.strictEqual( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns expected value' );
 	}
 	t.end();
 });
@@ -97,10 +97,10 @@ tape( 'if `x` or `y` equals `-infinity` and the other value equals any other num
 
 	for ( i = 0; i < values.length; i++ ) {
 		d = diff( NINF, values[i] );
-		t.strictEqual( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns expected value' );
 
 		d = diff( values[i], NINF );
-		t.strictEqual( d, PINF, 'returns +infinity' );
+		t.strictEqual( d, PINF, 'returns expected value' );
 	}
 	t.end();
 });
@@ -109,10 +109,10 @@ tape( 'if `x` and/or `y` is `NaN`, the function returns `NaN`', function test( t
 	var d;
 
 	d = diff( NaN, 5.0 );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( 3.0, NaN );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'if `x = y` and `x` and `y` are both finite, the function always returns `
 	for ( i = 0; i < values.length; i++ ) {
 		v = values[ i ];
 		d = diff( v, v );
-		t.strictEqual( d, 0.0, 'returns 0' );
+		t.strictEqual( d, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -146,16 +146,16 @@ tape( 'if `x` and `y` both equal `+-0`, the function returns `0`', function test
 	var d;
 
 	d = diff( -0.0, 0.0 );
-	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns expected value' );
 
 	d = diff( -0.0, -0.0 );
-	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns expected value' );
 
 	d = diff( 0.0, 0.0 );
-	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns expected value' );
 
 	d = diff( 0.0, -0.0 );
-	t.strictEqual( isPositiveZero( d ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( d ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -164,25 +164,25 @@ tape( 'if a scale function returns `0`, the function returns `NaN`', function te
 	var d;
 
 	d = diff( -1.0, 1.0, 'mean' );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( -1.0, 0.0, 'max' );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( 0.0, 1.0, 'min' );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( 0.0, -1.0, 'min-abs' );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( 0.0, 5.0, 'x' );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( 5.0, 0.0, 'y' );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	d = diff( 2.0, 5.0, scale );
-	t.strictEqual( isnan( d ), true, 'returns NaN' );
+	t.strictEqual( isnan( d ), true, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/from-binary-string/test/test.js b/lib/node_modules/@stdlib/number/float32/base/from-binary-string/test/test.js
index 697d26d95cb1..c05f941cfbaa 100644
--- a/lib/node_modules/@stdlib/number/float32/base/from-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/from-binary-string/test/test.js
@@ -74,29 +74,29 @@ tape( 'if provided a string with a length other than `32`, the function throws a
 
 tape( 'if provided all zeros, the function returns `+0`', function test( t ) {
 	var v = fromBinaryStringf( toBinaryStringf( 0.0 ) );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a sign bit of 1 and all zeros, the function returns `-0`', function test( t ) {
 	var v = fromBinaryStringf( toBinaryStringf( -0.0 ) );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a bit sequence where all exponent bits are 1s and everything else is 0, the function returns positive infinity', function test( t ) {
-	t.strictEqual( fromBinaryStringf( toBinaryStringf( PINF ) ), PINF, 'returns +infinity' );
+	t.strictEqual( fromBinaryStringf( toBinaryStringf( PINF ) ), PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a bit sequence where the sign bit is 1, all exponent bits are 1s, and everything else is 0, the function returns negative infinity', function test( t ) {
-	t.strictEqual( fromBinaryStringf( toBinaryStringf( NINF ) ), NINF, 'returns -infinity' );
+	t.strictEqual( fromBinaryStringf( toBinaryStringf( NINF ) ), NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a bit sequence where the sign bit may be either 1 or 0, all exponent bits are 1s, and the fraction is not all 0s, the function returns `NaN`', function test( t ) {
 	var v = fromBinaryStringf( toBinaryStringf( NaN ) );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/identity/test/test.js b/lib/node_modules/@stdlib/number/float32/base/identity/test/test.js
index 23084c8ccded..35dfdc7761b8 100644
--- a/lib/node_modules/@stdlib/number/float32/base/identity/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/identity/test/test.js
@@ -57,6 +57,6 @@ tape( 'the function evaluates the identity function when provided +-infinity', f
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = identityf( NaN );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float32/base/identity/test/test.native.js b/lib/node_modules/@stdlib/number/float32/base/identity/test/test.native.js
index 1df0d1b14530..a42b06e0af47 100644
--- a/lib/node_modules/@stdlib/number/float32/base/identity/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float32/base/identity/test/test.native.js
@@ -66,6 +66,6 @@ tape( 'the function evaluates the identity function when provided +-infinity', o
 
 tape( 'if provided `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var v = identityf( NaN );
-	t.strictEqual( isnanf( v ), true, 'returns NaN' );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/from-binary-string/test/test.js b/lib/node_modules/@stdlib/number/float64/base/from-binary-string/test/test.js
index 1e52a077c4e9..5070cbcd27fc 100644
--- a/lib/node_modules/@stdlib/number/float64/base/from-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/from-binary-string/test/test.js
@@ -75,29 +75,29 @@ tape( 'if provided a string with a length other than `32`, the function throws a
 });
 
 tape( 'if provided all zeros, the function returns `+0`', function test( t ) {
-	t.strictEqual( fromBinaryString( toBinaryString( 0.0 ) ), 0.0, 'returns +0' );
+	t.strictEqual( fromBinaryString( toBinaryString( 0.0 ) ), 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a sign bit of 1 and all zeros, the function returns `-0`', function test( t ) {
 	var v = fromBinaryString( toBinaryString( -0.0 ) );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a bit sequence where all exponent bits are 1s and everything else is 0, the function returns positive infinity', function test( t ) {
-	t.strictEqual( fromBinaryString( toBinaryString( PINF ) ), PINF, 'returns +infinity' );
+	t.strictEqual( fromBinaryString( toBinaryString( PINF ) ), PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a bit sequence where the sign bit is 1, all exponent bits are 1s, and everything else is 0, the function returns negative infinity', function test( t ) {
-	t.strictEqual( fromBinaryString( toBinaryString( NINF ) ), NINF, 'returns -infinity' );
+	t.strictEqual( fromBinaryString( toBinaryString( NINF ) ), NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a bit sequence where the sign bit may be either 1 or 0, all exponent bits are 1s, and the fraction is not all 0s, the function returns `NaN`', function test( t ) {
 	var v = fromBinaryString( toBinaryString( NaN ) );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/base/identity/test/test.js b/lib/node_modules/@stdlib/number/float64/base/identity/test/test.js
index 35ae6fdc55f7..36ab4cd00bf7 100644
--- a/lib/node_modules/@stdlib/number/float64/base/identity/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/identity/test/test.js
@@ -57,6 +57,6 @@ tape( 'the function evaluates the identity function when provided +-infinity', f
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = identity( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/identity/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/identity/test/test.native.js
index 427ca66189c1..d7749e490faa 100644
--- a/lib/node_modules/@stdlib/number/float64/base/identity/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/identity/test/test.native.js
@@ -66,6 +66,6 @@ tape( 'the function evaluates the identity function when provided +-infinity', o
 
 tape( 'if provided `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var v = identity( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.js b/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.js
index 737ce9c72e0c..3ea682b165b0 100644
--- a/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.js
@@ -87,25 +87,25 @@ tape( 'if provided `0`, the function returns `0`', function test( t ) {
 
 tape( 'if provided `-0`, the function returns `-0`', function test( t ) {
 	var v = float64ToFloat32( -0.0 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity`, the function returns `+infinity`', function test( t ) {
 	var v = float64ToFloat32( PINF );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `-infinity`', function test( t ) {
 	var v = float64ToFloat32( NINF );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = float64ToFloat32( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.polyfill.js b/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.polyfill.js
index 4f6e29452916..c63b11df21d2 100644
--- a/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/number/float64/base/to-float32/test/test.polyfill.js
@@ -65,25 +65,25 @@ tape( 'if provided `0`, the function returns `0`', function test( t ) {
 
 tape( 'if provided `-0`, the function returns `-0`', function test( t ) {
 	var v = float64ToFloat32( -0.0 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity`, the function returns `+infinity`', function test( t ) {
 	var v = float64ToFloat32( PINF );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `-infinity`', function test( t ) {
 	var v = float64ToFloat32( NINF );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `NaN`', function test( t ) {
 	var v = float64ToFloat32( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.factory.js
index c6745171eb58..ef8d7e89edab 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a `a >= b`, the created function always returns `NaN`', funct
 	cdf = factory( 2.0, 1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -1.0, -2.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.main.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.main.js
index ee6ab1c48aaa..67e8e130899b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.main.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.main.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = cdf( 2.0, -1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -0.5, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.native.js
index d74177ae6b69..7a055661a841 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = cdf( 2.0, -1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -0.5, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.js
index d549c4a3ef08..a082104f8abc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = entropy( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.native.js
index f30598243354..d0ee91f051a4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/entropy/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = entropy( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.js
index 4ff4961ce9e9..a48f8e77ab52 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.js
@@ -38,10 +38,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -50,16 +50,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = kurtosis( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.native.js
index 9c8906de5226..a4fd1bd2f419 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/kurtosis/test/test.native.js
@@ -47,10 +47,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -59,16 +59,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = kurtosis( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.factory.js
index c289c52ae961..fc72eceeea8f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0, 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a `a >= b`, the created function always returns `NaN`', funct
 	logcdf = factory( 2.0, 1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -1.0, -2.0 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.logcdf.js
index f79dfbdbed4a..c5ffa1092413 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `-infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logcdf( 2.0, -1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -0.5, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.factory.js
index 5909c14bda97..55e6a02dc91f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `a` and `b`, the function returns a function which re
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `a` and `b`, the function returns a function which re
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.logpdf.js
index 311c8740fedb..fdf44ecd7634 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logpdf( 2.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.native.js
index 512cc0556990..2f2bc49d7672 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = logpdf( 2.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.js
index 87de9ea87aa6..fa971cf526da 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.native.js
index 879f66ea3b30..3d7968b68759 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mean( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.js
index 7437551bf4b5..a87ed9d3449c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -54,16 +54,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = median( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.native.js
index b40f70994ed3..4a4ff3aa534a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/median/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,16 +63,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = median( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.js
index 650bf2f8281f..fe838550d3ed 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -54,16 +54,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mode( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.native.js
index d0fad836fc1a..6f332505e4b5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/mode/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,16 +63,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mode( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.factory.js
index 2a25eb2e508b..4bfb4bf3e6ce 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.native.js
index 78a52e14b87d..afeb5f4dfef7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = pdf( 2.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.pdf.js
index dfa8e3e1900b..eb290cafef06 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pdf( 2.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.factory.js
index eea82f236e93..8c5444fe98eb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,18 +98,18 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	quantile = factory( 1.0, 0.5 );
 
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.js
index e6f6072504d1..780611c17746 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.js
@@ -38,10 +38,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -50,16 +50,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns `0.0` as the skewness of an arcsine distribution ',
 		a = ( randu()*10.0 );
 		b = ( randu()*10.0 ) + a;
 		v = skewness( a, b );
-		t.strictEqual( v, 0.0, 'returns 0.0' );
+		t.strictEqual( v, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.native.js
index b2bed942cd61..c486dd8d12c4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/skewness/test/test.native.js
@@ -47,10 +47,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -59,16 +59,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'the function returns `0.0` as the skewness of an arcsine distribution ',
 		a = ( randu()*10.0 );
 		b = ( randu()*10.0 ) + a;
 		v = skewness( a, b );
-		t.strictEqual( v, 0.0, 'returns 0.0' );
+		t.strictEqual( v, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.js
index e8c408891c5a..c194f0b4aaae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = stdev( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.native.js
index 03cf30f2a0b4..30167f844abe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = stdev( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.js
index ba1a7c19d79c..f8249be9f567 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = variance( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.native.js
index a0566095d1c6..d388ef2833e0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = variance( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.cdf.js
index e458dd6a4713..d689ad65019a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.cdf.js
@@ -43,27 +43,27 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 4.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -4.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -0.5, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -72,16 +72,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = cdf( 3.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 3.0, -0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 3.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.factory.js
index 8537e44e8446..6354ef53e64b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.factory.js
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.5 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a valid `p`, the function returns a function which returns `1
 
 	cdf = factory( 0.5 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -81,16 +81,16 @@ tape( 'if provided a valid `p`, the function returns a function which returns `0
 
 	cdf = factory( 0.5 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -20.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -2.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -101,21 +101,21 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the created fun
 
 	cdf = factory( -1.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.5 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.native.js
index 8269c0e5d2ab..448082d5118f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/cdf/test/test.native.js
@@ -52,27 +52,27 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 4.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -4.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -0.5, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -81,16 +81,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = cdf( 3.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 3.0, -0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 3.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.js
index d197ba92b1d9..532d1b5def63 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.js
@@ -44,16 +44,16 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `0` or `1` for `p`, the function returns `0`', function test( t ) {
 	var v = entropy( 0.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = entropy( 1.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -62,16 +62,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = entropy( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.native.js
index 1fc927580137..69c2e568788c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/entropy/test/test.native.js
@@ -53,16 +53,16 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `0` or `1` for `p`, the function returns `0`', opts, function test( t ) {
 	var v = entropy( 0.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = entropy( 1.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -71,16 +71,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = entropy( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.js
index d5b3c597bbcb..64053ea160d6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.js
@@ -44,16 +44,16 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `1` or `0` for `p`, the function returns `+infinity`', function test( t ) {
 	var v = kurtosis( 0.0 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = kurtosis( 1.0 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -62,16 +62,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.native.js
index 9c3ebe3ca5d2..f059b2f405f0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/kurtosis/test/test.native.js
@@ -53,16 +53,16 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `1` or `0` for `p`, the function returns `+infinity`', opts, function test( t ) {
 	var v = kurtosis( 0.0 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = kurtosis( 1.0 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -71,16 +71,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.js
index 8daa3d726c4e..9d810064f1b4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mean( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.native.js
index a5cab703fa87..32cd024b6f07 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mean/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mean( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.js
index d51de3e856f9..b54d1fb93227 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,16 +50,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = median( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.native.js
index 6063236afc90..5b560df98044 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/median/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,16 +59,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = median( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.factory.js
index bb624320107d..0ac7f7f38b4e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.factory.js
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.5 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,27 +70,27 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the created fun
 
 	mgf = factory( -1.0 );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.5 );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.mgf.js
index e4210895705b..1e583080fd96 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.mgf.js
@@ -43,9 +43,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 4.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -53,16 +53,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = mgf( 3.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 3.0, -0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 3.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.native.js
index 64fa5893ea76..3f1f49b0fb79 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mgf/test/test.native.js
@@ -54,9 +54,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 4.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -64,16 +64,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = mgf( 3.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), false, 'returns NaN' );
+	t.strictEqual( isnan( y ), false, 'returns expected value' );
 
 	y = mgf( 3.0, -0.5 );
-	t.strictEqual( isnan( y ), false, 'returns NaN' );
+	t.strictEqual( isnan( y ), false, 'returns expected value' );
 
 	y = mgf( 3.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.js
index 8aca5c1f7ebe..65f0b71b6b31 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,16 +50,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mode( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.native.js
index ea1389c3ee44..1e1dd7184b11 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/mode/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,16 +59,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mode( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.factory.js
index 9fc43dc70666..5222a8a52f65 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.factory.js
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 0.5 );
 	y = pmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN );
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	pmf = factory( 1.0 );
 	y = pmf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -80,10 +80,10 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	pmf = factory( 0.4 );
 	y = pmf( -4.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,19 +94,19 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	pmf = factory( 0.4 );
 	y = pmf( 1.3 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 1.4 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 3.2 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 4.8 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.2 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -118,18 +118,18 @@ tape( 'if provided a `p` outside of `[0,1]`, the created function always returns
 	pmf = factory( -1.5 );
 
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 1.2 );
 
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.native.js
index b96bf0126cff..d8bd44baa6e3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.native.js
@@ -51,40 +51,40 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pmf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( PINF, 0.01 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( -20.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -4.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( -1.3, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 2.4, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 0.5, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -93,10 +93,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function al
 	var y;
 
 	y = pmf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.pmf.js
index dc35566998e2..232993e6ddfc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/pmf/test/test.pmf.js
@@ -42,40 +42,40 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = pmf( PINF, 0.01 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = pmf( -20.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -4.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = pmf( -1.3, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 2.4, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 0.5, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -84,10 +84,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function al
 	var y;
 
 	y = pmf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.factory.js
index 310e431b841a..d29202900cd3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/quantile/test/test.factory.js
@@ -53,11 +53,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -68,10 +68,10 @@ tape( 'if provided a valid success probability `p`, the function returns a funct
 
 	quantile = factory( 0.8 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,18 +83,18 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the created functi
 	quantile = factory( -1.0 );
 
 	y = quantile( 0.4 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.5 );
 
 	y = quantile( 0.4 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.js
index 5beebbbf8494..56bfca64b175 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.js
@@ -44,19 +44,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `0` for `p`, the function returns `+infinity`', function test( t ) {
 	var v = skewness( 0.0 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `1` for `p`, the function returns `-infinity`', function test( t ) {
 	var v = skewness( 1.0 );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -64,16 +64,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = skewness( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.native.js
index 97fd2b7014e1..52f19a584e83 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/skewness/test/test.native.js
@@ -53,19 +53,19 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `0` for `p`, the function returns `+infinity`', opts, function test( t ) {
 	var v = skewness( 0.0 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `1` for `p`, the function returns `-infinity`', opts, function test( t ) {
 	var v = skewness( 1.0 );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -73,16 +73,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = skewness( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.js
index 30ef668f5931..3dfa17763cf6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.js
@@ -44,16 +44,16 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `0` or `1` for `p`, the function returns `0`', function test( t ) {
 	var v = stdev( 1.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = stdev( 0.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -62,16 +62,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = stdev( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.native.js
index b3ed3c065f8b..d1b6129bf321 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/stdev/test/test.native.js
@@ -53,16 +53,16 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `0` or `1` for `p`, the function returns `0`', opts, function test( t ) {
 	var v = stdev( 1.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = stdev( 0.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -71,16 +71,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = stdev( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.js
index 4947e5a18a42..7e79279fda76 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.js
@@ -44,16 +44,16 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `1` or `0` for `p`, the function returns `0`', function test( t ) {
 	var v = variance( 1.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = variance( 0.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -62,16 +62,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = variance( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.native.js
index 726449e5a5da..d9ad12ebc17f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/variance/test/test.native.js
@@ -53,16 +53,16 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `1` or `0` for `p`, the function returns `0`', opts, function test( t ) {
 	var v = variance( 1.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = variance( 0.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -71,16 +71,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = variance( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/entropy/test/test.native.js
index 4c0429177b6f..4f434daa3153 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/entropy/test/test.native.js
@@ -53,26 +53,26 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NaN, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NaN, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,19 +81,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = entropy( 1.5, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -2, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -1, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 2.5, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( PINF, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -102,16 +102,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = entropy( 20, -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 20, 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 20, NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 20, PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -119,10 +119,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 tape( 'the function returns `0` for `p` equal to `1` or `0`', opts, function test( t ) {
 	var y;
 	y = entropy( 3, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = entropy( 3, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -130,7 +130,7 @@ tape( 'the function returns `0` for `p` equal to `1` or `0`', opts, function tes
 tape( 'the function returns `0` for `n` equal to `0`', opts, function test( t ) {
 	var y;
 	y = entropy( 0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.native.js
index 077b391ddb80..0ebdb1e45eaf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/mgf/test/test.native.js
@@ -56,9 +56,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 10, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 4.0, 10, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,10 +66,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mgf( 2.0, -2, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, -1, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = mgf( 2.0, 20, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 20, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 20, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.native.js
index 8ceef2b4809d..c362b1b67bc0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/pmf/test/test.native.js
@@ -56,40 +56,40 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `x` or `p`, the function returns `NaN`', opts, function test( t ) {
 	var y = pmf( NaN, 20, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, 20, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `n` and `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( NINF, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -20.0, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -100.0, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `n` and `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( -1.5, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -0.5, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 1.5, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 2.5, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -98,16 +98,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = pmf( 2.0, 20, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, 20, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, 20, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -120,32 +120,32 @@ tape( 'if `p` or `n` equals `0`, the function evaluates a degenerate distributio
 	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = pmf( 1.0, 8, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( PINF, 8, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NINF, 8, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NaN, 8, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	// Case: n = 0, p = 0.5
 	y = pmf( 0.0, 0, 0.5 );
 	t.strictEqual( y, 1.0, 'returns 1 for x equal to 0' );
 
 	y = pmf( 1.0, 0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( PINF, 0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NINF, 0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NaN, 0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -157,16 +157,16 @@ tape( 'if `p` equals `1.0`, the function evaluates a degenerate distribution cen
 	t.strictEqual( y, 1.0, 'returns 1 for x equal to 8' );
 
 	y = pmf( 1.0, 8, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( PINF, 8, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NINF, 8, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( NaN, 8, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/median/test/test.native.js
index 7331f9d9f59f..23a1385e6347 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/median/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,13 +60,13 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var v;
 
 	v = median( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/skewness/test/test.js
index baf81a830279..1daa14509d52 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/skewness/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,13 +51,13 @@ tape( 'if provided a shape parameter `c` that is not a positive number, the func
 	var v;
 
 	v = skewness( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/test/test.native.js
index b6374a86a57b..6849ca37ff80 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/stdev/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bradford/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/bradford/variance/test/test.native.js
index 2f16368c84b9..7995823c63fd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bradford/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bradford/variance/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `c`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.native.js
index 586a0bcf2625..4bf93c33eb8e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/cdf/test/test.native.js
@@ -55,10 +55,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = cdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -67,13 +67,13 @@ tape( 'if provided a negative `k`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,13 +82,13 @@ tape( 'if provided `k` equal to `0`, the function returns `0` for negative `x` a
 	var y;
 
 	y = cdf( -2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 2.0, 0.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -97,20 +97,20 @@ tape( 'if provided a nonpositive `x`, the function returns `0`', opts, function
 	var y;
 
 	y = cdf( -1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite positive `k`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.native.js
index 524b8f26c6c5..1509d195ce0c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/logpdf/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,10 +63,10 @@ tape( 'if provided a non-positive `k`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = logpdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, -2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,23 +75,23 @@ tape( 'if provided `k` equal to 0, the function returns `+infinity` or `-infinit
 	var y;
 
 	y = logpdf( 0.0, 0.0 );
-	t.strictEqual( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = logpdf( 2.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `k`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `k`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.native.js
index 5f3439078ff9..0b19e5021d99 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/pdf/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,7 +63,7 @@ tape( 'if provided a negative `k`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,20 +75,20 @@ tape( 'if `k` equals `0`, the function evaluates a degenerate distribution cente
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `k`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `k`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.native.js
index 45ea427b75e8..7f0b5c78bc81 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/cdf/test/test.native.js
@@ -55,10 +55,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = cdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,13 +79,13 @@ tape( 'if provided a negative `k`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.cdf.js
index b2010b4810f6..66590401c251 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.cdf.js
@@ -37,10 +37,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = cdf( NaN, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -49,10 +49,10 @@ tape( 'the function returns `1.0` if `x` is greater or equal to `mu`', function
 	var y;
 
 	y = cdf( 3.0, 3.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 4.0, 3.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -61,10 +61,10 @@ tape( 'the created function returns `0.0` if `x` is smaller than `mu`', function
 	var y;
 
 	y = cdf( 2.9, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -2.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.factory.js
index ecd1293b6fc7..ca0f8bb97b9f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.factory.js
@@ -45,11 +45,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 3.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -61,10 +61,10 @@ tape( 'the created function returns `1.0` if provided a value greater or equal t
 	cdf = factory( 3.0 );
 
 	y = cdf( 3.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 4.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -76,10 +76,10 @@ tape( 'the created function returns `0.0` if provided a value smaller than `mu`'
 	cdf = factory( 3.0 );
 
 	y = cdf( 2.9 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -2.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.native.js
index e70e938f0516..d1150e5cc1ab 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/cdf/test/test.native.js
@@ -46,10 +46,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = cdf( NaN, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -58,10 +58,10 @@ tape( 'the function returns `1.0` if `x` is greater or equal to `mu`', opts, fun
 	var y;
 
 	y = cdf( 3.0, 3.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 4.0, 3.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -70,10 +70,10 @@ tape( 'the created function returns `0.0` if `x` is smaller than `mu`', opts, fu
 	var y;
 
 	y = cdf( 2.9, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -2.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.js
index a4b6be06a873..89a86254dae8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.js
@@ -35,18 +35,18 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns the entropy of a degenerate distribution', function test( t ) {
 	var v = entropy( 2.0 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = entropy( -5.0 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = entropy( 0.5 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.native.js
index ab0ff2792890..571418ba9a60 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/entropy/test/test.native.js
@@ -44,18 +44,18 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns the entropy of a degenerate distribution', opts, function test( t ) {
 	var v = entropy( 2.0 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = entropy( -5.0 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = entropy( 0.5 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.factory.js
index f73d32d01042..5fcd31ff1a06 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.factory.js
@@ -46,11 +46,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 3.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -62,10 +62,10 @@ tape( 'the created function returns `0.0` if provided a value greater than or eq
 	logcdf = factory( 3.0 );
 
 	y = logcdf( 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 4.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'the created function returns `-Infinity` if provided a value less than `m
 	logcdf = factory( 3.0 );
 
 	y = logcdf( 2.9 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -2.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.logcdf.js
index f41ebc08ef47..8df8d5bd6913 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.logcdf.js
@@ -38,13 +38,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logcdf( NaN, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -53,10 +53,10 @@ tape( 'the function returns `0.0` if `x` is greater than or equal to `mu`', func
 	var y;
 
 	y = logcdf( 3.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 4.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'the created function returns `-Infinity` if `x` is less than `mu`', funct
 	var y;
 
 	y = logcdf( 2.9, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -2.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.native.js
index b0cfdc72b659..54596fef3b1d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logcdf/test/test.native.js
@@ -47,13 +47,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = logcdf( NaN, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -62,10 +62,10 @@ tape( 'the function returns `0.0` if `x` is greater than or equal to `mu`', opts
 	var y;
 
 	y = logcdf( 3.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 4.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -74,10 +74,10 @@ tape( 'the created function returns `-Infinity` if `x` is less than `mu`', opts,
 	var y;
 
 	y = logcdf( 2.9, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -2.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.factory.js
index 34412a563a23..a2ad9fa799d8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.factory.js
@@ -47,11 +47,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -62,15 +62,15 @@ tape( 'the created function returns `+Infinity` if provided `x` equal to `mu`',
 
 	logpdf = factory( 2.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	logpdf = factory( 0.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	logpdf = factory( -3.0 );
 	y = logpdf( -3.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -82,10 +82,10 @@ tape( 'the created function returns `-Infinity` if provided `x` not equal to `mu
 	logpdf = factory( 3.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 4.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.logpdf.js
index ffab314763c8..f58042955bc5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.logpdf.js
@@ -39,13 +39,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logpdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -54,13 +54,13 @@ tape( 'the function returns `+Infinity` if provided `x` equal to `mu`', function
 	var y;
 
 	y = logpdf( 2.0, 2.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = logpdf( 0.0, 0.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = logpdf( -3.0, -3.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -69,10 +69,10 @@ tape( 'the function returns `-Infinity` if provided `x` not equal to `mu`', func
 	var y;
 
 	y = logpdf( 2.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 4.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.native.js
index 29f43dafbfa1..23cfab3ee178 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpdf/test/test.native.js
@@ -48,13 +48,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = logpdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,13 +63,13 @@ tape( 'the function returns `+Infinity` if provided `x` equal to `mu`', opts, fu
 	var y;
 
 	y = logpdf( 2.0, 2.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = logpdf( 0.0, 0.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = logpdf( -3.0, -3.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -78,10 +78,10 @@ tape( 'the function returns `-Infinity` if provided `x` not equal to `mu`', opts
 	var y;
 
 	y = logpdf( 2.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 4.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.factory.js
index 58e233664343..8fd89b727715 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.factory.js
@@ -46,11 +46,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpmf = factory( 0.0 );
 	y = logpmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN );
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -61,15 +61,15 @@ tape( 'the created function returns `0.0` if provided `x` equal to `mu`', functi
 
 	logpmf = factory( 2.0 );
 	y = logpmf( 2.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	logpmf = factory( 0.0 );
 	y = logpmf( 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	logpmf = factory( -3.0 );
 	y = logpmf( -3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -81,10 +81,10 @@ tape( 'the created function returns `-Infinity` if provided `x` not equal to `mu
 	logpmf = factory( 3.0 );
 
 	y = logpmf( 2.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 4.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.logpmf.js
index 92fe46b48f33..c88d8a2c4e9b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.logpmf.js
@@ -38,13 +38,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logpmf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -53,13 +53,13 @@ tape( 'the function returns `0.0` if provided `x` equal to `mu`', function test(
 	var y;
 
 	y = logpmf( 2.0, 2.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logpmf( 0.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logpmf( -3.0, -3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -68,10 +68,10 @@ tape( 'the function returns `-Infinity` if provided `x` not equal to `mu`', func
 	var y;
 
 	y = logpmf( 2.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 4.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.native.js
index 37897e6f8e4f..003783aa0232 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/logpmf/test/test.native.js
@@ -47,13 +47,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = logpmf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -62,13 +62,13 @@ tape( 'the function returns `0.0` if provided `x` equal to `mu`', opts, function
 	var y;
 
 	y = logpmf( 2.0, 2.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logpmf( 0.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logpmf( -3.0, -3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'the function returns `-Infinity` if provided `x` not equal to `mu`', opts
 	var y;
 
 	y = logpmf( 2.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 4.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.js
index eaf5f105924c..fb1bffa46ff5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.native.js
index cc8145dc5c19..e56ade0e68e3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mean/test/test.native.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.js
index ee639c90845a..2970c2b41030 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.native.js
index e87c6ff2c44b..d253a697d968 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/median/test/test.native.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.factory.js
index afffccacfad5..d7d0930482eb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.factory.js
@@ -46,11 +46,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.mgf.js
index b3ed9344f87b..a25279e88148 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.mgf.js
@@ -38,13 +38,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = mgf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.native.js
index b14dab3f383c..a348e2ea2bc4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mgf/test/test.native.js
@@ -47,13 +47,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = mgf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.js
index 7b21720c64cb..9787977c1fb3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.native.js
index 202c91e96d16..b9fbdeb59c73 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/mode/test/test.native.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.factory.js
index 1d4422dc44dd..9d4e75a5d9df 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.factory.js
@@ -46,11 +46,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -61,15 +61,15 @@ tape( 'the created function returns `+Infinity` if provided `x` equal to `mu`',
 
 	pdf = factory( 2.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	pdf = factory( 0.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	pdf = factory( -3.0 );
 	y = pdf( -3.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -81,10 +81,10 @@ tape( 'the created function returns `0.0` if provided `x` not equal to `mu`', fu
 	pdf = factory( 3.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 4.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.native.js
index b342b274fbcd..938e6ce5410c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.native.js
@@ -47,13 +47,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = pdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -62,13 +62,13 @@ tape( 'the function returns `+Infinity` if provided `x` equal to `mu`', opts, fu
 	var y;
 
 	y = pdf( 2.0, 2.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = pdf( 0.0, 0.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = pdf( -3.0, -3.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'the function returns `0.0` if provided `x` not equal to `mu`', opts, func
 	var y;
 
 	y = pdf( 2.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 4.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.pdf.js
index ec2462b3ff60..3968a8978267 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pdf/test/test.pdf.js
@@ -38,13 +38,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = pdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -53,13 +53,13 @@ tape( 'the function returns `+Infinity` if provided `x` equal to `mu`', function
 	var y;
 
 	y = pdf( 2.0, 2.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = pdf( 0.0, 0.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = pdf( -3.0, -3.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -68,10 +68,10 @@ tape( 'the function returns `0.0` if provided `x` not equal to `mu`', function t
 	var y;
 
 	y = pdf( 2.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 4.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.factory.js
index 4e4690606e0e..77ab327a9a9b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.factory.js
@@ -45,11 +45,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 0.0 );
 	y = pmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN );
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -60,15 +60,15 @@ tape( 'the created function returns `1.0` if provided `x` equal to `mu`', functi
 
 	pmf = factory( 2.0 );
 	y = pmf( 2.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	pmf = factory( 0.0 );
 	y = pmf( 0.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	pmf = factory( -3.0 );
 	y = pmf( -3.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -80,10 +80,10 @@ tape( 'the created function returns `0.0` if provided `x` not equal to `mu`', fu
 	pmf = factory( 3.0 );
 
 	y = pmf( 2.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 4.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.native.js
index 65094441d270..a98ee5e34a4f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.native.js
@@ -46,13 +46,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = pmf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -61,13 +61,13 @@ tape( 'the function returns `1.0` if provided `x` equal to `mu`', opts, function
 	var y;
 
 	y = pmf( 2.0, 2.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = pmf( 0.0, 0.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = pmf( -3.0, -3.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -76,10 +76,10 @@ tape( 'the function returns `0.0` if provided `x` not equal to `mu`', opts, func
 	var y;
 
 	y = pmf( 2.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 4.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.pmf.js
index c25944e060f6..a4b6ad3c0a99 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/pmf/test/test.pmf.js
@@ -37,13 +37,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = pmf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -52,13 +52,13 @@ tape( 'the function returns `1.0` if provided `x` equal to `mu`', function test(
 	var y;
 
 	y = pmf( 2.0, 2.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = pmf( 0.0, 0.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = pmf( -3.0, -3.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -67,10 +67,10 @@ tape( 'the function returns `0.0` if provided `x` not equal to `mu`', function t
 	var y;
 
 	y = pmf( 2.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 4.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.factory.js
index e74331855274..84a2faaa4435 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.factory.js
@@ -45,11 +45,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -61,10 +61,10 @@ tape( 'the created function returns `NaN` for `p` outside the interval `[0,1]`',
 	quantile = factory( 2.0 );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.native.js
index 2c87c155855b..788fd8b6f067 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.native.js
@@ -46,13 +46,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = quantile( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -61,10 +61,10 @@ tape( 'if provided a number outside the interval `[0,1]` for `p`, the function r
 	var y;
 
 	y = quantile( 1.1, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.quantile.js
index 43aa143d4bef..eeea49e6e66b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/quantile/test/test.quantile.js
@@ -37,13 +37,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = quantile( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -52,10 +52,10 @@ tape( 'if provided a number outside the interval `[0,1]` for `p`, the function r
 	var y;
 
 	y = quantile( 1.1, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( -0.1, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.js
index 8d505bcb3a61..b6c4e347af12 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.js
@@ -35,18 +35,18 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns the standard deviation of a degenerate distribution', function test( t ) {
 	var v = stdev( 2.0 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = stdev( -5.0 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = stdev( 0.5 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.native.js
index 5f1b45e5fba8..88fcbc519b49 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/stdev/test/test.native.js
@@ -44,18 +44,18 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns the standard deviation of a degenerate distribution', opts, function test( t ) {
 	var v = stdev( 2.0 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = stdev( -5.0 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = stdev( 0.5 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.js
index faf56fbe62fe..0e9b78c770c3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.js
@@ -35,18 +35,18 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns the variance of a degenerate distribution', function test( t ) {
 	var v = variance( 2.0 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = variance( -5.0 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = variance( 0.5 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.native.js
index 6cbe8c4cbf66..f75fc899bd3a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/variance/test/test.native.js
@@ -44,18 +44,18 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `mu`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns the variance of a degenerate distribution', opts, function test( t ) {
 	var v = variance( 2.0 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = variance( -5.0 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = variance( 0.5 );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.cdf.js
index 7357942e18dc..448c67e259c6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.cdf.js
@@ -46,31 +46,31 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( 0.4, 0, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 1.0, -2.2, 3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( NaN, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, NaN, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 1, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a valid `a` and `b`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 2, 4 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a valid `a` and `b`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 2, 4 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -78,10 +78,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = cdf( 0.0, 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -2, -3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.factory.js
index ba6b1d257a44..964403308b97 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.factory.js
@@ -56,31 +56,31 @@ tape( 'if provided a non-integer value for any parameter, the created function r
 
 	cdf = factory( 0, 3.5 );
 	y = cdf( 1.4 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -2.2, 1 );
 	y = cdf( 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0, 1 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -91,7 +91,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0, 1 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -102,7 +102,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -114,22 +114,22 @@ tape( 'if provided a `a > b`, the created function always returns `NaN`', functi
 	cdf = factory( 2, 1 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -1, -2 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.native.js
index c6cccd25b10e..3235895f449b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/cdf/test/test.native.js
@@ -55,13 +55,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `Infinity` for `x` and a valid `a` and `b`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 2, 4 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a valid `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 2, 4 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -69,10 +69,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = cdf( 0.0, 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -2, -3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.js
index 5e3c5078f8d4..d28c1f65d4ce 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( 0.1, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10, 20.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,10 +66,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = entropy( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.native.js
index 029a93580520..6ae1751e65e0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/entropy/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = entropy( 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.js
index ac4f3fe03ead..031df81b827d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( 0.1, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10, 20.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,10 +66,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = kurtosis( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.native.js
index c29c56ed094c..ee5d3867f663 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/kurtosis/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = kurtosis( 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.factory.js
index 684934cdf76d..d84aa6eefbb6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided a non-integer value for `a` or `b`, the created function retu
 
 	logcdf = factory( 0, 1 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,11 +83,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0, 3.5 );
 	y = logcdf( 1.4 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -2.2, 1 );
 	y = logcdf( 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,7 +98,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0, 1 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -109,7 +109,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0, 1 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -121,22 +121,22 @@ tape( 'if provided a `a > b`, the created function always returns `NaN`', functi
 	logcdf = factory( 2, 1 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -1, -2 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.logcdf.js
index c5e52feccc5c..7a6e1a8cd689 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.logcdf.js
@@ -46,36 +46,36 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided a non-integer value for `a` or `b`, the function returns `NaN`', function test( t ) {
 	var y = logcdf( 0.4, 0, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 1.0, -2.2, 3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, NaN, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 1, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a valid `a` and `b`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 2, 4 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a valid `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 2, 4 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -83,10 +83,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logcdf( 0.0, 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -2, -3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.native.js
index 690a1b2fd1c4..9b7e82eed29b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logcdf/test/test.native.js
@@ -55,13 +55,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `Infinity` for `x` and a valid `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 2, 4 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a valid `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 2, 4 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -69,10 +69,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = logcdf( 0.0, 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -2, -3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.factory.js
index fadbd13e5dbc..29c20a1c8fa2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpmf = factory( 0, 1 );
 	y = logpmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, 1 );
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 1, NaN );
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, NaN );
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, NaN );
 	y = logpmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logpmf = factory( -2, 2 );
 	y = logpmf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logpmf = factory( -2, 2 );
 	y = logpmf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -105,11 +105,11 @@ tape( 'if provided a non-integer value for `a` or `b`, the created function retu
 
 	logpmf = factory( 0.5, 2 );
 	y = logpmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( -2, 5.5 );
 	y = logpmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -121,22 +121,22 @@ tape( 'if provided `a > b`, the created function always returns `NaN`', function
 	logpmf = factory( 0, -1 );
 
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 0.0, NINF );
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( PINF, NINF );
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, NINF );
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.logpmf.js
index 8d3ceddcff1b..bc19e47d84a2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.logpmf.js
@@ -46,32 +46,32 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpmf( NaN, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, NaN, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, 1, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( PINF, 0, 1 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( NINF, 0, 1 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpmf( 1.0, 1, 2.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, 0.1, 4 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,10 +80,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logpmf( 2.0, 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.native.js
index 02ea16de9b50..e19e972558bb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/logpmf/test/test.native.js
@@ -55,20 +55,20 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpmf( NaN, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( PINF, 0, 1 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( NINF, 0, 1 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -76,7 +76,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = logpmf( 2.0, 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.js
index 7abe623b19b5..8f4ea53a861a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( 0.1, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10, 20.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,10 +66,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.native.js
index e6558266a773..4098a1e20fef 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mean/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mean( 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.js
index f45944a3a40e..f2b8552b91c7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( 0.1, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10, 20.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,10 +66,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = median( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.native.js
index 64d7af36ec86..80f86719edb6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/median/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = median( 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.factory.js
index d5f243886040..66c57da73f98 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.factory.js
@@ -56,11 +56,11 @@ tape( 'if provided a non-integer value for `a` or `b`, the created function retu
 
 	mgf = factory( 0.5, 2 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( -2, 5.5 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -71,23 +71,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0, 1 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 1 );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -99,22 +99,22 @@ tape( 'if provided `a > b`, the created function always returns `NaN`', function
 	mgf = factory( 0, -1 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -125,11 +125,11 @@ tape( 'if provided valid parameters `a` and `b`, the created function returns `1
 
 	mgf = factory( -4, 4 );
 	y = mgf( 0.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	mgf = factory( 0, 10 );
 	y = mgf( 0.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.mgf.js
index 1f4633a96b52..5609ce4721d9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.mgf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( 0.0, 1, 2.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 0.1, 4 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, NaN, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 1, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -71,10 +71,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mgf( 2.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,13 +83,13 @@ tape( 'if provided valid parameters, the function returns `1` for `t = 0`', func
 	var y;
 
 	y = mgf( 0.0, 2, 4 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, 1, 2 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, -4, 4 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.native.js
index 6aae24f00c0f..99facd07bb80 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/mgf/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -62,7 +62,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mgf( 2.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -71,13 +71,13 @@ tape( 'if provided valid parameters, the function returns `1` for `t = 0`', opts
 	var y;
 
 	y = mgf( 0.0, 2, 4 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, 1, 2 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, -4, 4 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.factory.js
index 4a773c80d7cf..9c1cc93aa94b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 0.0, 1.0 );
 	y = pmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, 1.0 );
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 1.0, NaN );
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, NaN );
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, NaN );
 	y = pmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pmf = factory( -2, 2 );
 	y = pmf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pmf = factory( -2, 2 );
 	y = pmf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -105,11 +105,11 @@ tape( 'if provided a non-integer value for `a` or `b`, the created function retu
 
 	pmf = factory( 0.5, 2 );
 	y = pmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( -2, 5.5 );
 	y = pmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -121,22 +121,22 @@ tape( 'if provided `a > b`, the created function always returns `NaN`', function
 	pmf = factory( 0.0, -1.0 );
 
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 0.0, NINF );
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( PINF, NINF );
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, NINF );
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.native.js
index 4256386754a2..04df82a97361 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.native.js
@@ -52,20 +52,20 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pmf( NaN, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -73,7 +73,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = pmf( 2.0, 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.pmf.js
index d5b8e3eff6f6..2d0f5708388f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/pmf/test/test.pmf.js
@@ -46,32 +46,32 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( NaN, 0, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, NaN, 1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pmf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pmf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( 1.0, 1, 2.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, 0.1, 4 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,10 +80,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pmf( 2.0, 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.factory.js
index a4a17c8b8e77..2c429a67806e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0, 1 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1 );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1, NaN );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	quantile = factory( -2, 2 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,14 +98,14 @@ tape( 'if provided a non-integer value for `a` or `b`, the created function alwa
 	quantile = factory( 2, 1.5 );
 
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.2, 4 );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -117,14 +117,14 @@ tape( 'if provided `a > b`, the created function always returns `NaN`', function
 	quantile = factory( 2, 1 );
 
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.js
index 6666aa1bbab3..1cfd8bbc9b5e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.js
@@ -39,20 +39,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( 0.1, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10, 20.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -61,10 +61,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the function returns `0.0` as the skewness of a discrete uniform distribu
 		a = round( randu()*10.0 );
 		b = round( ( randu()*10.0 ) + a );
 		v = skewness( a, b );
-		t.strictEqual( v, 0.0, 'returns 0.0' );
+		t.strictEqual( v, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.native.js
index 81e5a489e56a..e063b92106da 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/skewness/test/test.native.js
@@ -48,7 +48,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = skewness( 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,7 +63,7 @@ tape( 'the function returns `0.0` as the skewness of a discrete uniform distribu
 		a = round( randu()*10.0 );
 		b = round( ( randu()*10.0 ) + a );
 		v = skewness( a, b );
-		t.strictEqual( v, 0.0, 'returns 0.0' );
+		t.strictEqual( v, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.js
index 13bec3f922b1..e5fab060022b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( 0.1, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10, 20.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,10 +66,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = stdev( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.native.js
index fc63bfe51566..1cda04ba4bd5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/stdev/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = stdev( 3, 2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.js
index e5c820ce9445..0adb13dc8a9b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.js
@@ -44,20 +44,20 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer value for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( 0.1, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10, 20.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,10 +66,10 @@ tape( 'if provided `a > b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = variance( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.native.js
index c4c31b7bb20f..1f9e6b1ad646 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/variance/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'if provided `a > b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = variance( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.cdf.js
index 7d27593e7b25..237988b66708 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `k` and `lambda`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 2, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `k` and `lambda`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 2, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `k`, the function returns `NaN`', function test( t
 	var y;
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided a negative `lambda`, the function returns `NaN`', function te
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.factory.js
index 45afaed7ac5d..bbda98fda3da 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `k` and `lambda`, the function returns a function wh
 
 	cdf = factory( 2, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `k` and `lambda`, the function returns a function wh
 
 	cdf = factory( 2, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	cdf = factory( 2, -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -137,26 +137,26 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.js
index 42f3ef3ed168..788ddccb68bd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = entropy( 1.5, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 3.9, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = entropy( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.native.js
index ca387e647029..fe82b005fde8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/entropy/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,22 +65,22 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = entropy( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = entropy( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.js
index 57a122fcb415..b10e339ffe60 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -54,28 +54,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = kurtosis( 1.7, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 3.7, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,19 +84,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = kurtosis( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.native.js
index 5f54591bf186..e81bae8e399f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/kurtosis/test/test.native.js
@@ -50,10 +50,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -62,10 +62,10 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = kurtosis( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -74,19 +74,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = kurtosis( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2, -2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 3, -1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.factory.js
index 2219479ad9b8..e3d6e7cd1a87 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `k` and `lambda`, the function returns a function whi
 
 	logpdf = factory( 2, 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `k` and `lambda`, the function returns a function whi
 
 	logpdf = factory( 2, 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `lambda <= 0`, the created function always returns `NaN`', fu
 	logpdf = factory( 0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -136,31 +136,31 @@ tape( 'if provided `k` is not a nonnegative integer, the created function always
 
 	logpdf = factory( -1.0, 0.5 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.5, 0.5 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.logpdf.js
index c273c653876c..99203a38ccf7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `k` and `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `k` and `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.js
index a6ec1254fd99..2f2dc929c212 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = mean( 1.5, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 3.9, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mean( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.native.js
index 60b62c709ffd..27a91aa421b6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,22 +65,22 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = mean( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = mean( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.factory.js
index 4eae97c7a0a4..dc83cf47ffdd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 1, 1.0 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,26 +84,26 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	mgf = factory( 2, -1.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -115,26 +115,26 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	mgf = factory( -1.0, 0.5 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, 1.0 );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, PINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NaN );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -145,9 +145,9 @@ tape( 'the created function returns `NaN` if provided `t >= lambda`', function t
 
 	mgf = factory( 1, 1.0 );
 	y = mgf( 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.mgf.js
index a84708597a69..9946c6996db3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mgf/test/test.mgf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,22 +58,22 @@ tape( 'if provided a negative `k`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mgf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,31 +82,31 @@ tape( 'if provided a negative `lambda`, the function returns `NaN`', function te
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `t >= lambda`, the function returns `NaN`', function test( t ) {
 	var y = mgf( 1.5, 1, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.8, 1, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.js
index 76153bfa08ba..983cb2a889d5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = mode( 1.5, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 3.9, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mode( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.native.js
index 419b55205fa2..387663c57b52 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,22 +65,22 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = mode( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = mode( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.factory.js
index 7b857a2953a5..47a82835f83b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `k` and `lambda`, the function returns a function whi
 
 	pdf = factory( 2, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `k` and `lambda`, the function returns a function whi
 
 	pdf = factory( 2, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `lambda <= 0`, the created function always returns `NaN`', fu
 	pdf = factory( 0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -136,31 +136,31 @@ tape( 'if provided `k` is not a nonnegative integer, the created function always
 
 	pdf = factory( -1.0, 0.5 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.5, 0.5 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.pdf.js
index e3b968ee68cf..f2b1ba4aad01 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `k` and `lambda`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `k` and `lambda`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.factory.js
index 6cfc166b5714..b71a0ca3e0de 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `k` and `lambda`, the function returns a function wh
 
 	quantile = factory( 1, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,26 +98,26 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	quantile = factory( 1, -1.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -129,26 +129,26 @@ tape( 'if provided a negative `k`, the created function always returns `NaN`', f
 	quantile = factory( -1, 0.5 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.js
index 4970731ca3ef..e41c2fded4f7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = skewness( 1.5, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 3.9, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = skewness( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.native.js
index a9465e36b2bf..afb974b61f8e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,22 +65,22 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = skewness( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = skewness( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.js
index e78a349d1d58..b3bcb23fa0ba 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = stdev( 1.5, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 3.9, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = stdev( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.native.js
index 969834997a30..637629c1955b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,22 +65,22 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = stdev( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = stdev( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.js
index 473ca01c4a61..8939c641a7a2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = variance( 1.5, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 3.9, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = variance( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.native.js
index 2645e6d0baec..d1433595db98 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,22 +65,22 @@ tape( 'if provided a `k` that is not a positive integer, the function returns `N
 	var y;
 
 	y = variance( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = variance( 2, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 8, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.cdf.js
index 8b798f30376a..7f14cebe3f42 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.cdf.js
@@ -44,21 +44,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -66,16 +66,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', functi
 	var y;
 
 	y = cdf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,13 +84,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.factory.js
index 91f536c33802..236c470fc2c7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.factory.js
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	cdf = factory( 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	cdf = factory( 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -92,16 +92,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns a function whi
 	cdf = factory( PINF );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -113,10 +113,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	cdf = factory( -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.native.js
index 46d5476c603b..3c2a2007a617 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/cdf/test/test.native.js
@@ -53,21 +53,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -75,16 +75,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', opts,
 	var y;
 
 	y = cdf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,13 +93,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', opts
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.js
index 4bb5ad05c470..44f5f8440bcc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = entropy( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.native.js
index 0986141f17cb..481578e2a065 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/entropy/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = entropy( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.js
index 630b25d64f47..05b059d36ac3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.native.js
index 47ef147838b8..7042a5fadae0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/kurtosis/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mean( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.factory.js
index 9cb875c3f71b..8f00a80bd6da 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.factory.js
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logcdf = factory( 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logcdf = factory( 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -92,16 +92,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns a function whi
 	logcdf = factory( PINF );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -113,10 +113,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	logcdf = factory( -1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.logcdf.js
index a63b42bc1819..d445b9685b1d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.logcdf.js
@@ -44,21 +44,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda`, the function returns `1`', function test( t ) {
 	var y = logcdf( PINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda`, the function returns `0`', function test( t ) {
 	var y = logcdf( NINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -66,16 +66,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', functi
 	var y;
 
 	y = logcdf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,13 +84,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = logcdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.native.js
index af99f6dedc7a..cb4b62e2ad36 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logcdf/test/test.native.js
@@ -53,21 +53,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda`, the function returns `1`', opts, function test( t ) {
 	var y = logcdf( PINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( NINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -75,16 +75,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', opts,
 	var y;
 
 	y = logcdf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,13 +93,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', opts
 	var y;
 
 	y = logcdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.factory.js
index 68e1b2a60e25..f8e3e135f293 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.factory.js
@@ -57,11 +57,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logpdf = factory( 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns a function whi
 	logpdf = factory( PINF );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -116,10 +116,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	logpdf = factory( -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.logpdf.js
index 981046a08de5..bb58d5e3d142 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.logpdf.js
@@ -47,21 +47,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -69,16 +69,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', functi
 	var y;
 
 	y = logpdf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -87,13 +87,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = logpdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.native.js
index ba729896dc3b..26f954d00bb3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/logpdf/test/test.native.js
@@ -56,21 +56,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -78,16 +78,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', opts,
 	var y;
 
 	y = logpdf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -96,13 +96,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', opts
 	var y;
 
 	y = logpdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.js
index f5e16609d272..ff933167c440 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mean( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.native.js
index fc0275d0fe60..8a506f9de125 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mean/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mean( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.js
index 06a42a4f6d80..21f0cd1ee788 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = median( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.native.js
index dd09221b85fb..2cd4d33a0167 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/median/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = median( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.factory.js
index 2f39f1de3c67..87cc3e380e34 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.factory.js
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 1.0 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,16 +72,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns a function whi
 	mgf = factory( PINF );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,18 +93,18 @@ tape( 'if provided a nonpositive `lambda`, the created function always returns `
 	mgf = factory( -1.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -115,11 +115,11 @@ tape( 'the created function returns `NaN` for `x >= lambda`', function test( t )
 
 	mgf = factory( 3.0 );
 	y = mgf( 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.1 );
 	y = mgf( 0.9 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.mgf.js
index c5f0828547c5..d75c51e0d382 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.mgf.js
@@ -46,9 +46,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -56,16 +56,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', functi
 	var y;
 
 	y = mgf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -74,19 +74,19 @@ tape( 'if provided a nonpositive `lambda`, the function always returns `NaN`', f
 	var y;
 
 	y = mgf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( -2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -95,10 +95,10 @@ tape( 'the function returns `NaN` for `x >= lambda`', function test( t ) {
 	var y;
 
 	y = mgf( 4.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.9, 0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.native.js
index c5d2ffa90377..3bc3be281c98 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mgf/test/test.native.js
@@ -55,9 +55,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -65,16 +65,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', opts,
 	var y;
 
 	y = mgf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided a nonpositive `lambda`, the function always returns `NaN`', o
 	var y;
 
 	y = mgf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( -2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,10 +104,10 @@ tape( 'the function returns `NaN` for `x >= lambda`', opts, function test( t ) {
 	var y;
 
 	y = mgf( 4.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.9, 0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.js
index 43d8eeed1a1a..be80e4583f42 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mode( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.native.js
index f117ffc25a86..2595017ce923 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/mode/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mode( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.factory.js
index cd24c4ef09bc..c0aac4b23ac5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.factory.js
@@ -57,11 +57,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	pdf = factory( 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	pdf = factory( 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns a function whi
 	pdf = factory( PINF );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -116,10 +116,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	pdf = factory( -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.native.js
index 77444971c1a3..67230ae56937 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.native.js
@@ -56,13 +56,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', opts,
 	var y;
 
 	y = pdf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,13 +88,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', opts
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.pdf.js
index b29eb2b2b917..ec1163411b7f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/pdf/test/test.pdf.js
@@ -47,21 +47,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -69,16 +69,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns `NaN`', functi
 	var y;
 
 	y = pdf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -87,13 +87,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.factory.js
index b44fd3126b90..c5424dee1224 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/quantile/test/test.factory.js
@@ -63,11 +63,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,10 +78,10 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	quantile = factory( 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,16 +93,16 @@ tape( 'if provided `+infinity` for `lambda`, the function returns a function whi
 	quantile = factory( PINF );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -114,10 +114,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	quantile = factory( -1.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.js
index 93710d69b219..b4eee30f4d2f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = skewness( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.native.js
index c1a75d0a0555..756b4862adfd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/skewness/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = skewness( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.js
index 7d3e05473693..659b83c3825b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = stdev( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.native.js
index c7d03eaf8cbf..5ae6c79cf1f1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/stdev/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = stddev( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = stddev( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stddev( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.js
index 1b5a2a75d406..de05f8cdea6d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = variance( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.native.js
index af183f6918db..da434c202f6b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/variance/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a rate parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = variance( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.cdf.js
index d3b95d66cd95..cf4479f65d0b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `d1` and `d2`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `d1` and `d2`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `d1`, the function returns `NaN`', function test(
 	var y;
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided a negative `d2`, the function returns `NaN`', function test(
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.factory.js
index 0c796959d197..732c7bf64c8e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `d1` and `d2`, the function returns a function which
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `d1` and `d2`, the function returns a function which
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,27 +106,27 @@ tape( 'if provided a nonpositive `d2`, the created function always returns `NaN`
 	cdf = factory( 0.5, 0.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.5, -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -138,27 +138,27 @@ tape( 'if provided a nonpositive `d1`, the created function always returns `NaN`
 	cdf = factory( 0.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.js
index a8814fe8d606..829d442cc06a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `d2 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.native.js
index 0e8a930f024a..aeb59b121771 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/entropy/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `d2 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.js
index d040b8a5a120..20ec61d9c1c8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,43 +77,43 @@ tape( 'if provided `d2 <= 8`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = kurtosis( 2.0, 8.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 7.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 6.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 5.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.native.js
index 543485720777..bdb410592670 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/kurtosis/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,43 +86,43 @@ tape( 'if provided `d2 <= 8`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = kurtosis( 2.0, 8.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 7.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 6.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 5.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.js
index ca4fff466880..e23ef65c8f59 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 3.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,25 +77,25 @@ tape( 'if provided `d2 <= 2`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.native.js
index eb53998a5094..ad920fae5973 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 3.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,25 +86,25 @@ tape( 'if provided `d2 <= 2`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = mean( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.js
index 5bedf21fb43b..4836f4c50653 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,25 +56,25 @@ tape( 'if provided `d1 <= 2`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mode( 2.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.5, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided `d2 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mode( 3.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 3.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.native.js
index 24ee3a8e055c..a841076a6ca9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,25 +65,25 @@ tape( 'if provided `d1 <= 2`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = mode( 2.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.5, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,19 +92,19 @@ tape( 'if provided `d2 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = mode( 3.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 3.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.factory.js
index 9cda45efb265..e059a69e929f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.factory.js
@@ -59,23 +59,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 2.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,7 +86,7 @@ tape( 'if provided a finite `d1` and `d2`, the function returns a function which
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -97,7 +97,7 @@ tape( 'if provided a finite `d1` and `d2`, the function returns a function which
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -108,11 +108,11 @@ tape( 'if provided `d1 < 2.0`, the function returns a function which returns `+I
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	pdf = factory( 1.5, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -123,11 +123,11 @@ tape( 'if provided `d1 = 2.0`, the function returns a function which returns `1.
 
 	pdf = factory( 2.0, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	pdf = factory( 2.0, 3.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -138,11 +138,11 @@ tape( 'if provided `d1 > 2.0`, the function returns a function which returns `0.
 
 	pdf = factory( 3.0, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	pdf = factory( 3.5, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -154,31 +154,31 @@ tape( 'if provided `d2 <= 0`, the created function always returns `NaN`', functi
 	pdf = factory( 1.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -190,31 +190,31 @@ tape( 'if provided `d1 <= 0`, the created function always returns `NaN`', functi
 	pdf = factory( 0.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.pdf.js
index 259bff65e8cd..638a50e197f7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/pdf/test/test.pdf.js
@@ -49,23 +49,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `d1` and `d2`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `d1` and `d2`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -73,22 +73,22 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,22 +97,22 @@ tape( 'if provided `d2 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -121,10 +121,10 @@ tape( 'if provided `d1 < 2.0`, the function returns `+Infinity` when provided `0
 	var y;
 
 	y = pdf( 0.0, 1.0, 1.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = pdf( 0.0, 1.5, 1.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -133,10 +133,10 @@ tape( 'if provided `d1 = 2.0`, the function returns `1.0` when provided `0.0` fo
 	var y;
 
 	y = pdf( 0.0, 2.0, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, 3.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -145,10 +145,10 @@ tape( 'if provided `d1 > 2.0`, the function returns `0.0` when provided `0.0` fo
 	var y;
 
 	y = pdf( 0.0, 3.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.0, 3.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.factory.js
index 6f820dee946e..179a79b5c842 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `d1` and `d2`, the function returns a function which
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,31 +98,31 @@ tape( 'if provided a nonpositive `d2`, the created function always returns `NaN`
 	quantile = factory( 1.0, 0.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -134,31 +134,31 @@ tape( 'if provided a nonpositive `d1`, the created function always returns `NaN`
 	quantile = factory( 0.0, 0.5 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.js
index b072bcacdcdc..636483594ea2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,37 +77,37 @@ tape( 'if provided `d2 <= 6`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = skewness( 2.0, 6.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 5.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.native.js
index dd00f6018d65..c440b6eba513 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,37 +86,37 @@ tape( 'if provided `d2 <= 6`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = skewness( 2.0, 6.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 5.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.js
index c87b84ac3619..a473e489e2c9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,31 +77,31 @@ tape( 'if provided `d2 <= 4`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = stdev( 2.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.native.js
index 5b4cfcf85e27..714f33c45621 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,31 +86,31 @@ tape( 'if provided `d2 <= 4`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = stdev( 2.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.js
index 7703b799d0af..4a359492eaad 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,31 +77,31 @@ tape( 'if provided `d2 <= 4`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = variance( 2.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.native.js
index 7a320e2f5883..eeb280d692af 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `d1 <= 0`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,31 +86,31 @@ tape( 'if provided `d2 <= 4`, the function returns `NaN`', opts, function test(
 	var y;
 
 	y = variance( 2.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.cdf.js
index 60a484e36061..0232b3c75572 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.cdf.js
@@ -46,34 +46,34 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 1.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `alpha` and `s`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 1.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, 1.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -82,25 +82,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,25 +109,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.factory.js
index 9068e3b1aa17..f292a9b013a5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.factory.js
@@ -56,27 +56,27 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0, 0.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0, 0.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN, 0.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN, 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'if provided a finite `alpha` and `s`, the function returns a function whi
 
 	cdf = factory( 1.0, 1.0, 0.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -98,19 +98,19 @@ tape( 'if provided a finite `alpha` and `s`, the function returns a function whi
 
 	cdf = factory( 1.0, 1.0, 2.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 2.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -122,30 +122,30 @@ tape( 'if provided a nonpositive `s`, the created function always returns `NaN`'
 	cdf = factory( 1.0, -1.0, 1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, 0.0, 1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF, NaN );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.native.js
index 836be4565649..0ce41c4caf9b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/cdf/test/test.native.js
@@ -55,34 +55,34 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 1.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `alpha` and `s`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 1.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, 1.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -91,25 +91,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = cdf( 2.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,25 +118,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.js
index 30d1a46b4594..b9504e6ed66e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = entropy( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = entropy( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.native.js
index 90c6782a2b69..1c653fd06c0f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/entropy/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = entropy( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = entropy( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.js
index 8c874997dfb6..af1fe9f56822 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = kurtosis( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = kurtosis( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = kurtosis( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.native.js
index 3a80d773a3f7..e48ff396a211 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/kurtosis/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = kurtosis( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = kurtosis( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.factory.js
index 532dc3f81fbe..def4a675bf35 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.factory.js
@@ -56,27 +56,27 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0, 1.0, 0.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0, 0.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN, 0.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN, 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -87,7 +87,7 @@ tape( 'if provided a finite `alpha` and `s`, the function returns a function whi
 
 	logcdf = factory( 1.0, 1.0, 0.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -98,19 +98,19 @@ tape( 'if provided a finite `alpha` and `s`, the function returns a function whi
 
 	logcdf = factory( 1.0, 1.0, 2.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -122,30 +122,30 @@ tape( 'if provided a nonpositive `s`, the created function always returns `NaN`'
 	logcdf = factory( 1.0, -1.0, 1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, 0.0, 1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NINF, 1.0 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF, 1.0 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF, NaN );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.logcdf.js
index 8de286976f87..c4e90a993351 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.logcdf.js
@@ -46,34 +46,34 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 1.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `alpha` and `s`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `0`', function test( t ) {
 	var y = logcdf( NINF, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 1.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, 1.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -82,25 +82,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = logcdf( 2.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, PINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,25 +109,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.native.js
index 0d712fe1589f..8970b2bdcaa1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logcdf/test/test.native.js
@@ -55,34 +55,34 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 1.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `alpha` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( NINF, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 1.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, 1.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -91,25 +91,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = logcdf( 2.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, PINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,25 +118,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.factory.js
index 325cb5856664..05832a9769cd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.factory.js
@@ -56,27 +56,27 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0, 1.0, 0.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0, 0.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN, 0.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN, 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -87,19 +87,19 @@ tape( 'if provided a finite `alpha` and `s`, the function returns a function whi
 
 	logpdf = factory( 1.0, 1.0, 2.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -111,30 +111,30 @@ tape( 'if provided a nonpositive `s`, the created function always returns `NaN`'
 	logpdf = factory( 1.0, -1.0, 1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, 0.0, 1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF, NaN );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.logpdf.js
index a8b7a1873d9c..7690b462efcf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.logpdf.js
@@ -46,28 +46,28 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 0.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 1.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, 1.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -76,25 +76,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = logpdf( 2.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -103,25 +103,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.native.js
index e09c47b11890..e3ac38ff7032 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/logpdf/test/test.native.js
@@ -55,28 +55,28 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 0.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 1.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, 1.0, 3.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -85,25 +85,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = logpdf( 2.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -112,25 +112,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.js
index 9fb75c9f6e63..c5a9cfd98520 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = mean( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = mean( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.native.js
index 06b2d20df5f4..4e1f0939c967 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/mean/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mean( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mean( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.js
index c01047b7fcfa..fdf3f0cb1953 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = median( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = median( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.native.js
index cc1ce2a5c58f..82fec7362784 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/median/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = median( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = median( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.js
index adee00d6d653..b2ea2c4352c3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = mode( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = mode( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.native.js
index 12cc7b242ab7..45259f38433d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/mode/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mode( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mode( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.factory.js
index 444e8dd43396..98b0d1a6df20 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.factory.js
@@ -56,27 +56,27 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0, 1.0, 0.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0, 0.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN, 0.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN, 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -87,19 +87,19 @@ tape( 'if provided a finite `alpha` and `s`, the function returns a function whi
 
 	pdf = factory( 1.0, 1.0, 2.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 2.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -111,30 +111,30 @@ tape( 'if provided a nonpositive `s`, the created function always returns `NaN`'
 	pdf = factory( 1.0, -1.0, 1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, 0.0, 1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF, NaN );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.pdf.js
index 6462afd876fe..485f62ea87cc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/pdf/test/test.pdf.js
@@ -46,28 +46,28 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `x <= m` and a valid `alpha` and `s`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 1.0, 1.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, 1.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -76,25 +76,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = pdf( 2.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -103,25 +103,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.factory.js
index 425104fb0bfb..7e05a1a7f554 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.factory.js
@@ -56,27 +56,27 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0, 1.0, 0.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0, 0.0 );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN, 0.0 );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN, 1.0, NaN );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN, NaN );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,30 +88,30 @@ tape( 'if provided a nonpositive `s`, the created function always returns `NaN`'
 	quantile = factory( 1.0, -1.0, 1.0 );
 
 	y = quantile( 0.6 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, 0.0, 1.0 );
 
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NINF, 1.0 );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF, 1.0 );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF, NaN );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.native.js
index 83b895295304..df0fc3460da1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/quantile/test/test.native.js
@@ -55,13 +55,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.5, NaN, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.5, 1.0, NaN, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.5, 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -69,10 +69,10 @@ tape( 'if provided `p < 0` or `p > 1`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = quantile( -0.1, 1.0, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1, 1.0, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,25 +81,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = quantile( 0.5, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, -1.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 0.0, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, PINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NINF, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -108,25 +108,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = quantile( 0.5, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2, 2.0, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 1.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, PINF, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, NaN, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.js
index ba4c7d38c12a..d3e742457607 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = skewness( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = skewness( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = skewness( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.native.js
index 5d9230d3989c..138b288c2dbd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/skewness/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = skewness( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = skewness( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.js
index 2aa39b36f9c4..1c52d06d2c84 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = stdev( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = stdev( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.native.js
index 96e7e809adb3..e5c8dfd5ed87 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/stdev/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = stdev( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = stdev( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.js
index f60d6f535627..0ed1ddc5171b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.js
@@ -44,11 +44,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -56,22 +56,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = variance( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,22 +80,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = variance( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.native.js
index d560dabd43d9..fc5385a99e63 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/variance/test/test.native.js
@@ -53,11 +53,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -65,22 +65,22 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = variance( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( -1.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,22 +89,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = variance( 2.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.cdf.js
index c3f68d7b43c7..fa3c0dd0f2f1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `alpha`, the function returns `NaN`', function tes
 	var y;
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,25 +94,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -136,7 +136,7 @@ tape( 'if provided an `alpha` equal to `0` and `beta` is positive, the function
 	t.strictEqual( y, 0.0, 'returns  0 for x smaller than 0' );
 
 	y = cdf( NaN, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.factory.js
index e03b4c6bbc0e..4ef7daaa761b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositiveeta`, the created function always returns `NaN`'
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -145,26 +145,26 @@ tape( 'if provided a negative `alpha`, the created function always returns `NaN`
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -191,7 +191,7 @@ tape( 'if `alpha` equals `0` and `beta` is positive, the created function evalua
 	t.strictEqual( y, 0.0, 'returns 0 for x smaller than one' );
 
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.native.js
index 7e79be71ef9a..b308101e7d3e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/cdf/test/test.native.js
@@ -57,13 +57,13 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = cdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,22 +72,22 @@ tape( 'if provided a negative `alpha`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -96,25 +96,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.js
index 85008afeef11..a22825fbd1a6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.js
@@ -43,10 +43,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -55,19 +55,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,19 +76,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.native.js
index b40692e9b5b1..ca448ff486cf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/entropy/test/test.native.js
@@ -52,10 +52,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -64,19 +64,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -85,19 +85,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.js
index b117b2a9bd49..b8ad09358df9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.native.js
index 3a8ef18e9baa..0595cb65f5d6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/kurtosis/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.factory.js
index a5efb6f9c47b..3ace228fd751 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logcdf/test/test.factory.js
@@ -51,23 +51,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,7 +78,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -89,7 +89,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -101,34 +101,34 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	logcdf = factory( 2.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 2.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 2.0, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -140,26 +140,26 @@ tape( 'if provided `alpha < 0`, the created function always returns `NaN`', func
 	logcdf = factory( -1.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, 1.0 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, PINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NaN );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -186,7 +186,7 @@ tape( 'if `alpha` equals `0`, the created function evaluates a degenerate distri
 	t.strictEqual( y, NINF, 'returns -Infinity for x smaller than 0' );
 
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.factory.js
index 2787c714575c..85df77486e40 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	logpdf = factory( 2.0, 0.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 2.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 2.0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -145,26 +145,26 @@ tape( 'if provided `alpha < 0`, the created function always returns `NaN`', func
 	logpdf = factory( -1.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -176,22 +176,22 @@ tape( 'if `alpha` equals `0`, the created function evaluates a degenerate distri
 	logpdf = factory( 0.0, 2.0 );
 
 	y = logpdf( -2.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 0.0 );
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = logpdf( 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.logpdf.js
index 61eb7adb381a..669fe0c87b9a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided `alpha < 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,25 +94,25 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -124,19 +124,19 @@ tape( 'if `alpha` equals `0`, the function evaluates a degenerate distribution c
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = logpdf( 1.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -1.5, 0.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF, 0.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF, 0.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.native.js
index 56c9e3e6c7b7..bde540f07e6f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided `alpha < 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -103,25 +103,25 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -133,19 +133,19 @@ tape( 'if `alpha` equals `0`, the function evaluates a degenerate distribution c
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = logpdf( 1.0, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -1.5, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.js
index 1239c552c125..87891d08e64e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.native.js
index a2a8c5e9c8f1..79193d4d8943 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.factory.js
index d0005ba7d6e6..b31edb8afbe1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0, 1.0 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,26 +84,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	mgf = factory( 0.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -115,26 +115,26 @@ tape( 'if provided `alpha < 0`, the created function always returns `NaN`', func
 	mgf = factory( -1.0, 0.5 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, 1.0 );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, PINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NaN );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.mgf.js
index 39e77da04fb4..6d6d0286138a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.mgf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,22 +58,22 @@ tape( 'if provided a negative `alpha`, the function returns `NaN`', function tes
 	var y;
 
 	y = mgf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,22 +82,22 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.native.js
index f3182b82a54a..04624a430e24 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mgf/test/test.native.js
@@ -55,11 +55,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -67,22 +67,22 @@ tape( 'if provided a negative `alpha`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = mgf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -91,22 +91,22 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.js
index a926fa2284ac..3a1674642492 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.native.js
index 4809c53980af..1515a6dee723 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.factory.js
index efe17e9c984f..1aca1791ba0f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	pdf = factory( 2.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 2.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 2.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -145,26 +145,26 @@ tape( 'if provided `alpha < 0`, the created function always returns `NaN`', func
 	pdf = factory( -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -176,22 +176,22 @@ tape( 'if `alpha` equals `0`, the created function evaluates a degenerate distri
 	pdf = factory( 0.0, 2.0 );
 
 	y = pdf( -2.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.0 );
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.native.js
index f4caa4481a47..20d5fec7d58e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided `alpha < 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -103,25 +103,25 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -133,19 +133,19 @@ tape( 'if `alpha` equals `0`, the function evaluates a degenerate distribution c
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 1.0, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -1.5, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 0.0, 1.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 0.0, 1.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN, 0.0, 1, 5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.pdf.js
index 55e48d0b7852..6a0c78e903d5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided `alpha < 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,25 +94,25 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -124,19 +124,19 @@ tape( 'if `alpha` equals `0`, the function evaluates a degenerate distribution c
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 1.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -1.5, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.factory.js
index 2e98ac4fb888..995690fdd788 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,34 +98,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	quantile = factory( 2.0, 0.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 2.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 2.0, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -137,26 +137,26 @@ tape( 'if provided a negative `alpha`, the created function always returns `NaN`
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.js
index 7e5a780c7060..5a6424c57ba5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.native.js
index 630dccff9019..36ee34e99f61 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.js
index e74adbf921a5..9a3993f1fa55 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.native.js
index 8c50705b5081..7099fb6da4bb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.js
index 92fd8702d450..df84d7c34a14 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.native.js
index b72c6c20548e..4e681760799d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.cdf.js
index 8b66c86dda45..89b201814d86 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.cdf.js
@@ -45,27 +45,27 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 4.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -4.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -0.5, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -74,16 +74,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = cdf( 3.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 3.0, -0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 3.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.factory.js
index 8537e44e8446..6354ef53e64b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.factory.js
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.5 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a valid `p`, the function returns a function which returns `1
 
 	cdf = factory( 0.5 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -81,16 +81,16 @@ tape( 'if provided a valid `p`, the function returns a function which returns `0
 
 	cdf = factory( 0.5 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -20.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -2.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -101,21 +101,21 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the created fun
 
 	cdf = factory( -1.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.5 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.native.js
index 750ec77fc617..05da616f54b3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/cdf/test/test.native.js
@@ -54,27 +54,27 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 4.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -4.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -0.5, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -83,16 +83,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = cdf( 3.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 3.0, -0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 3.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.js
index 6eacfa513c5c..ba96b3053011 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = entropy( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.native.js
index c3772c5fe0c3..52934faffa1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/entropy/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var k = entropy( NaN );
-	t.strictEqual( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var k;
 
 	k = entropy( -1.0 );
-	t.strictEqual( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns expected value' );
 
 	k = entropy( 1.5 );
-	t.strictEqual( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns expected value' );
 
 	k = entropy( NINF );
-	t.strictEqual( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns expected value' );
 
 	k = entropy( PINF );
-	t.strictEqual( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.js
index b47383564c57..9776289c051f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.native.js
index a828220f997b..acfc29bfd8ba 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/kurtosis/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var k = kurtosis( NaN );
-	t.strictEqual( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var k;
 
 	k = kurtosis( -1.0 );
-	t.strictEqual( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns expected value' );
 
 	k = kurtosis( 1.5 );
-	t.strictEqual( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns expected value' );
 
 	k = kurtosis( NINF );
-	t.strictEqual( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns expected value' );
 
 	k = kurtosis( PINF );
-	t.strictEqual( isnan( k ), true, 'returns NaN' );
+	t.strictEqual( isnan( k ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.factory.js
index e562b39674f5..4bb138f34a3a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.factory.js
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.5 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a valid `p`, the function returns a function which returns `0
 
 	logcdf = factory( 0.5 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -81,15 +81,15 @@ tape( 'if provided a valid `p`, the function returns a function which returns `-
 
 	logcdf = factory( 0.5 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -20.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -2.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	y = logcdf( -0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -100,21 +100,21 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the created fun
 
 	logcdf = factory( -1.0 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.5 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.logcdf.js
index 838cb6fb2d06..2923e9423d34 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.logcdf.js
@@ -45,27 +45,27 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 4.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -4.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -0.5, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -74,16 +74,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = logcdf( 3.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 3.0, -0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 3.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.native.js
index 5394609ed739..694ea7290881 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logcdf/test/test.native.js
@@ -54,27 +54,27 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 4.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `p`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -4.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -0.5, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -83,16 +83,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = logcdf( 3.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 3.0, -0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 3.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.factory.js
index e01e4c1bf28d..59bcf70ae5a0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.factory.js
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpmf = factory( 0.5 );
 	y = logpmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN );
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	logpmf = factory( 1.0 );
 	y = logpmf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -81,10 +81,10 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	logpmf = factory( 0.4 );
 	y = logpmf( -4.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -95,19 +95,19 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	logpmf = factory( 0.4 );
 	y = logpmf( 1.3 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 1.4 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 3.2 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 4.8 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.2 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -119,18 +119,18 @@ tape( 'if provided a `p` outside of `[0,1]`, the created function always returns
 	logpmf = factory( -1.5 );
 
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 1.2 );
 
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.logpmf.js
index d61a8a3e2cd2..5018360789d8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.logpmf.js
@@ -45,40 +45,40 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpmf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( PINF, 0.01 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( -20.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -4.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( -1.3, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 2.4, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 0.5, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -87,10 +87,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function al
 	var y;
 
 	y = logpmf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.native.js
index e7876ad71241..e2b4595b97ae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/logpmf/test/test.native.js
@@ -54,40 +54,40 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpmf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( PINF, 0.01 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `p`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( -20.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -4.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `p`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( -1.3, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 2.4, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 0.5, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -96,10 +96,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function al
 	var y;
 
 	y = logpmf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.js
index 75752cc8cf8d..40ff1024b38a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mean( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.native.js
index 98d222423bec..c6167fc84ce4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mean/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var m = mean( NaN );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var m;
 
 	m = mean( -1.0 );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	m = mean( 1.5 );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	m = mean( NINF );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	m = mean( PINF );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.js
index 9848114d410f..7fc32af956b8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,16 +50,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = median( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.native.js
index 86653839c24e..39dae76bf863 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/median/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var m = median( NaN );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var m;
 
 	m = median( -1.0 );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	m = median( 1.5 );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	m = median( NINF );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	m = median( PINF );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.factory.js
index 031a169df58b..841b2fcacf8f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.factory.js
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.5 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,27 +70,27 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the created fun
 
 	mgf = factory( -1.0 );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.5 );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.mgf.js
index 82953e99c5d1..3e2c65959917 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.mgf.js
@@ -45,9 +45,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 4.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -55,16 +55,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = mgf( 3.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 3.0, -0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 3.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.native.js
index 8f0106a9a2fd..7a7f06bb779b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mgf/test/test.native.js
@@ -54,9 +54,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 4.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -64,16 +64,16 @@ tape( 'if provided a value outside `[0,1]` for success probability `p`, the func
 	var y;
 
 	y = mgf( 3.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 3.0, -0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 3.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.js
index 2d6b9730adfb..eb6ecd4b844e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,16 +50,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mode( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.native.js
index 79078bc48aa4..0e6a912717cd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/mode/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var m = mode( NaN );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,16 +59,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var m;
 
 	m = mode( -1.0 );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	m = mode( 1.5 );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	m = mode( NINF );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	m = mode( PINF );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.factory.js
index 9fc43dc70666..5222a8a52f65 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.factory.js
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 0.5 );
 	y = pmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN );
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	pmf = factory( 1.0 );
 	y = pmf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -80,10 +80,10 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	pmf = factory( 0.4 );
 	y = pmf( -4.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,19 +94,19 @@ tape( 'if provided a finite `p`, the function returns a function which returns `
 
 	pmf = factory( 0.4 );
 	y = pmf( 1.3 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 1.4 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 3.2 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 4.8 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.2 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -118,18 +118,18 @@ tape( 'if provided a `p` outside of `[0,1]`, the created function always returns
 	pmf = factory( -1.5 );
 
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 1.2 );
 
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.native.js
index 40a056bc237c..f077aa8010d0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.native.js
@@ -53,40 +53,40 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pmf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( PINF, 0.01 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( -20.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -4.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `p`, the function returns `0`', opts, function test( t ) {
 	var y = pmf( -1.3, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 2.4, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 0.5, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -95,10 +95,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function al
 	var y;
 
 	y = pmf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.pmf.js
index 3b838aaca1cd..ad4ee76c63f2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/pmf/test/test.pmf.js
@@ -44,40 +44,40 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = pmf( PINF, 0.01 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = pmf( -20.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -4.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `p`, the function returns `0`', function test( t ) {
 	var y = pmf( -1.3, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 2.4, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 0.5, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -86,10 +86,10 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function al
 	var y;
 
 	y = pmf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.factory.js
index e137afa4e493..a8916518efac 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.factory.js
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,10 +69,10 @@ tape( 'if provided a valid success probability `p`, the function returns a funct
 
 	quantile = factory( 0.8 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid success probability `p`, the function returns a funct
 
 	quantile = factory( 0.5 );
 	y = quantile( 1.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -95,18 +95,18 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the created functi
 	quantile = factory( -1.0 );
 
 	y = quantile( 0.4 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.5 );
 
 	y = quantile( 0.4 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.js
index 02d792195da2..7e67da254c37 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = skewness( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.native.js
index 2dc32a4d2de8..0d7917384541 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/skewness/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var s = skewness( NaN );
-	t.strictEqual( isnan( s ), true, 'returns NaN' );
+	t.strictEqual( isnan( s ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var s;
 
 	s = skewness( -1.0 );
-	t.strictEqual( isnan( s ), true, 'returns NaN' );
+	t.strictEqual( isnan( s ), true, 'returns expected value' );
 
 	s = skewness( 1.5 );
-	t.strictEqual( isnan( s ), true, 'returns NaN' );
+	t.strictEqual( isnan( s ), true, 'returns expected value' );
 
 	s = skewness( NINF );
-	t.strictEqual( isnan( s ), true, 'returns NaN' );
+	t.strictEqual( isnan( s ), true, 'returns expected value' );
 
 	s = skewness( PINF );
-	t.strictEqual( isnan( s ), true, 'returns NaN' );
+	t.strictEqual( isnan( s ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.js
index c00dfd6203ae..67949a8f4e65 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = stdev( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.native.js
index 1f4d0d6c56aa..4ffa0235a0c4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/stdev/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var m = stdev( NaN );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var m;
 
 	m = stdev( -1.0 );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	m = stdev( 1.5 );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	m = stdev( NINF );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	m = stdev( PINF );
-	t.strictEqual( isnan( m ), true, 'returns NaN' );
+	t.strictEqual( isnan( m ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.js
index d470f0463f9a..862d915a5b0d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.js
@@ -44,7 +44,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,16 +52,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = variance( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.native.js
index 808effcb25de..a5d99c3cebdf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/variance/test/test.native.js
@@ -53,7 +53,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = variance( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.cdf.js
index 3f8b48027495..8707d360438d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,28 +70,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.factory.js
index 50d0979c0919..463c4ce31d9c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.native.js
index b7855152594b..7fdacec86ac0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,28 +79,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.js
index 5db72c04ddaf..d1eeca1a476c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.native.js
index 47dd05805527..794173a44528 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/entropy/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.js
index b53a8f9fe057..cce1317e8068 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.native.js
index 434051e34747..e71b3d4f20fe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/kurtosis/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.factory.js
index 1971ad9ce9ed..fa07e4d7ec42 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	logcdf = factory( 0.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.logcdf.js
index 61d73a5902cf..f05e8a9d184f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `1`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,28 +70,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.native.js
index 2e65ec9c9d41..27fd3409c06e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logcdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `1`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,28 +79,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.factory.js
index 0cb59f5f5bf7..4e5d45cffc6d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, 0.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.logpdf.js
index 32e07cebc5cd..4256506c1acb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,28 +70,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.native.js
index 6ed2ea5d389f..16da6b4d99ba 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,28 +79,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.js
index 4fea9bb7bfa0..5e88c7e94e9e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.native.js
index ab7e53b94c8e..7f01dfe7b609 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mean/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.js
index 64f32769fbff..96b132bf1856 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.native.js
index 67a22cac885d..682be826b228 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/median/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,22 +63,22 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.factory.js
index a2f56e0cf441..f28b99676d28 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mgf/test/test.factory.js
@@ -49,23 +49,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 20, 0.5 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 0.5 );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 20, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,7 +79,7 @@ tape( 'the created function returns `NaN` for `x >= 1/beta`', function test( t )
 
 	for ( i = 1; i < 10; i++ ) {
 		y = mgf( i/2.0 );
-		t.strictEqual( isnan( y ), true, 'returns NaN' );
+		t.strictEqual( isnan( y ), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -91,34 +91,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	mgf = factory( 0.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, 0.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.js
index 087bcc9d6c53..2937485f83b9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.native.js
index 02010dbd2cdd..e042d676be92 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/mode/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.factory.js
index 2208cb1b8fcc..f1630478738b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.native.js
index 39becd8d9ac7..d455279cb717 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,28 +79,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.pdf.js
index 1d18b787e448..a4a4b125aeb3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,28 +70,28 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.factory.js
index 208937c97885..5dee12fa987d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `mu` and `beta`, the function returns a function whi
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,34 +98,34 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, 0.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.js
index 5d0213917431..91836e9bdd93 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.js
@@ -38,9 +38,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -48,25 +48,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.native.js
index 58084823d2b2..3c27d3259ad3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/skewness/test/test.native.js
@@ -47,9 +47,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,25 +57,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.js
index 7d33f9fb15ae..3474461f9c75 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.native.js
index 6c337f135592..211455c868c3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/stdev/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.js
index c20d7457a28b..0b3d618a55f6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.native.js
index b37b0563c2f3..656fe9416321 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/variance/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.cdf.js
index fd37885c23a7..de35b27d57fd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.cdf.js
@@ -44,41 +44,41 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 10, 10, 5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 10, 5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 10, NaN, 5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 10, 10, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a `x` greater equal to `min( n, K )`, the function returns `1` (provided all parameters are valid)', function test( t ) {
 	var y = cdf( PINF, 20, 20, 10 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 11, 20, 20, 10 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 10, 20, 20, 10 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 100, 20, 20, 10 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number for `x` smaller than `max( 0, n + K - N )`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 20, 20, 10 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0, 20, 20, 10 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 9.0, 20, 10, 20 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -87,19 +87,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = cdf( 2.0, 30.5, 20, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -2, 20, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1, 20, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 20.5, 20, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, PINF, 20, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -108,19 +108,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = cdf( 2.0, 20, 3.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 20, -2, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 20, -1, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 20, 2.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 20, PINF, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -129,19 +129,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = cdf( 2.0, 40, 20, 3.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 40, 20, -2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 40, 20, -1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 40, 20, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 40, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.factory.js
index 0119e4e5edb7..094dd633abd5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/cdf/test/test.factory.js
@@ -54,35 +54,35 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 40, 20, 10 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 20, 10 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 40, NaN, 10 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 30, 20, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN, 10 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 20, NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 20, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -93,23 +93,23 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	cdf = factory( 40, 20, 10 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 200.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 20.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 10.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	cdf = factory( 25, 5, 10 );
 	y = cdf( 5.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 10.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -120,19 +120,19 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	cdf = factory( 30, 20, 15 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -10.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -4.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 4.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -144,22 +144,22 @@ tape( 'if provided an `N` which is not a nonnegative integer, the created functi
 	cdf = factory( 40.5, 20, 10 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -10, 20, 10 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, 20, 10 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, 20, 10 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -171,22 +171,22 @@ tape( 'if provided a `K` which is not a nonnegative integer, the created functio
 	cdf = factory( 40, 20.5, 10 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 40, -10, 10 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 40, PINF, 10 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 40, NINF, 10 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -198,22 +198,22 @@ tape( 'if provided an `n` which is not a nonnegative integer, the created functi
 	cdf = factory( 40, 20, 10.5 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 40, 20, -10 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 40, 10, PINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 40, 10, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/kurtosis/test/test.js
index 8d98e3d68d84..3498425dc416 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/kurtosis/test/test.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 10, 4 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, NaN, 4 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -58,19 +58,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = kurtosis( 10.5, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( -2, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( -1, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20.5, 10, 5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( PINF, 10, 5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,19 +79,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = kurtosis( 20, 3.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 20, -2, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 20, -1, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 20, 2.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 20, PINF, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -100,19 +100,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = kurtosis( 40, 20, 3.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 40, 20, -2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 40, 20, -1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 40, 20, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 40, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.js
index e4497b8dd060..570fb518ff27 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 10, 4 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 20, NaN, 4 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 20, 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -58,19 +58,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = mean( 10.5, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( -2, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( -1, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 20.5, 10, 5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( PINF, 10, 5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,19 +79,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mean( 20, 3.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 20, -2, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 20, -1, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 20, 2.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 20, PINF, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -100,19 +100,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mean( 40, 20, 3.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 40, 20, -2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 40, 20, -1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 40, 20, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 40, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.native.js
index 59252e161c8e..7c5c23db5e65 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = mean( -2, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( -1, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mean( 20, -2, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 20, -1, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mean( 40, 20, -2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 40, 20, -1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.js
index d7df77cce7e5..dd661ac6ff4a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 10, 4 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 20, NaN, 4 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 20, 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -58,19 +58,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = mode( 10.5, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -2, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -1, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 20.5, 10, 5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( PINF, 10, 5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,19 +79,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mode( 20, 3.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 20, -2, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 20, -1, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 20, 2.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 20, PINF, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -100,19 +100,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mode( 40, 20, 3.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 40, 20, -2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 40, 20, -1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 40, 20, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 40, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.native.js
index 8ed32d875b9f..809fbd21a5c4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = mode( -2, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -1, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mode( 20, -2, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 20, -1, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = mode( 40, 20, -2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 40, 20, -1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.factory.js
index 2a5535d963b6..3ac58379e326 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.factory.js
@@ -52,39 +52,39 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 8, 4, 2 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 4, 2 );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 8, NaN, 2 );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 8, 4, NaN );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 8, NaN, NaN );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 4, NaN );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN, 2 );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN, NaN );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -95,10 +95,10 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	quantile = factory( 6, 4, 2 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,23 +110,23 @@ tape( 'if provided an `N` which is not a nonnegative integer, the created functi
 	quantile = factory( 20.5, 4, 2 );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( -1.0, 4, 2 );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, 4, 2 );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, 4, 2 );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -137,21 +137,21 @@ tape( 'if provided a `K` which is not a nonnegative integer, the created functio
 
 	quantile = factory( 40, 20.5, 2 );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 40, -1.0, 2 );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 40, NINF, 2 );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 40, PINF, 2 );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -162,21 +162,21 @@ tape( 'if provided an `n` which is not a nonnegative integer, the created functi
 
 	quantile = factory( 20, 10, 2.5 );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 4, 2, -1.0 );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 4, 2, NINF );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 4, 2, PINF );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -187,7 +187,7 @@ tape( 'given valid parameters, the created function returns `max( 0, n + K - N )
 
 	quantile = factory( 20, 10, 5 );
 	y = quantile( 0.0 );
-	t.strictEqual( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	quantile = factory( 20, 10, 15 );
 	y = quantile( 0.0 );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.js
index 487180832f1c..7d9914dc0658 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 10, 4 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, NaN, 4 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -58,19 +58,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = skewness( 10.5, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( -2, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( -1, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20.5, 10, 5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( PINF, 10, 5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,19 +79,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = skewness( 20, 3.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 20, -2, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 20, -1, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 20, 2.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 20, PINF, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -100,19 +100,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = skewness( 40, 20, 3.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 40, 20, -2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 40, 20, -1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 40, 20, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 40, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.native.js
index 67a560d4ffea..768d40895fd5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = skewness( -2, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( -1, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = skewness( 20, -2, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 20, -1, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = skewness( 40, 20, -2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 40, 20, -1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.js
index 5c1249d9b172..ad75f5933813 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 10, 4 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, NaN, 4 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -58,19 +58,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = stdev( 10.5, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( -2, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( -1, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20.5, 10, 5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( PINF, 10, 5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,19 +79,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = stdev( 20, 3.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 20, -2, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 20, -1, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 20, 2.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 20, PINF, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -100,19 +100,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = stdev( 40, 20, 3.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 40, 20, -2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 40, 20, -1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 40, 20, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 40, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.native.js
index 6e2a029d87b8..ce77bfbf19b2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = stdev( -2, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( -1, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = stdev( 20, -2, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 20, -1, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = stdev( 40, 20, -2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 40, 20, -1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.js
index 94f46fb7e4c7..bfdf1fe386ba 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.js
@@ -43,13 +43,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 10, 4 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 20, NaN, 4 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 20, 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -58,19 +58,19 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = variance( 10.5, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( -2, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( -1, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 20.5, 10, 5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( PINF, 10, 5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,19 +79,19 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = variance( 20, 3.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 20, -2, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 20, -1, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 20, 2.5, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 20, PINF, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -100,19 +100,19 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = variance( 40, 20, 3.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 40, 20, -2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 40, 20, -1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 40, 20, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 40, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.native.js
index 5ea34b6e2bad..b4a3375fd6ee 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'if provided an `N` which is not a nonnegative integer, the function retur
 	var v;
 
 	v = variance( -2, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( -1, 4, 2 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'if provided an `K` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = variance( 20, -2, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 20, -1, 10 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,10 +77,10 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 	var y;
 
 	y = variance( 40, 20, -2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 40, 20, -1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.cdf.js
index 9f08c9e20a53..8ca914428bd4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,16 +88,16 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.factory.js
index 9e289c166e10..8d70032cbb58 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `beta`, the created function always returns `NaN`'
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -137,26 +137,26 @@ tape( 'if provided a negative `alpha`, the created function always returns `NaN`
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.native.js
index 8552ea796b4d..1f146435a2e9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/cdf/test/test.native.js
@@ -56,26 +56,26 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = cdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -83,16 +83,16 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -101,16 +101,16 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.js
index aec5d008b42d..b8764411d5e9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.js
@@ -43,10 +43,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -55,19 +55,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,19 +76,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.native.js
index 5fc172d5ca4b..0bdebbfa2cbd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/entropy/test/test.native.js
@@ -52,10 +52,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -64,19 +64,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -85,19 +85,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.js
index 7c0e10d4cbaa..cb3bdb3a1512 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided `alpha <= 4`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( 4.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.native.js
index b37044e9238f..e628e6031c3d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/kurtosis/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,28 +65,28 @@ tape( 'if provided `alpha <= 4`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = kurtosis( 4.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -95,19 +95,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.factory.js
index 165e659f50f9..151d07edeb4f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -137,26 +137,26 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 	logpdf = factory( -1.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.logpdf.js
index 576fac256a70..46699dc1c59a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `alpha` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `alpha` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.nativs.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.nativs.js
index e3f004f89405..c8d89de06ea2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.nativs.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/logpdf/test/test.nativs.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `alpha` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `alpha` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -103,22 +103,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.js
index c33e82391580..e2faede36b33 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.native.js
index b96a6902c142..6db0aad8c6e7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.js
index 6daa24914c0d..0b98b86df25f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.native.js
index e9b36a54802f..9acd9d9a3c7c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.factory.js
index 35f919bf27fa..ae0780777cdb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -137,26 +137,26 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 	pdf = factory( -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.native.js
index 423ccc02e31f..2f236a2357a9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -103,22 +103,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.pdf.js
index ea37f41731b9..cdf3b7bd3372 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.factory.js
index 3253e9caf32e..e5ed29c2dfbc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,26 +98,26 @@ tape( 'if provided a negative `beta`, the created function always returns `NaN`'
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -129,26 +129,26 @@ tape( 'if provided a negative `alpha`, the created function always returns `NaN`
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.js
index 7e5a780c7060..5a6424c57ba5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.native.js
index 22c34c43184c..b30695cbbe37 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.js
index abcc7f5ec973..1db6ca5f0e52 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,25 +56,25 @@ tape( 'if provided `alpha <= 2`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.native.js
index 88719f87fd19..2379f4288f59 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,25 +65,25 @@ tape( 'if provided `alpha <= 2`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = stdev( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,19 +92,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.js
index c5a41a87eff1..cbb1e9c250cf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,25 +56,25 @@ tape( 'if provided `alpha <= 2`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.native.js
index 3bfc6a15d585..7fa0fd64a265 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,25 +65,25 @@ tape( 'if provided `alpha <= 2`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = variance( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,19 +92,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.factory.js
index 9cabe854a4a0..388d614c3e0f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.factory.js
@@ -50,23 +50,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,16 +77,16 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 100.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 10.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -97,19 +97,19 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -100.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -10.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -121,31 +121,31 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	cdf = factory( 1.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -157,31 +157,31 @@ tape( 'if provided a nonpositive `a`, the created function always returns `NaN`'
 	cdf = factory( 0.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.factory.js
index 93c1358ee9e1..29910a003d05 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.factory.js
@@ -50,23 +50,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0, 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,16 +77,16 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 100.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 10.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -97,19 +97,19 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -100.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -10.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -121,31 +121,31 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	logcdf = factory( 1.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -157,31 +157,31 @@ tape( 'if provided a nonpositive `a`, the created function always returns `NaN`'
 	logcdf = factory( 0.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -1.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, 1.0 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, PINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NaN );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.factory.js
index d07b5f7bdf53..4c027819d472 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.factory.js
@@ -52,23 +52,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -79,16 +79,16 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 100.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 10.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -99,19 +99,19 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -100.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -10.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -123,31 +123,31 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	logpdf = factory( 1.0, 0.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -159,31 +159,31 @@ tape( 'if provided a nonpositive `a`, the created function always returns `NaN`'
 	logpdf = factory( 0.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( -1.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.logpdf.js
index 090b99f27340..492bd05600d8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.logpdf.js
@@ -42,42 +42,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 100.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 10.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 1.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -100.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -1.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 0.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -86,25 +86,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = logpdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -113,25 +113,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.native.js
index 8f3c6b47546c..08ecf088a168 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logpdf/test/test.native.js
@@ -51,42 +51,42 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 100.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 10.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 1.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -100.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -1.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 0.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -95,25 +95,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logpdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -122,25 +122,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.js
index 98bba32b1f90..c0b839899190 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,25 +56,25 @@ tape( 'if provided `a <= 0`, function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,25 +83,25 @@ tape( 'if provided `b <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.native.js
index 62200f6f797b..11b3908a983f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,25 +65,25 @@ tape( 'if provided `a <= 0`, function returns `NaN`', opts, function test( t ) {
 	var y;
 
 	y = mean( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,25 +92,25 @@ tape( 'if provided `b <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.js
index 805353ff750b..de6c675e3df1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,7 +56,7 @@ tape( 'if provided `a = 1` and `b = 1`, the function returns `NaN`', function te
 	var y;
 
 	y = mode( 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,28 +65,28 @@ tape( 'if provided `a < 1`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mode( 0.8, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -95,28 +95,28 @@ tape( 'if provided `b < 1`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mode( 2.0, 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.native.js
index a42ddacd96f4..5ca414b5a996 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,7 +65,7 @@ tape( 'if provided `a = 1` and `b = 1`, the function returns `NaN`', opts, funct
 	var y;
 
 	y = mode( 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -74,28 +74,28 @@ tape( 'if provided `a < 1`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mode( 0.8, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,28 +104,28 @@ tape( 'if provided `b < 1`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mode( 2.0, 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.factory.js
index 0bcd361d3e96..3b8fc6934211 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.factory.js
@@ -50,23 +50,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,16 +77,16 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 100.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 10.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -97,19 +97,19 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -100.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -10.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -121,31 +121,31 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	pdf = factory( 1.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -157,31 +157,31 @@ tape( 'if provided a nonpositive `a`, the created function always returns `NaN`'
 	pdf = factory( 0.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.factory.js
index e5357b549967..ee2a46cac231 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/quantile/test/test.factory.js
@@ -50,23 +50,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,31 +78,31 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	quantile = factory( 1.0, 0.0 );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, -1.0 );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NINF );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -114,31 +114,31 @@ tape( 'if provided a nonpositive `a`, the created function always returns `NaN`'
 	quantile = factory( 0.0, 0.5 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.js
index 97061c30f2fa..a429b2376460 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,25 +56,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = stdev( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,25 +83,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.native.js
index 701780139d21..c452bf9bd924 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,25 +65,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = stdev( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,25 +92,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.js
index 7975e21f8163..f5955d548451 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,25 +56,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', function test
 	var y;
 
 	y = variance( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,25 +83,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.native.js
index 4b977eb5352a..263176c02432 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,25 +65,25 @@ tape( 'if provided a nonpositive `a`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = variance( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,25 +92,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.cdf.js
index 3511d090517e..05230d00ecf8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `b`, the function returns `NaN`', function test( t
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.factory.js
index 0c11508b1416..7a0334c9aa9d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `mu` and `b`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `mu` and `b`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.native.js
index 054c4f212007..6e7e40de9463 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `b`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.js
index ce6c9c0212fc..dfa4b5d10bc3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.native.js
index 64a903f67912..a3763f4ca8ce 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/entropy/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.js
index 198f16b790cd..898a7755c172 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.native.js
index f928e1fdc7a2..3711848c1d85 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/kurtosis/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.factory.js
index bbeabb98c1d7..aefba5e2fc33 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	logcdf = factory( 0.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.logcdf.js
index a07adec9f1a6..c469025711a1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `b`, the function returns `NaN`', function test( t
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.native.js
index 5993474ac779..bc6e72ee3b16 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logcdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `b`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.factory.js
index ce6560c33585..5dc58d4a65a1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, 0.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.logpdf.js
index 83f05b73313f..58e5b421a95c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,28 +70,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.native.js
index 7eb5c238fcdb..79ecd400737b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,28 +79,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.js
index d1ab1334a7d4..53351d77c706 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.native.js
index 07e9fc8310d1..23e72d0c78f1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mean/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 1.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.js
index 446c092c580d..d551ffccf22b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.native.js
index 556e782b623b..3d7ee0053b12 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/median/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN, 1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 1.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.factory.js
index 59211bb54908..8c1c9b15871f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0, 1.0 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,29 +83,29 @@ tape( 'the created function returns `NaN` for any `x` outside `(-1/b,1/b)', func
 
 	mgf = factory( 0.0, 2.0 );
 	y = mgf( -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( -0.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, 4.0 );
 	y = mgf( -0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( -0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -117,34 +117,34 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	mgf = factory( 0.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, 0.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.mgf.js
index 487989c15ab3..9aa6998ac91c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.mgf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,28 +58,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -88,28 +88,28 @@ tape( 'the function returns `NaN` for any `x` outside `(-1/b,1/b)', function tes
 	var y;
 
 	y = mgf( -1.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( -0.8, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.8, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 1.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( -0.5, 0.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( -0.3, 0.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.5, 0.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.3, 0.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.native.js
index b74c584c1025..2a22126d46e7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mgf/test/test.native.js
@@ -55,11 +55,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -67,28 +67,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,28 +97,28 @@ tape( 'the function returns `NaN` for any `x` outside `(-1/b,1/b)', opts, functi
 	var y;
 
 	y = mgf( -1.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( -0.8, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.8, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 1.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( -0.5, 0.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( -0.3, 0.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.5, 0.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.3, 0.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.js
index 2ddb465b1068..db62d9648088 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.native.js
index 6741cdd79e66..5c72d4ce415e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/mode/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.factory.js
index 5f54340cfafb..86c065fc8bdf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.native.js
index 8bdedf968f8c..97ddda136efa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,28 +79,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.pdf.js
index bf0eb40ba4b2..2593610acf65 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,28 +70,28 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.factory.js
index 30e7ff468661..a5799d75475f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `mu` and `b`, the function returns a function which
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,34 +98,34 @@ tape( 'if provided a nonpositive `b`, the created function always returns `NaN`'
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, 0.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.js
index 533eb9e232fb..fa2f10b2e335 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.native.js
index 31e1c6f61c2a..4558c0c90458 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/skewness/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.js
index ce8d6a96ba4f..7d5870228562 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.native.js
index 1580bd4a0f84..633abb720f36 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/stdev/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.js
index 61d17d7638ec..7615aa866752 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', function test
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.native.js
index fbc7b8520650..ee731ae96d13 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/variance/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `b`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.cdf.js
index a62a0b692335..e4c95722dd6f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.cdf.js
@@ -46,32 +46,32 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `c`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a `x` smaller than `mu`, the function returns `0`', function test( t ) {
 	var y = cdf( -1.0, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 3.0, 4.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -80,25 +80,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.factory.js
index 2b846654c6cc..245347b9f9fd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `mu` and `c`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `mu` and `c`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -105,11 +105,11 @@ tape( 'the created function returns `0` for `x < mu`', function test( t ) {
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	cdf = factory( 4.0, 1.0 );
 	y = cdf( 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -121,34 +121,34 @@ tape( 'if provided a nonpositive `c`, the created function always returns `NaN`'
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.native.js
index 0133046f2eae..4a0ef94d2dc2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/cdf/test/test.native.js
@@ -55,32 +55,32 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `mu` and `c`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `mu` and `c`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a `x` smaller than `mu`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( -1.0, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 3.0, 4.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -89,25 +89,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.js
index 2b54d32660a3..f5daf3e566ec 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.native.js
index e529c0b4a210..59a1e9506a25 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/entropy/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.factory.js
index bf4146dcb038..b7315ea47d62 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `mu` and `c`, the function returns a function which r
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `mu` and `c`, the function returns a function which r
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -105,11 +105,11 @@ tape( 'the created function returns `-infinity` for `x < mu`', function test( t
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( -1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	logcdf = factory( 4.0, 1.0 );
 	y = logcdf( 3.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -121,34 +121,34 @@ tape( 'if provided a nonpositive `c`, the created function always returns `NaN`'
 	logcdf = factory( 0.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.logcdf.js
index b8d1e2d0e999..fb1ee8318643 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.logcdf.js
@@ -46,32 +46,32 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `c`, the function returns `-infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a `x` smaller than `mu`, the function returns `-infinity`', function test( t ) {
 	var y = logcdf( -1.0, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 3.0, 4.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -80,25 +80,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.native.js
index 3945709ab073..3ba3546e7195 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logcdf/test/test.native.js
@@ -55,32 +55,32 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `c`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a `x` smaller than `mu`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logcdf( -1.0, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 3.0, 4.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -89,25 +89,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.factory.js
index 1182a7a0b8da..21afb5908c0f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `c`, the function returns a function which
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -95,13 +95,13 @@ tape( 'if provided a finite `mu` and `c`, the function returns a function which
 	logpdf = factory( 0.0, 1.0 );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -2.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -113,31 +113,31 @@ tape( 'if provided a nonpositive `c`, the created function always returns `NaN`'
 	logpdf = factory( 0.0, 0.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.logpdf.js
index e86333179a3e..467b43924426 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.logpdf.js
@@ -46,17 +46,17 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -64,13 +64,13 @@ tape( 'if provided `x <= μ` and a finite `mu` and `c`, the function returns `-i
 	var y;
 
 	y = logpdf( 0.0, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -2.0, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.native.js
index b62bc58daa1b..a41f28aeddfe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `c`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.js
index 4d524d7c65fb..68914004c543 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.js
@@ -38,9 +38,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -48,25 +48,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the expected value of a Lévy distribution', functio
 		mu = ( randu()*10.0 ) - 5.0;
 		c = randu() * 20.0;
 		y = mean( mu, c );
-		t.strictEqual( y, PINF, 'returns +Infinity' );
+		t.strictEqual( y, PINF, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.native.js
index 9972881b66d5..53c7e7c0759d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/mean/test/test.native.js
@@ -47,9 +47,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,25 +57,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns the expected value of a Lévy distribution', opts, f
 		mu = ( randu()*10.0 ) - 5.0;
 		c = randu() * 20.0;
 		y = mean( mu, c );
-		t.strictEqual( y, PINF, 'returns +Infinity' );
+		t.strictEqual( y, PINF, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.js
index 4d0e78e51722..ea049d164cf7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.native.js
index 8f4d20a62755..1a67318d8263 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/mode/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.factory.js
index 5904d1dc4d93..cb51ad713514 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `c`, the function returns a function which
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `c`, the function returns a function which
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,31 +106,31 @@ tape( 'if provided a nonpositive `c`, the created function always returns `NaN`'
 	pdf = factory( 0.0, 0.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.native.js
index 567a549cc662..7519cfa4972c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `c`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.pdf.js
index fa80abb71726..106796ba3be8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `c`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `c`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.factory.js
index 8a5f932a488b..4b0de54f57df 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `mu` and `c`, the function returns a function which
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,26 +98,26 @@ tape( 'if provided a negative `c`, the created function always returns `NaN`', f
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.js
index 3cf6ca1bb5db..46d6413029b2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.js
@@ -38,9 +38,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -48,25 +48,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the standard deviation of a Lévy distribution', fun
 		mu = ( randu()*10.0 ) - 5.0;
 		c = randu() * 20.0;
 		y = stdev( mu, c );
-		t.strictEqual( y, PINF, 'returns +Infinity' );
+		t.strictEqual( y, PINF, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.native.js
index 74da422038fe..9b064133ea3c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/stdev/test/test.native.js
@@ -47,9 +47,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,25 +57,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns the standard deviation of a Lévy distribution', opt
 		mu = ( randu()*10.0 ) - 5.0;
 		c = randu() * 20.0;
 		y = stdev( mu, c );
-		t.strictEqual( y, PINF, 'returns +Infinity' );
+		t.strictEqual( y, PINF, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.js
index 5ac294071ea8..92e10541ed1b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.js
@@ -38,9 +38,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -48,25 +48,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', function test
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'the function returns the variance of a Lévy distribution', function test
 		mu = ( randu()*10.0 ) - 5.0;
 		c = randu() * 20.0;
 		y = variance( mu, c );
-		t.strictEqual( y, PINF, 'returns +Infinity' );
+		t.strictEqual( y, PINF, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.native.js
index b4af14078586..32eb1d59c2a5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/variance/test/test.native.js
@@ -47,9 +47,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,25 +57,25 @@ tape( 'if provided a nonpositive `c`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -90,7 +90,7 @@ tape( 'the function returns the variance of a Lévy distribution', opts, functio
 		mu = ( randu()*10.0 ) - 5.0;
 		c = randu() * 20.0;
 		y = variance( mu, c );
-		t.strictEqual( y, PINF, 'returns +Infinity' );
+		t.strictEqual( y, PINF, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.cdf.js
index ec365ed53cd7..4d774e6a73a9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.factory.js
index 1be46a3b91f6..95ffb7fbf987 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `mu` and `s`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `mu` and `s`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.native.js
index 43cea6598bd5..97a49b869d1c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.js
index baae0f07bd3d..fed59ec1c68f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.native.js
index 2703e725d422..873c5f520cf1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/entropy/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.js
index 7c7e9f6d6538..19d9e20aa6e5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.native.js
index 8aa97c40d431..bc8430641203 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/kurtosis/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,22 +61,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.factory.js
index 273e96b0dbfa..92adb159947f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	logcdf = factory( 0.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.logcdf.js
index e37522e6a4cc..16b1717019ed 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.native.js
index fde47ea8b711..be15719ab9bb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logcdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.factory.js
index ab5bccb74930..9b21c19aac6f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -140,16 +140,16 @@ tape( 'if `s` equals `0`, the created function evaluates a degenerate distributi
 	t.strictEqual( y, PINF, 'returns +Infinity for x equal to mu' );
 
 	y = logpdf( 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.logpdf.js
index 615582e71629..dd10f466c254 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,7 +106,7 @@ tape( 'if provided `s` equal to `0`, the function evaluates a degenerate distrib
 	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( NaN, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.native.js
index fb6193082971..948cdf4ae3d2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -115,7 +115,7 @@ tape( 'if provided `s` equal to `0`, the function evaluates a degenerate distrib
 	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( NaN, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.js
index 5234110f3a61..1e36744ee281 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.native.js
index 08d6903f15dd..55e0aafd1be1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mean/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,22 +61,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.js
index 4ab83ae09f99..52e7ba206959 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.native.js
index e52c3b579648..d94d9e4343a8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/median/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,22 +61,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.factory.js
index cc3944a44dd3..44115393befd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.factory.js
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0, 1.0 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -85,26 +85,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	mgf = factory( 0.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.mgf.js
index 4c354b6ea5f6..5d7f9d023651 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.mgf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,22 +58,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.native.js
index f16699efda6c..9a2613316233 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mgf/test/test.native.js
@@ -55,11 +55,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -67,22 +67,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.js
index d6293d73db92..104cf26b1e9d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.native.js
index 4dbf89584d79..ece09e2a81b5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/mode/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,22 +61,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.factory.js
index 4ba57a09c396..6855e502062d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -140,16 +140,16 @@ tape( 'if `s` equals `0`, the created function evaluates a degenerate distributi
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = pdf( 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.native.js
index 45badf63b148..3c3b316f4c75 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', opts, function t
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,16 +106,16 @@ tape( 'if provided `s` equal to `0`, the function evaluates a degenerate distrib
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = pdf( 1.0, 2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.pdf.js
index a381983b24d1..a2fb06d970c8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `s`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `s`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `s`, the function returns `NaN`', function test( t
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,16 +97,16 @@ tape( 'if provided `s` equal to `0`, the function evaluates a degenerate distrib
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = pdf( 1.0, 2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.factory.js
index f1af640fbd7b..153592661214 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `mu` and `s`, the function returns a function which
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,26 +98,26 @@ tape( 'if provided a negative `s`, the created function always returns `NaN`', f
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.js
index 4942bc26e82e..b1ec6753293e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.native.js
index bef83cafd3a5..0205919e3c3b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/skewness/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,22 +61,22 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.js
index 8cc75b570873..fe8921ee622d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.native.js
index 89640f9ce615..ca4dbdad83db 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/stdev/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.js
index c5008590a86f..a2fc32d882f9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', function test
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.native.js
index ee5df2691fae..50881f7a4d2d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/variance/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `s`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.cdf.js
index edc9e86c96d9..0a42261a804e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `sigma`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.factory.js
index 80fc1753a0a3..b488ef54858b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.js
index 8bce41662234..c2db248cd0ed 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.native.js
index 4ba79f1fdfc5..207311f091db 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/entropy/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.js
index 6518a9934d31..a19e53bc63c5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.native.js
index 823ed9ba1a64..305ee549209c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/kurtosis/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.factory.js
index c9b0a242c862..a45ffcf98603 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.factory.js
@@ -54,23 +54,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -104,26 +104,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	logcdf = factory( 0.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -135,19 +135,19 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	logcdf = factory( 2.0, 0.0 );
 
 	y = logcdf( PINF );
-	t.strictEqual( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = logcdf( 2.0 );
 	t.strictEqual( y, 0, 'returns 0 for x equal to mu' );
 
 	y = logcdf( 1.0 );
-	t.strictEqual( y, -Infinity, 'returns -Infinity' );
+	t.strictEqual( y, -Infinity, 'returns expected value' );
 
 	y = logcdf( NINF );
-	t.strictEqual( y, -Infinity, 'returns -Infinity' );
+	t.strictEqual( y, -Infinity, 'returns expected value' );
 
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.logcdf.js
index 453feff9f0a8..2485d17a087e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logcdf/test/test.logcdf.js
@@ -46,38 +46,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -85,22 +85,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', funct
 	var y;
 
 	y = logcdf( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,19 +109,19 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = logcdf( PINF, 2.0, 0.0 );
-	t.strictEqual( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, 0.0 );
 	t.strictEqual( y, NINF, 'returns -Infinity for x equal to mu' );
 
 	y = logcdf( 1.0, 2.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( NINF, 2.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( NaN, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.factory.js
index eaaf51a13ac7..3a15307fd87a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -105,30 +105,30 @@ tape( 'if provided a nonpositive `sigma`, the created function always returns `N
 
 	logpdf = factory( 0.0, 0.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, -1.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.logpdf.js
index a57ce9f3d5fe..2df679a65a6e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.js
index 05f0658580cf..4ea573a592a6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.native.js
index 73811d813c3a..e78c49b73c58 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mean/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.js
index fdb93c59aa5e..dd255b239495 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.native.js
index 404e24219638..76437dd57292 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/median/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.js
index 2d8a342458c0..e14c7b9ccf03 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.native.js
index 8829a863d0e3..27ff7d0d2192 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/mode/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.factory.js
index 1ac5b84749cc..519f2dcfea2d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -105,30 +105,30 @@ tape( 'if provided a nonpositive `sigma`, the created function always returns `N
 
 	pdf = factory( 0.0, 0.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, -1.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.native.js
index 1d792727b719..23ffbe8c8439 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.pdf.js
index d9be18e5dd47..47fa9b1e3d66 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.factory.js
index 2e0ff0fbd2e8..63f49bc3f7d7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,31 +98,31 @@ tape( 'if provided a nonpositive `sigma`, the created function always returns `N
 	quantile = factory( 0.0, 0.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.js
index 42f8d6f1d88d..54d5b2e9c3df 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.native.js
index fc4628dee922..9aad27049b2b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/skewness/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.js
index b46ee95e901b..8c2c6f2c7e13 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.native.js
index 782ff4a61ef6..445b0704dd28 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/stdev/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.js
index dda42c59cca0..39b39598b49e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.native.js
index 171f986d4edc..4dcd889a7d99 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/variance/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.cdf.js
index 20b45eaa6bc6..f1b00caf4959 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.cdf.js
@@ -47,30 +47,30 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 10, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 10, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a `x` equal to `+Infinity`, the function returns `1` (provided `r` and `p` are valid)', function test( t ) {
 	var y = cdf( PINF, 20, 0.5 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a negative number for `x` and a valid `r` and `p`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -10.0, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -79,16 +79,16 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var y;
 
 	y = cdf( 2.0, -2.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, NINF, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,16 +97,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = cdf( 2.0, 20, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 20, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 20, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.factory.js
index 8bfdde6babf0..73e9daf59602 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/cdf/test/test.factory.js
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 20, 0.5 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 0.5 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 20, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	cdf = factory( 20, 0.5 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	cdf = factory( 20, 0.5 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -10.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -116,18 +116,18 @@ tape( 'if provided a `r` which is not a positive number, the created function al
 	cdf = factory( -10.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -4.0, 0.5 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, 0.5 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -139,22 +139,22 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the created functi
 	cdf = factory( 20.0, 1.5 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 20.0, -0.5 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 20.0, PINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 20.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.js
index 60d5269a550a..ed7094ec97ca 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -54,13 +54,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = kurtosis( -2, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( -1, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NINF, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,16 +69,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = kurtosis( 20, -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.native.js
index 395a839ce965..bf9da41e99ad 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/kurtosis/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,13 +63,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = kurtosis( -2, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( -1, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NINF, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = kurtosis( 20, -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 20, PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.factory.js
index 22e894ccbbbe..d74b251f96aa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.factory.js
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpmf = factory( 20.0, 0.5 );
 	y = logpmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, 0.5 );
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 20.0, NaN );
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, NaN );
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN, NaN );
 	y = logpmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,16 +84,16 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	logpmf = factory( 20.0, 0.5 );
 	y = logpmf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -20.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -10.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -104,16 +104,16 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	logpmf = factory( 20.0, 0.5 );
 	y = logpmf( -2.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 1.2 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -125,26 +125,26 @@ tape( 'if provided a success probability `p` outside `(0,1]`, the created functi
 	logpmf = factory( 20, 1.2 );
 
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 20, 0.0 );
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 20, -0.1 );
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 20, NINF );
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( 20, PINF );
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -156,18 +156,18 @@ tape( 'if provided a `r` which is not a positive number, the created function al
 	logpmf = factory( -1.0, 0.5 );
 
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( -2.0, 0.5 );
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NINF, 0.5 );
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.logpmf.js
index 0d41d65bca08..ebcbc64213aa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/logpmf/test/test.logpmf.js
@@ -47,42 +47,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpmf( NaN, 20.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, 20.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `r` and `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( NINF, 20, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -20.0, 20, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -100.0, 20, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.0, 20, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `r` and `p`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( -1.5, 20.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -0.5, 20.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 1.5, 20.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 2.5, 20.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -91,13 +91,13 @@ tape( 'if provided `r` which is not a positive number, the function returns `NaN
 	var y;
 
 	y = logpmf( 2.0, -0.5, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, -1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, NINF, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,16 +106,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = logpmf( 2.0, 20, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, 20, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, 20, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.js
index c0c85867185a..09be5148dfce 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -54,13 +54,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = mean( -2, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( -1, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,16 +69,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mean( 20, -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 20, 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 20, NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 20, PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.native.js
index f8fe195f9c11..093feeae04c3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mean/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,13 +63,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = mean( -2, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( -1, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mean( 20, -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 20, 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 20, NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 20, PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.factory.js
index ff9a87d68254..463733b98b4b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mgf/test/test.factory.js
@@ -50,23 +50,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 20, 0.5 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 0.5 );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 20, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,18 +78,18 @@ tape( 'if provided a `r` which is not a positive number, the created function al
 	mgf = factory( -10.0, 0.5 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( -4.0, 0.5 );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, 0.5 );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -101,22 +101,22 @@ tape( 'if provided a success probability `p` outside `[0,1]`, the created functi
 	mgf = factory( 20.0, 1.5 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 20.0, -0.5 );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 20.0, PINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 20.0, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -127,11 +127,11 @@ tape( 'the created function returns `NaN` if provided `t >= -ln( p )`', function
 
 	mgf = factory( 10, 0.5 ); // -ln( p ) = ~0.693
 	y = mgf( 0.7 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 10, 0.2 ); // -ln( p ) = ~1.609
 	y = mgf( 1.7 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.js
index a5397e375c74..43cbb5b0e074 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -54,13 +54,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = mode( -2, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -1, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,16 +69,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mode( 20, -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 20, 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 20, NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 20, PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.native.js
index 1be121106754..dac553182709 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/mode/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,13 +63,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = mode( -2, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( -1, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = mode( 20, -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 20, 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 20, NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 20, PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.factory.js
index 1bee984180a1..7285a136d716 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.factory.js
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 20.0, 0.5 );
 	y = pmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, 0.5 );
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 20.0, NaN );
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, NaN );
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN, NaN );
 	y = pmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,16 +84,16 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	pmf = factory( 20.0, 0.5 );
 	y = pmf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -20.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -10.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -104,16 +104,16 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	pmf = factory( 20.0, 0.5 );
 	y = pmf( -2.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 1.2 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -125,26 +125,26 @@ tape( 'if provided a success probability `p` outside `(0,1]`, the created functi
 	pmf = factory( 20, 1.2 );
 
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 20, 0.0 );
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 20, -0.1 );
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 20, NINF );
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( 20, PINF );
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -156,18 +156,18 @@ tape( 'if provided a `r` which is not a positive number, the created function al
 	pmf = factory( -1.0, 0.5 );
 
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( -2.0, 0.5 );
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NINF, 0.5 );
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.pmf.js
index 2550cdf48960..96dbdef76e71 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/pmf/test/test.pmf.js
@@ -47,42 +47,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( NaN, 20.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, 20.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `r` and `p`, the function returns `0`', function test( t ) {
 	var y = pmf( NINF, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -20.0, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -100.0, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `r` and `p`, the function returns `0`', function test( t ) {
 	var y = pmf( -1.5, 20.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -0.5, 20.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 1.5, 20.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 2.5, 20.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -91,13 +91,13 @@ tape( 'if provided `r` which is not a positive number, the function returns `NaN
 	var y;
 
 	y = pmf( 2.0, -0.5, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, -1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, NINF, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,16 +106,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var y;
 
 	y = pmf( 2.0, 20, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, 20, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, 20, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, 20, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.factory.js
index df6bcbc9f524..9359caeddd63 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.factory.js
@@ -55,23 +55,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 20.0, 0.5 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 0.5 );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 20.0, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -82,10 +82,10 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which re
 
 	quantile = factory( 20, 0.5 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,22 +97,22 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the created fun
 	quantile = factory( 20, -1.0 );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 20, NINF );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 20, PINF );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 20, 1.5 );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -124,19 +124,19 @@ tape( 'if provided a `r` which is not a positive integer, the created function a
 	quantile = factory( -10.5, 0.5 );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, 0.5 );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -147,10 +147,10 @@ tape( 'if provided a valid `r` and `p`, the function returns a function which ac
 
 	quantile = factory( 20, 0.5 );
 	y = quantile( 1.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.js
index bc5b8769f1a2..ffea0d64186a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -54,13 +54,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = skewness( -2, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( -1, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,16 +69,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = skewness( 20, -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.native.js
index d85e15bd0912..a7837497d6ed 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/skewness/test/test.native.js
@@ -51,10 +51,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,13 +63,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = skewness( -2, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( -1, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -78,16 +78,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = skewness( 20, -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 20, PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.js
index 303064ff2a81..8e97f70322f8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,13 +56,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = stdev( -2, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( -1, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -71,16 +71,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = stdev( 20, -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.native.js
index 1fb24f323943..332f61758f31 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,13 +65,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = stdev( -2, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( -1, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,16 +80,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = stdev( 20, -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 20, PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.js
index 226c1a5275d5..3eb7c49c834e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.js
@@ -42,10 +42,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -54,13 +54,13 @@ tape( 'if provided a `r` which is not a positive number, the function returns `N
 	var v;
 
 	v = variance( -2, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( -1, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,16 +69,16 @@ tape( 'if provided a success probability `p` outside of `[0,1]`, the function re
 	var v;
 
 	v = variance( 20, -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 20, 1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 20, NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 20, PINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.native.js
index 6a1088407992..90fda0c314e3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/variance/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 10, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,16 +61,16 @@ tape( 'if provided `r <= 0` or `p <= 0` or `p > 1`, the function returns `NaN`',
 	var y;
 
 	y = variance( -1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 0.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 10.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 10.0, 1.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.cdf.js
index 62ddad344e8a..0de6bf28adff 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `mu` and `sigma`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,22 +70,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', funct
 	var y;
 
 	y = cdf( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.factory.js
index e8c24a364af9..f6c2e3292324 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `mu` and `sigma`, the function returns a function whi
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `mu` and `sigma`, the function returns a function whi
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	cdf = factory( 0.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.native.js
index 607a6ce1f407..4645da47a9b9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `mu` and `sigma`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `mu` and `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,22 +79,22 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = cdf( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.js
index 1668cf17ebb8..cae4de3cbcb0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.native.js
index 584bc04bfe12..0fa52a281c70 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/entropy/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = entropy( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = entropy( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = entropy( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.js
index 3841acad3b16..6b6468dcec10 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.native.js
index 06da10f6fac7..9f665e677247 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/kurtosis/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = kurtosis( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = kurtosis( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = kurtosis( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.factory.js
index c9b0a242c862..a45ffcf98603 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.factory.js
@@ -54,23 +54,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -104,26 +104,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	logcdf = factory( 0.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -135,19 +135,19 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	logcdf = factory( 2.0, 0.0 );
 
 	y = logcdf( PINF );
-	t.strictEqual( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = logcdf( 2.0 );
 	t.strictEqual( y, 0, 'returns 0 for x equal to mu' );
 
 	y = logcdf( 1.0 );
-	t.strictEqual( y, -Infinity, 'returns -Infinity' );
+	t.strictEqual( y, -Infinity, 'returns expected value' );
 
 	y = logcdf( NINF );
-	t.strictEqual( y, -Infinity, 'returns -Infinity' );
+	t.strictEqual( y, -Infinity, 'returns expected value' );
 
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.logcdf.js
index d817be43d57e..9b012cc7abde 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.logcdf.js
@@ -46,38 +46,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -85,22 +85,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', funct
 	var y;
 
 	y = logcdf( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -109,19 +109,19 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = logcdf( PINF, 2.0, 0.0 );
-	t.strictEqual( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, 0.0 );
 	t.strictEqual( y, 0, 'returns 0 for x equal to mu' );
 
 	y = logcdf( 1.0, 2.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( NINF, 2.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( NaN, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.native.js
index 1169e318e142..4f1b496f700a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logcdf/test/test.native.js
@@ -55,38 +55,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( NaN, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -94,22 +94,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', opts,
 	var y;
 
 	y = logcdf( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -118,19 +118,19 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	var y;
 
 	y = logcdf( PINF, 2.0, 0.0 );
-	t.strictEqual( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, 0.0 );
 	t.strictEqual( y, 0, 'returns 0 for x equal to mu' );
 
 	y = logcdf( 1.0, 2.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( NINF, 2.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( NaN, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.factory.js
index e242b85323a5..021846613521 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.factory.js
@@ -54,23 +54,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -104,26 +104,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -138,16 +138,16 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = logpdf( 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.logpdf.js
index cadd70415aa2..59f84e1431c7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.logpdf.js
@@ -46,38 +46,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -85,22 +85,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', funct
 	var y;
 
 	y = logpdf( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -112,16 +112,16 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	t.strictEqual( y, PINF, 'returns Infinity for x equal to mu' );
 
 	y = logpdf( 1.0, 2.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF, 2.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF, 2.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NaN, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.native.js
index bd0df222b7c2..db5e1004f30c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/logpdf/test/test.native.js
@@ -55,38 +55,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `mu` and `sigma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -94,22 +94,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', opts,
 	var y;
 
 	y = logpdf( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -121,16 +121,16 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	t.strictEqual( y, PINF, 'returns Infinity for x equal to mu' );
 
 	y = logpdf( 1.0, 2.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF, 2.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF, 2.0, 0.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NaN, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.js
index d165e9c9c411..c78b7ef1e1a7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.native.js
index 94b087a452ac..c79d15bf715f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mean/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mean( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mean( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.js
index cd68edd06d9d..617761c94d64 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.native.js
index c392a7c6c9b7..927f62a09dd0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/median/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = median( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = median( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.factory.js
index d022af5f9170..8523f3f26130 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0, 1.0 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,30 +83,30 @@ tape( 'if provided a nonpositive `sigma`, the created function always returns `N
 
 	mgf = factory( 0.0, 0.0 );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, -1.0 );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.mgf.js
index 904b2aab0541..d96b3f13c450 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.mgf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,25 +58,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.native.js
index 4ddc37544666..602b963a6f52 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mgf/test/test.native.js
@@ -55,11 +55,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -67,25 +67,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mgf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.js
index 8424a461ee81..93e18096e637 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.native.js
index 8e4dcfd5ed46..80cb5b92eb19 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/mode/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mode( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = mode( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.factory.js
index 4f7c89df81b2..4a1340e47405 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.factory.js
@@ -54,23 +54,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,7 +81,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -92,7 +92,7 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -104,26 +104,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -138,16 +138,16 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = pdf( 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.native.js
index 74228061a239..dbde75a1bb5c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.native.js
@@ -55,38 +55,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -94,22 +94,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', opts,
 	var y;
 
 	y = pdf( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -121,16 +121,16 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = pdf( 1.0, 2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.pdf.js
index 946a36d434b7..c3002d93f203 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/pdf/test/test.pdf.js
@@ -46,38 +46,38 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 	var y;
 
 	y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, NaN, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `mu` and `sigma`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -85,22 +85,22 @@ tape( 'if provided a negative `sigma`, the function always returns `NaN`', funct
 	var y;
 
 	y = pdf( 2.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 0.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -112,16 +112,16 @@ tape( 'if provided `sigma` equals `0`, the function evaluates a degenerate distr
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to mu' );
 
 	y = pdf( 1.0, 2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 2.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.factory.js
index a112506acd82..d2e51d789548 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/quantile/test/test.factory.js
@@ -63,23 +63,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -90,10 +90,10 @@ tape( 'if provided a finite `mu` and `sigma`, the function returns a function wh
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -105,26 +105,26 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.js
index 689e1ea7c258..535c3d9eb738 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.js
@@ -42,9 +42,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -52,25 +52,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.native.js
index 6d8a97171a6c..580fe68a548c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/skewness/test/test.native.js
@@ -51,9 +51,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = skewness( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = skewness( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -61,25 +61,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = skewness( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.js
index ef08951b0515..88b4c32d55da 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,22 +54,22 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.native.js
index af044bc29c86..4074762861fa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/stdev/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = stdev( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = stdev( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = stdev( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.js
index 50272fe412bb..a65e3a3b66cf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.js
@@ -44,9 +44,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -54,25 +54,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', function
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.native.js
index 28ff25a0e2c8..47910941f954 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/variance/test/test.native.js
@@ -53,9 +53,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = variance( 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,25 +63,25 @@ tape( 'if provided a nonpositive `sigma`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = variance( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.cdf.js
index 5a52cbeb5a1b..64188394cb5b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.cdf.js
@@ -46,29 +46,29 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `1.0` if provided `+Infinity` and valid parameters', function test( t ) {
 	var y = cdf( PINF, 2.0, 2.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.5, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -77,25 +77,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,25 +104,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.factory.js
index befe5296281a..0e16e5299e87 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	cdf = factory( 1.0, 10.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -100.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -10.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 9.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 10.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -121,31 +121,31 @@ tape( 'if provided a nonpositive `alpha`, the created function always returns `N
 	cdf = factory( 0.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, 1.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, PINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NaN );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -157,31 +157,31 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	cdf = factory( 1.0, 0.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.native.js
index cf1a5ba64ac7..6357e5368c8b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/cdf/test/test.native.js
@@ -55,29 +55,29 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `1.0` if provided `+Infinity` and valid parameters', opts, function test( t ) {
 	var y = cdf( PINF, 2.0, 2.0 );
-	t.strictEqual( y, 1.0, 'returns 1.0' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.5, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -86,25 +86,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -113,25 +113,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.js
index 3f60981f16f7..735467f84d2b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.native.js
index e9ba4c848577..707611a6b95e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/entropy/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.js
index b1c2593c403c..92bc49e2d60e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided `alpha <= 4`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( 4.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.native.js
index e9bdc51863cc..b755295cfadc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/kurtosis/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,28 +65,28 @@ tape( 'if provided `alpha <= 4`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = kurtosis( 4.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -95,19 +95,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.factory.js
index 103f6aa1e1e7..be6dc75540ae 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0, 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,22 +94,22 @@ tape( 'if provided a finite `alpha` and `beta`, the function returns a function
 
 	logcdf = factory( 1.0, 10.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -100.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -10.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 9.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 10.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -121,31 +121,31 @@ tape( 'if provided a nonpositive `alpha`, the created function always returns `N
 	logcdf = factory( 0.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -1.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, 1.0 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, PINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NaN );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -157,31 +157,31 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	logcdf = factory( 1.0, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.logcdf.js
index d9738f01b0fc..8e176c4cf95f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.logcdf.js
@@ -46,29 +46,29 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0.0` if provided `+Infinity` and valid parameters', function test( t ) {
 	var y = logcdf( PINF, 2.0, 2.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.5, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -77,25 +77,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', function
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,25 +104,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', function t
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.native.js
index 15e4b309ba78..8319972b655b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logcdf/test/test.native.js
@@ -55,29 +55,29 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0.0` if provided `+Infinity` and valid parameters', opts, function test( t ) {
 	var y = logcdf( PINF, 2.0, 2.0 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.5, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -86,25 +86,25 @@ tape( 'if provided a nonpositive `alpha`, the function returns `NaN`', opts, fun
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -113,25 +113,25 @@ tape( 'if provided a nonpositive `beta`, the function returns `NaN`', opts, func
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1/0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.factory.js
index eeab03623d46..bcc0e6fbe1ab 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided a valid `alpha` and `beta`, the function returns a function w
 
 	logpdf = factory( 1.0, 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -100.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -107,26 +107,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -138,26 +138,26 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 	logpdf = factory( -1.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.logpdf.js
index d20c0b62bbd5..aac720177e50 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.logpdf.js
@@ -46,29 +46,29 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -100.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -10.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -0.5, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 0.5, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -77,22 +77,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -101,22 +101,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.native.js
index d1eb546ca552..cec9f7e9d9c1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/logpdf/test/test.native.js
@@ -55,29 +55,29 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -100.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -10.0, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -0.5, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 0.5, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -86,22 +86,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,22 +110,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/median/test/test.js
index 8c3ce7c87359..9fdea21b1182 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/median/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = median( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.js
index b066ca2dc4cd..2721b2d63c20 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.native.js
index 9f879088c874..1b5f79f326b0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.factory.js
index ea375fef6705..854b453b8940 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,19 +83,19 @@ tape( 'if provided a valid `alpha` and `beta`, the function returns a function w
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -100.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -107,26 +107,26 @@ tape( 'if provided `beta <= 0`, the created function always returns `NaN`', func
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -138,26 +138,26 @@ tape( 'if provided `alpha <= 0`, the created function always returns `NaN`', fun
 	pdf = factory( -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.native.js
index d158fd2da663..eafd225d738b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.native.js
@@ -56,29 +56,29 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -100.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -10.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.5, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -87,22 +87,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -111,22 +111,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.pdf.js
index 59f3789b9702..17a8dc26e67a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/pdf/test/test.pdf.js
@@ -46,29 +46,29 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number smaller than `beta` for `x` and a valid `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -100.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -10.0, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.5, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -77,22 +77,22 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -101,22 +101,22 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.factory.js
index 5622b5a9c6a5..d592159b0584 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a valid `alpha` and `beta`, the function returns a function w
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,26 +98,26 @@ tape( 'if provided a nonpositive `beta`, the created function always returns `Na
 	quantile = factory( 0.0, -1.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -129,31 +129,31 @@ tape( 'if provided a nonpositive `alpha`, the created function always returns `N
 	quantile = factory( 0.0, 0.5 );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( -1.0, 0.5 );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.js
index ddecc88d1882..78ff0b8c3617 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,28 +56,28 @@ tape( 'if provided `alpha <= 3`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.native.js
index e1b529418625..3fa02241664d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/skewness/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,28 +65,28 @@ tape( 'if provided `alpha <= 3`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -95,19 +95,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.js
index 08e2a9a4028f..e5144c8fd5f7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,13 +77,13 @@ tape( 'if provided `0 < alpha <= 2` and `beta > 0`, the function returns `+Infin
 	var y;
 
 	y = stdev( 2.0, 2.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = stdev( 0.1, 1.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = stdev( 0.5, PINF );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -92,19 +92,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.native.js
index 0b060877cef8..3a0baee2755e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,13 +86,13 @@ tape( 'if provided `0 < alpha <= 2` and `beta > 0`, the function returns `+Infin
 	var y;
 
 	y = stdev( 2.0, 2.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = stdev( 0.1, 1.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = stdev( 0.5, PINF );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -101,19 +101,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.js
index 8aada0688651..845a84272cb6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,13 +77,13 @@ tape( 'if provided `0 < alpha <= 2` and `beta > 0`, the function returns `+Infin
 	var y;
 
 	y = variance( 2.0, 2.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = variance( 0.1, 1.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = variance( 0.5, PINF );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -92,19 +92,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', function test( t )
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.native.js
index f25f608795fc..4b644a298afb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `alpha <= 0`, the function returns `NaN`', opts, function tes
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,13 +86,13 @@ tape( 'if provided `0 < alpha <= 2` and `beta > 0`, the function returns `+Infin
 	var y;
 
 	y = variance( 2.0, 2.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = variance( 0.1, 1.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = variance( 0.5, PINF );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -101,19 +101,19 @@ tape( 'if provided `beta <= 0`, the function returns `NaN`', opts, function test
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.factory.js
index 9b468c202491..d4b54826b45f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/cdf/test/test.factory.js
@@ -95,21 +95,21 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the created
 
 	cdf = factory( 0.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -1.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.js
index 04bb9fc710bc..4fe5e72b1623 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,10 +50,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = kurtosis( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( -1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.native.js
index a8c94cb8af72..3158b3caa70e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/kurtosis/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,10 +59,10 @@ tape( 'if provided a shape parameter `lambda` which is nonpositive, the function
 	var v;
 
 	v = kurtosis( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( -1.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.cdf.js
index cc3fe4c850aa..214ab7ffc480 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.cdf.js
@@ -46,30 +46,30 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a nonpositive number for `x` and a valid `lambda`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -10.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -2.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -78,13 +78,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.factory.js
index 316a154db1bc..f9c28dd6714b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.factory.js
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'if provided a valid `lambda`, the function returns a function which retur
 
 	cdf = factory( 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -82,16 +82,16 @@ tape( 'if provided a valid `lambda`, the function returns a function which retur
 
 	cdf = factory( 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -100.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -2.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -103,10 +103,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	cdf = factory( -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.native.js
index 334c115ebf88..9965fe936471 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/cdf/test/test.native.js
@@ -57,32 +57,32 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var y;
 
 	y = cdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a nonpositive number for `x` and a valid `lambda`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -10.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -2.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -91,13 +91,13 @@ tape( 'if provided a negative `lambda`, the function returns `NaN`', opts, funct
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/entropy/test/test.js
index 43b7acec9f85..5f4a8d00e0a6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/entropy/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = entropy( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -63,7 +63,7 @@ tape( 'if provided a `lambda` equal to `0`, the function returns `0`', function
 	var v;
 
 	v = entropy( 0.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.js
index 0669c878d54e..0050edadbdec 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,13 +49,13 @@ tape( 'if provided a mean parameter `lambda` that is not a positive number, the
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.native.js
index 09ba95e69a61..9ae6a89a5944 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/kurtosis/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,13 +58,13 @@ tape( 'if provided a mean parameter `lambda` that is not a positive number, the
 	var v;
 
 	v = kurtosis( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.factory.js
index 76dbec3e6192..208a71fdd9ea 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.factory.js
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpmf = factory( 0.5 );
 	y = logpmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpmf = factory( NaN );
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logpmf = factory( 1.0 );
 	y = logpmf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -82,10 +82,10 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logpmf = factory( 0.4 );
 	y = logpmf( -4.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -96,19 +96,19 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	logpmf = factory( 0.4 );
 	y = logpmf( 1.3 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 1.4 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 3.2 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 4.8 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.2 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -120,10 +120,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	logpmf = factory( -1.0 );
 
 	y = logpmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.logpmf.js
index e2dc7a569bae..98d42168ac08 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.logpmf.js
@@ -46,40 +46,40 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpmf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( PINF, 0.01 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( -20.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -4.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( -1.3, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 2.4, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 0.5, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -88,13 +88,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = logpmf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.native.js
index 15c928ffe451..c2c6e290ffdf 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/logpmf/test/test.native.js
@@ -55,40 +55,40 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpmf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpmf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( PINF, 0.01 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( -20.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -4.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( -1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( -1.3, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 2.4, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpmf( 0.5, 0.5 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -97,13 +97,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', opts
 	var y;
 
 	y = logpmf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpmf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.js
index 38f65766cd4b..503821bc0b95 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mean( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.native.js
index a8980ad2bb1d..4a3cc6515502 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mean/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a mean parameter `lambda` less than `0`, the function returns
 	var v;
 
 	v = mean( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.js
index 4bb5bb2ea781..a31a54707abd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.js
@@ -41,13 +41,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `0` for `lambda`, the function returns `0`', function test( t ) {
 	var v = median( 0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -55,10 +55,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = median( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.native.js
index 2f244ac6c119..b015d123003d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/median/test/test.native.js
@@ -50,13 +50,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `0` for `lambda`, the function returns `0`', opts, function test( t ) {
 	var v = median( 0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -64,10 +64,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = median( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.factory.js
index a3d9160c2de7..78efb1fcdd57 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.factory.js
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 1.0 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,18 +70,18 @@ tape( 'if provided a nonpositive `lambda`, the created function always returns `
 	mgf = factory( -1.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.mgf.js
index b19a27afa988..a0a650414b95 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.mgf.js
@@ -47,9 +47,9 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,17 +57,17 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mgf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `t` and a valid `lambda`, the function returns `+infinity`', function test( t ) {
 	var y = mgf( PINF, 0.5 );
-	t.strictEqual( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.native.js
index c73b02bac70b..dc32a960af8c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mgf/test/test.native.js
@@ -56,9 +56,9 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,17 +66,17 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = mgf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `t` and a valid `lambda`, the function returns `+infinity`', opts, function test( t ) {
 	var y = mgf( PINF, 0.5 );
-	t.strictEqual( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.js
index 3dde516998b9..6562e6ca16f5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mode( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.native.js
index cdfacb6dd301..423981eb4ef2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/mode/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = mode( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.factory.js
index 87b6565d31fa..d078eb1ec5e4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.factory.js
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pmf = factory( 0.5 );
 	y = pmf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pmf = factory( NaN );
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	pmf = factory( 1.0 );
 	y = pmf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -81,10 +81,10 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	pmf = factory( 0.4 );
 	y = pmf( -4.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -95,19 +95,19 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	pmf = factory( 0.4 );
 	y = pmf( 1.3 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 1.4 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 3.2 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 4.8 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.2 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -119,10 +119,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	pmf = factory( -1.0 );
 
 	y = pmf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.pmf.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.pmf.js
index 7580d995d0ce..57970ff1ccc5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.pmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/pmf/test/test.pmf.js
@@ -46,40 +46,40 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pmf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pmf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `0`', function test( t ) {
 	var y = pmf( PINF, 0.01 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a negative integer for `x` and a valid `lambda`, the function returns `0`', function test( t ) {
 	var y = pmf( -20.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -4.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( -1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a non-integer for `x` and a valid `lambda`, the function returns `0`', function test( t ) {
 	var y = pmf( -1.3, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 2.4, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pmf( 0.5, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -88,13 +88,13 @@ tape( 'if provided a negative `lambda`, the function always returns `NaN`', func
 	var y;
 
 	y = pmf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pmf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.factory.js
index 8e41d03be064..77a8b667cfa9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.factory.js
@@ -53,11 +53,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -68,10 +68,10 @@ tape( 'if provided a finite `lambda`, the function returns a function which retu
 
 	quantile = factory( 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 	quantile = factory( -1.0 );
 
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -94,11 +94,11 @@ tape( 'if provided a negative `lambda`, the created function always returns `NaN
 tape( 'if provided a finite `lambda`, the created function returns `0` for `p = 0`', function test( t ) {
 	var quantile = factory( 3.0 );
 	var y = quantile( 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	quantile = factory( 6.9 );
 	y = quantile( 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,11 +106,11 @@ tape( 'if provided a finite `lambda`, the created function returns `0` for `p =
 tape( 'if provided a finite `lambda`, the created function returns `+infinity` for `p = 1`', function test( t ) {
 	var quantile = factory( 3.0 );
 	var y = quantile( 1.0 );
-	t.strictEqual( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	quantile = factory( 6.9 );
 	y = quantile( 1.0 );
-	t.strictEqual( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.js
index 61ca047f4169..0f6df78117c3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,13 +49,13 @@ tape( 'if provided a mean parameter `lambda` that is not a positive number, the
 	var v;
 
 	v = skewness( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.native.js
index 94ce5cea0920..aede169b0c2e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/skewness/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,13 +58,13 @@ tape( 'if provided a mean parameter `lambda` that is not a positive number, the
 	var v;
 
 	v = skewness( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.js
index f81a9134019f..233ffecf5dc0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a mean parameter `lambda` that is a negative number, the func
 	var v;
 
 	v = stdev( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.native.js
index c6783692c941..7399106c90bc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/stdev/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a mean parameter `lambda` that is a negative number, the func
 	var v;
 
 	v = stdev( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.js
index 15bd87226997..510ba698ea3e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = variance( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.native.js
index 7ba7e73ab7ac..926a0a88bd8c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/variance/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `lambda`, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a mean parameter `lambda` that is not a nonnegative number, t
 	var v;
 
 	v = variance( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.cdf.js
index 2ade7edb1477..e030c38ca529 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.cdf.js
@@ -46,21 +46,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -68,10 +68,10 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', function tes
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.factory.js
index ceff6b646142..8246d54764d4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.factory.js
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.5 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	cdf = factory( 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -82,7 +82,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	cdf = factory( 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,14 +94,14 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	cdf = factory( -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.native.js
index f26acaea931e..098c443ef734 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/cdf/test/test.native.js
@@ -55,21 +55,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -77,10 +77,10 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.js
index 3b3153e968c7..f64090e7590e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = entropy( NaN );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,13 +51,13 @@ tape( 'if provided a scale `sigma` that is not a positive number, the function r
 	var sigma;
 
 	sigma = entropy( 0.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = entropy( -1.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = entropy( NINF );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.native.js
index 5bb6fe9ca323..2579ea16f980 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/entropy/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var sigma = entropy( NaN );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,13 +60,13 @@ tape( 'if provided a scale `sigma` that is not a positive number, the function r
 	var sigma;
 
 	sigma = entropy( 0.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = entropy( -1.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = entropy( NINF );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.js
index 00c8fd1e4b6f..890d1fe36ff1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = kurtosis( NaN );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = kurtosis( -1.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = kurtosis( NINF );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.native.js
index 4f5359ba00cc..853cfe68a097 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/kurtosis/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var sigma = kurtosis( NaN );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = kurtosis( -1.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = kurtosis( NINF );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.factory.js
index c0713030a3b1..3b8259614916 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.factory.js
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.5 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	logcdf = factory( 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -82,7 +82,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	logcdf = factory( 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -94,14 +94,14 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	logcdf = factory( -1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.logcdf.js
index 2db379558b38..8601a1e6ceed 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.logcdf.js
@@ -46,21 +46,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -68,10 +68,10 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', function tes
 	var y;
 
 	y = logcdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.native.js
index 0754c1ae1bff..3a1a8eee8107 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logcdf/test/test.native.js
@@ -55,21 +55,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -77,10 +77,10 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = logcdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.factory.js
index 07a6cbb0277c..176f80f46b40 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.factory.js
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	logpdf = factory( 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -82,7 +82,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -94,10 +94,10 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	logpdf = factory( -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -112,16 +112,16 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	t.strictEqual( y, PINF, 'returns +Infinity for x equal to 0' );
 
 	y = logpdf( 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.logpdf.js
index 3d49e7051e76..7d8e3542e592 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.logpdf.js
@@ -46,21 +46,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -68,13 +68,13 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', function tes
 	var y;
 
 	y = logpdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'if provided `sigma` equal to `0`, the function evaluates a degenerate dis
 	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.native.js
index 6cbd40eebbe7..05028d9d9328 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/logpdf/test/test.native.js
@@ -55,21 +55,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -77,13 +77,13 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = logpdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,7 +104,7 @@ tape( 'if provided `sigma` equal to `0`, the function evaluates a degenerate dis
 	t.strictEqual( y, NINF, 'returns -infinity ' );
 
 	y = logpdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.js
index c43cbb277c2e..c5507751d1a8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var v;
 
 	v = mean( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.native.js
index eeed71601bee..cd9b7712ab1c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mean/test/test.native.js
@@ -50,16 +50,16 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var mu = mean( NaN );
-	t.strictEqual( isnan( mu ), true, 'returns NaN' );
+	t.strictEqual( isnan( mu ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a scale `sigma` that is not a nonnegative number, the function returns `NaN`', opts, function test( t ) {
 	var mu = mean( -1.0 );
-	t.strictEqual( isnan( mu ), true, 'returns NaN' );
+	t.strictEqual( isnan( mu ), true, 'returns expected value' );
 
 	mu = mean( NINF );
-	t.strictEqual( isnan( mu ), true, 'returns NaN' );
+	t.strictEqual( isnan( mu ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.js
index fd9febf8fb27..0296e391c8f1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = median( NaN );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = median( -1.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = median( NINF );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.native.js
index 771b504cf9ab..57dc0c86f53c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/median/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var result = median( NaN );
-	t.strictEqual( isnan( result ), true, 'returns NaN' );
+	t.strictEqual( isnan( result ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var result;
 
 	result = median( -1.0 );
-	t.strictEqual( isnan( result ), true, 'returns NaN' );
+	t.strictEqual( isnan( result ), true, 'returns expected value' );
 
 	result = median( NINF );
-	t.strictEqual( isnan( result ), true, 'returns NaN' );
+	t.strictEqual( isnan( result ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.factory.js
index 9b5fbbd32677..76c07a08f7de 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mgf/test/test.factory.js
@@ -48,11 +48,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.5 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -64,14 +64,14 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	mgf = factory( -1.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.js
index 864ed7b7a6bf..20e0c37f7762 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = mode( NaN );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = mode( -1.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = mode( NINF );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.native.js
index 87d365b09ec4..7c9c66b3a2aa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/mode/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var sigma = mode( NaN );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = mode( -1.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = mode( NINF );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.factory.js
index 6ee443197da4..986ca5e72b68 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.factory.js
@@ -56,11 +56,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -71,7 +71,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	pdf = factory( 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -82,7 +82,7 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	pdf = factory( 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,10 +94,10 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	pdf = factory( -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -112,16 +112,16 @@ tape( 'if `sigma` equals `0`, the created function evaluates a degenerate distri
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.native.js
index 698fac18b071..a147f4551711 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.native.js
@@ -55,21 +55,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -77,13 +77,13 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'if provided `sigma` equal to `0`, the function evaluates a degenerate dis
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 1.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.pdf.js
index 24455f41e624..fb1859e7e193 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/pdf/test/test.pdf.js
@@ -46,21 +46,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `sigma`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `sigma`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -68,13 +68,13 @@ tape( 'if provided a negative `sigma`, the function returns `NaN`', function tes
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,16 +86,16 @@ tape( 'if provided `sigma` equal to `0`, the function evaluates a degenerate dis
 	t.strictEqual( y, PINF, 'returns +infinity for x equal to 0' );
 
 	y = pdf( 1.0, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( PINF, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NINF, 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.factory.js
index 817f289e4108..81bc4eca556e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/quantile/test/test.factory.js
@@ -55,11 +55,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -70,10 +70,10 @@ tape( 'if provided a valid `sigma`, the function returns a function which return
 
 	quantile = factory( 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -85,14 +85,14 @@ tape( 'if provided a negative `sigma`, the created function always returns `NaN`
 	quantile = factory( -1.0 );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.js
index aee0fe2834eb..afb4adf6cd71 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = skewness( NaN );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a scale parameter `sigma` that is not a nonnegative number, t
 	var sigma;
 
 	sigma = skewness( -1.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = skewness( NINF );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.native.js
index eba22e8732b6..3d34fd7e5cad 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/skewness/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var sigma = skewness( NaN );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,10 +58,10 @@ tape( 'if provided a scale parameter `sigma` that is not a nonnegative number, t
 	var sigma;
 
 	sigma = skewness( -1.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = skewness( NINF );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.js
index a7be77044878..365496809ccb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = stdev( NaN );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = stdev( -1.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = stdev( NINF );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.native.js
index f74f9417c970..8949936fa557 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/stdev/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var sigma = stdev( NaN );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = stdev( -1.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = stdev( NINF );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.js
index 8683214e7e39..ee77e63db2b2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', function test( t ) {
 	var sigma = variance( NaN );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,10 +51,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = variance( -1.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = variance( NINF );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.native.js
index 3030b3a08549..9464c4d93663 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/variance/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `sigma`, the function returns `NaN`', opts, function test( t ) {
 	var sigma = variance( NaN );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,10 +60,10 @@ tape( 'if provided a scale `sigma` that is not a nonnegative number, the functio
 	var sigma;
 
 	sigma = variance( -1.0 );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	sigma = variance( NINF );
-	t.strictEqual( isnan( sigma ), true, 'returns NaN' );
+	t.strictEqual( isnan( sigma ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.cdf.js
index 959a87e4acf8..16fd05e41529 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.cdf.js
@@ -44,21 +44,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `n`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `n`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -66,16 +66,16 @@ tape( 'if not provided a positive integer for `n`, the function returns `NaN`',
 	var y;
 
 	y = cdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 6.9 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.factory.js
index 1d92f6558bf0..7589de8c65a9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/cdf/test/test.factory.js
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.5 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a valid `n`, the function returns a function which returns `1
 
 	cdf = factory( 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'if provided a valid `n`, the function returns a function which returns `0
 
 	cdf = factory( 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -92,17 +92,17 @@ tape( 'if not provided a positive integer for `n`, the created function always r
 	cdf = factory( -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 3.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.factory.js
index c52e1bee9b1e..f8cbdd306616 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.factory.js
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.5 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,7 +69,7 @@ tape( 'if provided a valid `n`, the function returns a function which returns `0
 
 	pdf = factory( 8 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -80,7 +80,7 @@ tape( 'if provided a valid `n`, the function returns a function which returns `0
 
 	pdf = factory( 8 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -92,17 +92,17 @@ tape( 'if not provided a positive integer for `n`, the created function always r
 	pdf = factory( -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 3.8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.native.js
index 512d6936838d..16e2df38edd7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.native.js
@@ -49,21 +49,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `n`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 8 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `n`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 8 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -71,13 +71,13 @@ tape( 'if not provided a positive integer for `n`, the function returns `NaN`',
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.pdf.js
index 566f29f578dc..eb1352361c3f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/pdf/test/test.pdf.js
@@ -44,21 +44,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 8 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `n`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 8 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `n`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 8 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -66,16 +66,16 @@ tape( 'if not provided a positive integer for `n`, the function returns `NaN`',
 	var y;
 
 	y = pdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 6.9 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.factory.js
index ba218baf3747..d41e480c7700 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/signrank/quantile/test/test.factory.js
@@ -54,11 +54,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 4 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -69,10 +69,10 @@ tape( 'if provided a valid `n`, the function returns a function which returns `N
 
 	quantile = factory( 4 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,22 +84,22 @@ tape( 'if provided a negative or non-integer `n`, the created function always re
 	quantile = factory( -1.0 );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 2.3 );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF );
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.cdf.js
index df47fcbe2242..7a08bbd830a7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.cdf.js
@@ -42,19 +42,19 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 3.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 1.0, NaN, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 1.0, 3.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `r < 2` or `v < 2`, the function returns `NaN`', function test( t ) {
 	var y = cdf( 2.5, 1.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 2.5, 3.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.factory.js
index 53b17dd71073..af813cb39eac 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/cdf/test/test.factory.js
@@ -54,23 +54,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 2.5, 3.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 3.0 );
 	y = cdf( 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 3.0, NaN );
 	y = cdf( 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -81,15 +81,15 @@ tape( 'if provided `r < 2` or `v < 2`, the created function returns `NaN`', func
 
 	cdf = factory( 1.5, 2.0 );
 	y = cdf( 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 2.0, 1.5 );
 	y = cdf( 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.5, 1.5 );
 	y = cdf( 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -100,7 +100,7 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	cdf = factory( 3.0, 2.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -111,16 +111,16 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	cdf = factory( 3.0, 2.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -2.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -0.1 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.factory.js
index c2fc70b29a66..5ca7b123d41d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.factory.js
@@ -53,23 +53,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 2.5, 3.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 3.0 );
 	y = cdf( 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 3.0, NaN );
 	y = cdf( 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -80,15 +80,15 @@ tape( 'if provided `r < 2` or `v < 2`, the created function returns `NaN`', func
 
 	cdf = factory( 1.5, 2.0 );
 	y = cdf( 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 2.0, 1.5 );
 	y = cdf( 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.5, 1.5 );
 	y = cdf( 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	quantile = factory( 3.0, 2.0 );
 	y = quantile( 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -121,10 +121,10 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	quantile = factory( 3.0, 3.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.quantile.js
index a6c3b1488bf7..d56b8f3e43ad 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/studentized-range/quantile/test/test.quantile.js
@@ -42,11 +42,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = quantile( NaN, 3.0, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.7, NaN, 3.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.7, 3.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.cdf.js
index 4bf606953287..9ff43c4bfec4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.cdf.js
@@ -47,21 +47,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `v`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `v`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -69,16 +69,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', functi
 	var y;
 
 	y = cdf( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.factory.js
index efe3bbdee9dc..37c49a3d7406 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/cdf/test/test.factory.js
@@ -57,11 +57,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'if provided a valid `v`, the function returns a function which returns `1
 
 	cdf = factory( 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `v`, the function returns a function which returns `0
 
 	cdf = factory( 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -114,15 +114,15 @@ tape( 'if provided a nonpositive `v`, the created function always returns `NaN`'
 	cdf = factory( 0.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.js
index 77c2def96ce6..6c29341227f6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -51,13 +51,13 @@ tape( 'if provided a degrees of freedom `v` that is not a positive number, the f
 	var v;
 
 	v = entropy( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.native.js
index b4be31a82041..89561b4d9556 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/entropy/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,13 +60,13 @@ tape( 'if provided a degrees of freedom `v` that is not a positive number, the f
 	var v;
 
 	v = entropy( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.js
index bd5b9bcb1dcb..16d31d4780ea 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,32 +50,32 @@ tape( 'if provided `v <= 2`, the function returns `NaN`', function test( t ) {
 	var v;
 
 	v = kurtosis( 2.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `2 < v <= 4`, the function returns `infinity`', function test( t ) {
 	var v = kurtosis( 2.5 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = kurtosis( 3.0 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = kurtosis( 4.0 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.native.js
index 589234b43ecc..b6aea4e06fc4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/kurtosis/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,32 +59,32 @@ tape( 'if provided `v <= 2`, the function returns `NaN`', opts, function test( t
 	var v;
 
 	v = kurtosis( 2.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `2 < v <= 4`, the function returns `infinity`', opts, function test( t ) {
 	var v = kurtosis( 2.5 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = kurtosis( 3.0 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = kurtosis( 4.0 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.factory.js
index 106df4154f20..1e711105ac85 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.factory.js
@@ -58,11 +58,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -73,7 +73,7 @@ tape( 'if provided a valid `v`, the function returns a function which returns `0
 
 	logcdf = factory( 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'if provided a valid `v`, the function returns a function which returns `-
 
 	logcdf = factory( 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -115,15 +115,15 @@ tape( 'if provided a nonpositive `v`, the created function always returns `NaN`'
 	logcdf = factory( 0.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.logcdf.js
index 26b594d2b6e3..96b11ec68aa3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logcdf/test/test.logcdf.js
@@ -48,21 +48,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `v`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `v`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -85,16 +85,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', functi
 	var y;
 
 	y = logcdf( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.factory.js
index 9c6538a614ba..cd039d17fab6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.factory.js
@@ -57,11 +57,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'if provided a finite `v`, the function returns a function which returns `
 
 	logpdf = factory( 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `v`, the function returns a function which returns `
 
 	logpdf = factory( 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'if provided `+infinity` for `v`, the function returns a function which re
 	logpdf = factory( PINF );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -116,15 +116,15 @@ tape( 'if provided a nonpositive `v`, the created function always returns `NaN`'
 	logpdf = factory( 0.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.logpdf.js
index de4d0bb43fd0..2ab69fd0ec61 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.logpdf.js
@@ -47,21 +47,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `v`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `v`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -69,16 +69,16 @@ tape( 'if provided `Infinity` for `v`, the function returns `NaN`', function tes
 	var y;
 
 	y = logpdf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -87,16 +87,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', functi
 	var y;
 
 	y = logpdf( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.native.js
index 9ce84a8a2d7a..52872236683f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/logpdf/test/test.native.js
@@ -56,21 +56,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `Infinity` for `x` and a finite `v`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-Infinity` for `x` and a finite `v`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -78,16 +78,16 @@ tape( 'if provided `Infinity` for `v`, the function returns `NaN`', opts, functi
 	var y;
 
 	y = logpdf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -96,16 +96,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', opts,
 	var y;
 
 	y = logpdf( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.js
index 9df01383e313..22d3a1c97184 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a degrees of freedom `v` that is not a nonnegative number, th
 	var v;
 
 	v = mean( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.native.js
index 78c605af442d..7c90e43ff028 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/mean/test/test.native.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', opts, function test( t ) {
 	var y = mean( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,16 +57,16 @@ tape( 'if provided `v <= 1`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mean( 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.js
index b5660e917ff8..e1dcc8c46591 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = median( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a degrees of freedom `v` that is not a nonnegative number, th
 	var v;
 
 	v = median( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.native.js
index 3e45e55a8fda..2d7bb06cf2a5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/median/test/test.native.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for the parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = median( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,10 +57,10 @@ tape( 'if provided a negative value for `v`, the function returns `NaN`', opts,
 	var y;
 
 	y = median( -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( -0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.js
index 056412163d74..634c09dc6be1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,10 +49,10 @@ tape( 'if provided a degrees of freedom `v` that is not a nonnegative number, th
 	var v;
 
 	v = mode( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.native.js
index 2d8c517ae144..89cdf9d2aca0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/mode/test/test.native.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for the parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mode( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -57,10 +57,10 @@ tape( 'if provided a negative value for `v`, the function returns `NaN`', opts,
 	var y;
 
 	y = mode( -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( -0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.factory.js
index 3758ace40e08..4a0a880677da 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.factory.js
@@ -57,11 +57,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -72,7 +72,7 @@ tape( 'if provided a finite `v`, the function returns a function which returns `
 
 	pdf = factory( 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `v`, the function returns a function which returns `
 
 	pdf = factory( 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -95,16 +95,16 @@ tape( 'if provided `+infinity` for `v`, the function returns a function which re
 	pdf = factory( PINF );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -116,15 +116,15 @@ tape( 'if provided a nonpositive `v`, the created function always returns `NaN`'
 	pdf = factory( 0.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.native.js
index b9a018c5fe37..6f0693e3bb68 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.native.js
@@ -56,21 +56,21 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `v`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `v`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -78,16 +78,16 @@ tape( 'if provided `+infinity` for `v`, the function returns `NaN`', opts, funct
 	var y;
 
 	y = pdf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -96,16 +96,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', opts,
 	var y;
 
 	y = pdf( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.pdf.js
index 51c81f6bdc7e..8a5cf510d857 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/pdf/test/test.pdf.js
@@ -47,21 +47,21 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `v`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `v`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -69,16 +69,16 @@ tape( 'if provided `+infinity` for `v`, the function returns `NaN`', function te
 	var y;
 
 	y = pdf( 0.0, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( PINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -87,16 +87,16 @@ tape( 'if provided a nonpositive `v`, the function always returns `NaN`', functi
 	var y;
 
 	y = pdf( 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.factory.js
index 3fed6d0d5797..5476bb1fc95b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/quantile/test/test.factory.js
@@ -53,11 +53,11 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -68,10 +68,10 @@ tape( 'if provided a finite `v`, the function returns a function which returns `
 
 	quantile = factory( 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,15 +83,15 @@ tape( 'if provided a nonpositive `v`, the created function always returns `NaN`'
 	quantile = factory( 0.0 );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( -1.0 );
 
 	y = quantile( 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.js
index 5aa02b101d54..21417cba5dd6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.js
@@ -41,7 +41,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -49,22 +49,22 @@ tape( 'if provided a degrees of freedom `v <= 3`, the function returns `NaN`', f
 	var v;
 
 	v = skewness( 3.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 2.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.native.js
index 05f9497e3968..717ace77d2dc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/skewness/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,22 +58,22 @@ tape( 'if provided a degrees of freedom `v <= 3`, the function returns `NaN`', o
 	var v;
 
 	v = skewness( 3.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 2.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 0.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.js
index 9844e6a79a1b..5793154f7dc7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,23 +50,23 @@ tape( 'if provided a degrees of freedom `v` that is not a nonnegative number, th
 	var v;
 
 	v = stdev( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `1 < v <= 2`, the function returns `infinity`', function test( t ) {
 	var v = stdev( 1.5 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = stdev( 1.1 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = stdev( 2.0 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.native.js
index 1985695ab12b..a423bde3189c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/stdev/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -59,23 +59,23 @@ tape( 'if provided a degrees of freedom `v` that is not a nonnegative number, th
 	var v;
 
 	v = stdev( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `1 < v <= 2`, the function returns `infinity`', opts, function test( t ) {
 	var v = stdev( 1.5 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = stdev( 1.1 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = stdev( 2.0 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.js
index 98520ffe80e2..bd88e36040ec 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for `v`, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,23 +50,23 @@ tape( 'if provided a degrees of freedom `v` that is not a nonnegative number, th
 	var v;
 
 	v = variance( -1.0 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( NINF );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `1 < v <= 2`, the function returns `infinity`', function test( t ) {
 	var v = variance( 1.5 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = variance( 1.1 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	v = variance( 2.0 );
-	t.strictEqual( v, PINF, 'returns infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.native.js
index 9b96bcaaf04d..d678788cc4d6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/variance/test/test.native.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for the parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = variance( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,13 +60,13 @@ tape( 'if provided `v <= 1`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = variance( 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -75,13 +75,13 @@ tape( 'if provided `1 < v <= 2`, the function returns `Infinity`', opts, functio
 	var y;
 
 	y = variance( 2.0 );
-	t.strictEqual( y, PINF, 'returns Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = variance( 1.5 );
-	t.strictEqual( y, PINF, 'returns Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = variance( 1.1 );
-	t.strictEqual( y, PINF, 'returns Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.cdf.js
index 5f286ee0bf3e..5e97c2bba57c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.cdf.js
@@ -46,25 +46,25 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a`, `b` and `c`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a`, `b` and `c`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -72,16 +72,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = cdf( 2.0, -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.factory.js
index 1d81fa5a1075..5171cb561fd0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.factory.js
@@ -56,39 +56,39 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0, 0.5 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0, 0.5 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NaN, 0.5 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN, 0.5 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN, 0.5 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'if provided a valid `a`, `b` and `c`, the function returns a function whi
 
 	cdf = factory( 0.0, 1.0, 0.5 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0, 0.5 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -122,34 +122,34 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the created function
 	cdf = factory( 2.0, 1.0, 0.5 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF, 0.5 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF, 0.5 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF, 0.5 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -1.0, -2.0, 0.5 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -10.0, 10.0, 12.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -10.0, 10.0, -12.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.native.js
index c7438ba29df2..dd5eccb9a9f7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/cdf/test/test.native.js
@@ -55,25 +55,25 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a`, `b` and `c`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a`, `b` and `c`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -81,16 +81,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = cdf( 2.0, -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.js
index f251abf9dca7..221ecb533b72 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = entropy( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.native.js
index 4b7a185b9d80..4e294fa22b4f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/entropy/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = entropy( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.js
index 1df20eba6f75..c00f33f71325 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = kurtosis( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.native.js
index 4453403dd334..665db690fdad 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/kurtosis/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = kurtosis( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.factory.js
index 43dfb36cb0d9..a7970169abd8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.factory.js
@@ -56,39 +56,39 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0, 0.5 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0, 0.5 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, NaN, 0.5 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN, 0.5 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN, 0.5 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -99,7 +99,7 @@ tape( 'if provided a valid `a`, `b` and `c`, the function returns a function whi
 
 	logcdf = factory( 0.0, 1.0, 0.5 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -110,7 +110,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0.0, 1.0, 0.5 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -122,34 +122,34 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the created function
 	logcdf = factory( 2.0, 1.0, 0.5 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, NINF, 0.5 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF, 0.5 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF, 0.5 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -1.0, -2.0, 0.5 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -10.0, 10.0, 12.0 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -10.0, 10.0, -12.0 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.logcdf.js
index 3800a4ee2330..46376c677e22 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.logcdf.js
@@ -46,29 +46,29 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 1.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a`, `b` and `c`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a`, `b` and `c`, the function returns `-infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -76,16 +76,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = logcdf( 2.0, -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.native.js
index cc1f473efd83..e87be0092bf9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logcdf/test/test.native.js
@@ -55,29 +55,29 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 1.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a`, `b` and `c`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a`, `b` and `c`, the function returns `-infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -85,16 +85,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = logcdf( 2.0, -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.factory.js
index 89ab855b91dd..98e211543d08 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.factory.js
@@ -57,45 +57,45 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0, 0.5 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0, 0.5 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NaN, 0.5 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN, 0.5 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN, 0.5 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN, NaN );
 
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,13 +106,13 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	logpdf = factory( -10.0, 10.0, 0.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 20.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 11.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -123,13 +123,13 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	logpdf = factory( -10.0, 10.0, 0.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -100.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -11.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -141,26 +141,26 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the created function
 	logpdf = factory( 0.0, -1.0, 0.5 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF, 0.5 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF, 0.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, 10.0, 20.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, 10.0, -10.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.logpdf.js
index e1723fecca80..d655c95aa21a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.logpdf.js
@@ -47,42 +47,42 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided a number greater than `b` for `x` and valid parameters, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 20.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 2.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 1.1, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number smaller than `a` for `x` and valid parameters, the function returns `-infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -20.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -2.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -0.5, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -91,16 +91,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = logpdf( 2.0, 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, 3.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, 3.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.native.js
index 81e15ccf6162..7ce0487f86c2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/logpdf/test/test.native.js
@@ -56,48 +56,48 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 1.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number greater than `b` for `x` and valid parameters, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 20.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 2.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( 1.1, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number smaller than `a` for `x` and valid parameters, the function returns `-infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -20.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -2.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logpdf( -0.5, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,16 +106,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = logpdf( 2.0, 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, 3.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, 3.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.js
index e23eb6114bdf..8e3e2b8f346d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = mean( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.native.js
index 9ca692899603..9b0176024978 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mean/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = mean( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.native.js
index 5dffa7fd7f16..5c9557c338e9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mgf/test/test.native.js
@@ -57,13 +57,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -71,16 +71,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = mgf( 2.0, -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.js
index 235960741d12..2111a5d5184c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = mode( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.native.js
index ee10045df6c6..5cd6995b3d8e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/mode/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = mode( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.factory.js
index a0014f160a0d..72d08649912a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.factory.js
@@ -56,45 +56,45 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0, 0.5 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0, 0.5 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NaN, 0.5 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN, 0.5 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN, 0.5 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN, NaN );
 
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -105,13 +105,13 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	pdf = factory( -10.0, 10.0, 0.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 20.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 11.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -122,13 +122,13 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	pdf = factory( -10.0, 10.0, 0.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -100.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -11.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -140,26 +140,26 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the created function
 	pdf = factory( 0.0, -1.0, 0.5 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF, 0.5 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF, 0.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, 10.0, 20.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, 10.0, -10.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.native.js
index 051fbe3fb080..166d3d06e2cc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.native.js
@@ -55,48 +55,48 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 1.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number greater than `b` for `x` and valid parameters, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 20.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 2.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 1.1, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number smaller than `a` for `x` and valid parameters, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -20.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -2.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -105,16 +105,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = pdf( 2.0, 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, 3.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, 3.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.pdf.js
index 468b9ca020bc..467957793a1a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/pdf/test/test.pdf.js
@@ -46,48 +46,48 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 1.0, NaN, 0.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number greater than `b` for `x` and valid parameters, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 20.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 2.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 1.1, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number smaller than `a` for `x` and valid parameters, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -20.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -2.0, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -0.5, 0.0, 1.0, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -96,16 +96,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = pdf( 2.0, 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, 3.0, 4.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, 3.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.factory.js
index b88dd01b86a6..b516ec3dd85d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/quantile/test/test.factory.js
@@ -56,31 +56,31 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0, 0.5 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0, 0.5 );
 	y = quantile( 0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN, 0.5 );
 	y = quantile( 0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, 1.0, NaN );
 	y = quantile( 0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN, 0.5 );
 	y = quantile( 0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 0.0, NaN, NaN );
 	y = quantile( 0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0, NaN );
 	y = quantile( 0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -91,10 +91,10 @@ tape( 'if provided valid parameters, the function returns a function which retur
 
 	quantile = factory( 0.0, 1.0, 0.5 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,18 +106,18 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the created function
 	quantile = factory( 1.0, 0.0, 0.5 );
 
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, 2.0, 3.0 );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF, 0.0 );
 	y = quantile( 0.2 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.js
index bb7dd4f1a18a..303c8ddb6b39 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = skewness( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.native.js
index fe67e3aacb1a..8df245cc9144 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/skewness/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = skewness( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.js
index 10f6b83b1f5a..7b9362234a0f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = stdev( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.native.js
index 4569cc881d81..db4a41528ebc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/stdev/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = stdev( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.js
index 9ac81b9d7b32..4003819427ff 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.js
@@ -42,13 +42,13 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -57,16 +57,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = variance( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.native.js
index b6a55406d12f..552aa4afdd75 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/variance/test/test.native.js
@@ -51,13 +51,13 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 1.0, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 0.0, NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 0.0, 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -66,16 +66,16 @@ tape( 'if provided parameters not satisfying `a <= c <= b`, the function returns
 	var y;
 
 	y = variance( -1.0, -1.1, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 3.0, 2.0, 2.5 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 0.0, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 0.0, 1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.cdf.js
index 942ee9a3da87..0dda57f38cc9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = cdf( 2.0, -1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -0.5, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.factory.js
index 61338c1ab5cd..74ca704e8eed 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0.0, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	cdf = factory( 0, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a `a >= b`, the created function always returns `NaN`', funct
 	cdf = factory( 2.0, 1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -1.0, -2.0 );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.native.js
index f7d825b5ff1d..3c0dc9338e68 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = cdf( 2.0, -1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -0.5, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.js
index 19ff5d3b8325..100b9aac6d93 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = entropy( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.native.js
index eb2c4eeedd59..04b0577e32b0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/entropy/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = entropy( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.js
index a24080fb1908..545389140143 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.js
@@ -38,10 +38,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -50,16 +50,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = kurtosis( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.native.js
index d442483889ed..44b260edc7bd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/kurtosis/test/test.native.js
@@ -47,10 +47,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -59,16 +59,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = kurtosis( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.factory.js
index 8e14a89b12ea..4279b3c8cdfe 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0.0, 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	logcdf = factory( 0, 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided a `a >= b`, the created function always returns `NaN`', funct
 	logcdf = factory( 2.0, 1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.0, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -1.0, -2.0 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.logcdf.js
index fb2358d3bed5..4e92429cffe1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logcdf( 2.0, -1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -0.5, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.native.js
index 4d80bf52635f..100673279755 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logcdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a valid `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = logcdf( 2.0, -1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -0.5, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.factory.js
index 5909c14bda97..55e6a02dc91f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 0.0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `a` and `b`, the function returns a function which re
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `a` and `b`, the function returns a function which re
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	logpdf = factory( 0.0, -1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 0.0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.logpdf.js
index 311c8740fedb..fdf44ecd7634 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.logpdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logpdf( 2.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.native.js
index 940080b23744..3bb14400e2e9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/logpdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a valid `a` and `b`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = logpdf( 2.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.js
index 35007e595803..dfed5d0d32b5 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.native.js
index 065f9f6f1135..7f323090397a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/mean/test/test.native.js
@@ -55,10 +55,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var v;
 
 	v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -67,16 +67,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mean( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.js
index c4f760d9b04b..237c60bae3a2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = median( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.native.js
index 6e0e9170dd3d..48bcb0f440fa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/median/test/test.native.js
@@ -55,10 +55,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var v;
 
 	v = median( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -67,16 +67,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = median( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.factory.js
index 14ce7bf627df..b85d4459f4c1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 0.0, 1.0 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,26 +84,26 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	mgf = factory( 0.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 0.0, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -114,11 +114,11 @@ tape( 'if provided valid parameters `a` and `b`, the created function returns `1
 
 	mgf = factory( 0.2, 0.4 );
 	y = mgf( 0.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	mgf = factory( 0.0, 10.0 );
 	y = mgf( 0.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.mgf.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.mgf.js
index 8aa448a6773b..21ad52ebb807 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.mgf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.mgf.js
@@ -46,11 +46,11 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -58,16 +58,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mgf( 2.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,13 +76,13 @@ tape( 'if provided valid parameters, the function returns `1` for `t = 0`', func
 	var y;
 
 	y = mgf( 0.0, 2.0, 4.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, 1.0, 2.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, 0.2, 0.8 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.native.js
index 27ecfb2863d5..acc51ccb022d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/mgf/test/test.native.js
@@ -55,11 +55,11 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = mgf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = mgf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -67,16 +67,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mgf( 2.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0, 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -85,13 +85,13 @@ tape( 'if provided valid parameters, the function returns `1` for `t = 0`', opts
 	var y;
 
 	y = mgf( 0.0, 2.0, 4.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, 1.0, 2.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = mgf( 0.0, 0.2, 0.8 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.factory.js
index 2a25eb2e508b..4bfb4bf3e6ce 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 0.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,26 +106,26 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	pdf = factory( 0.0, -1.0 );
 
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 0.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.native.js
index a2af03e92c98..e83cdbdd97db 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = pdf( 2.0, -1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 0.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -0.5, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.pdf.js
index dfa8e3e1900b..eb290cafef06 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,16 +70,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pdf( 2.0, 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.factory.js
index eea82f236e93..8c5444fe98eb 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a finite `a` and `b`, the function returns a function which r
 
 	quantile = factory( 0.0, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,18 +98,18 @@ tape( 'if provided `a >= b`, the created function always returns `NaN`', functio
 	quantile = factory( 1.0, 0.5 );
 
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 0.3 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.js
index 8faa2cf52670..02a8b62aa2e6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.js
@@ -38,10 +38,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -50,16 +50,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -74,7 +74,7 @@ tape( 'the function returns `0.0` as the skewness of a uniform distribution ', f
 		a = ( randu()*10.0 );
 		b = ( randu()*10.0 ) + a;
 		v = skewness( a, b );
-		t.strictEqual( v, 0.0, 'returns 0.0' );
+		t.strictEqual( v, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.native.js
index 3bf2e0154de2..ffc391ee912b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/skewness/test/test.native.js
@@ -48,10 +48,10 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 	var v;
 
 	v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -60,16 +60,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = skewness( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.js
index 839d96f9eb43..9cac66399f01 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = stdev( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.native.js
index d86c3d2f215e..667084217552 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = stdev( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.js
index be21788dcc23..fe27f75dfbfa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,16 +56,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = variance( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.native.js
index 3403c69695e8..4ec9a1e4298b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,16 +65,16 @@ tape( 'if provided `a >= b`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = variance( 3.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 2.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.cdf.js
index c18993485c13..67a08e46e832 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.cdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `lambda`, the function returns `NaN`', function
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,25 +97,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', function test
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1/0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.factory.js
index 3c43150c63c9..049f9ae665a9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	cdf = factory( 1.0, 1.0 );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, 1.0 );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NaN );
 	y = cdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( PINF );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	cdf = factory( 0.5, 1.0 );
 	y = cdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `k`, the created function always returns `NaN`'
 	cdf = factory( 0.0, 1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( -1.0, 1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -145,34 +145,34 @@ tape( 'if provided a nonpositive `lambda`, the created function always returns `
 	cdf = factory( 0.5, 0.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 0.5, -1.0 );
 
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( 1.0, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( PINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NINF, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	cdf = factory( NaN, NINF );
 	y = cdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.native.js
index c69959167c18..7992bcb2bca0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/cdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = cdf( NaN, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = cdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `lambda`, the function returns `NaN`', opts, fu
 	var y;
 
 	y = cdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,25 +106,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = cdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 0.0, -1/0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = cdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.js
index 14f5f947fbbf..e74ad3a5db27 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.native.js
index aaa4560425c1..75a9e74ce5ab 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/entropy/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = entropy( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = entropy( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = entropy( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = entropy( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = entropy( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.js
index 7179049026a1..ea538bbd0521 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.native.js
index 774d4fd03e70..54e2c3a79262 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/kurtosis/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = kurtosis( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = kurtosis( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = kurtosis( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = kurtosis( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = kurtosis( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.factory.js
index 07ae6d1a6aec..d991edd11a6f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logcdf = factory( 1.0, 1.0 );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, 1.0 );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NaN );
 	y = logcdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	logcdf = factory( 0.5, 1.0 );
 	y = logcdf( NINF );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -106,34 +106,34 @@ tape( 'if provided a nonpositive `k`, the created function always returns `NaN`'
 	logcdf = factory( 0.0, 1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( -1.0, 1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, 0.0 );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, PINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NaN );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -145,34 +145,34 @@ tape( 'if provided a nonpositive `lambda`, the created function always returns `
 	logcdf = factory( 0.5, 0.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 0.5, -1.0 );
 
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( 1.0, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( PINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NINF, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logcdf = factory( NaN, NINF );
 	y = logcdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.logcdf.js
index ac06c0e3e4c0..30aea0998bf2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.logcdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logcdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `-Infinity`', function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns 0' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided a nonpositive `lambda`, the function returns `NaN`', function
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,25 +97,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', function test
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1/0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.native.js
index f85264300786..19635e920812 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logcdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logcdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logcdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns 0' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided a nonpositive `lambda`, the function returns `NaN`', opts, fu
 	var y;
 
 	y = logcdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,25 +106,25 @@ tape( 'if provided a nonpositive `k`, the function returns `NaN`', opts, functio
 	var y;
 
 	y = logcdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 0.0, -1/0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logcdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.factory.js
index e72682e697c6..f56f4c86dd34 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.factory.js
@@ -57,23 +57,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	logpdf = factory( 1.0, 1.0 );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NaN );
 	y = logpdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( PINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -95,7 +95,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	logpdf = factory( 0.5, 1.0 );
 	y = logpdf( NINF );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
@@ -107,33 +107,33 @@ tape( 'if provided `k <= 0`, the created function always returns `NaN`', functio
 	logpdf = factory( 0.0, 1.0 );
 
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( -1.0, 1.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, 1.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, PINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NaN );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -144,33 +144,33 @@ tape( 'if provided `lambda <= 0`, the created function always returns `NaN`', fu
 
 	logpdf = factory( 1.0, 0.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, -1.0 );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( 1.0, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( PINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NINF, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	logpdf = factory( NaN, NINF );
 	y = logpdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -195,7 +195,7 @@ tape( 'if provided a positive `lambda` and `k` not equal to one, the  created fu
 
 	logpdf = factory( 2.0, 1.0 );
 	y = logpdf( 0.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.logpdf.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.logpdf.js
index 06e8745389ff..4029b11a1dbc 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.logpdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.logpdf.js
@@ -47,23 +47,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -71,25 +71,25 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,25 +98,25 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = logpdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -135,7 +135,7 @@ tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` equal to one, the
 
 tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` not equal to one, the function returns `-Infinity`', function test( t ) {
 	var y = logpdf( 0.0, 2.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.native.js
index 4113f3317484..87c03d644097 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/logpdf/test/test.native.js
@@ -56,23 +56,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = logpdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = logpdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -80,25 +80,25 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = logpdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, 2.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -107,25 +107,25 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = logpdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = logpdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -144,7 +144,7 @@ tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` equal to one, the
 
 tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` not equal to one, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpdf( 0.0, 2.0, 1.0 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.js
index 3c3159bf33c4..cd47f335ed5b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.native.js
index 21d8f82e2558..97115cb84d24 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mean/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mean( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mean( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mean( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = mean( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mean( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.js
index 41e2c7575c2e..46cf9736a9e7 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = median( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.native.js
index 0fb0c5922348..ecc1ddb699d3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/median/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = median( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = median( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = median( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = median( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = median( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.factory.js
index dbcc55334efe..2e81fea327b4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.factory.js
@@ -49,23 +49,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	mgf = factory( 1.0, 1.0 );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, 1.0 );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.0, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NaN );
 	y = mgf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,31 +77,31 @@ tape( 'if provided a nonpositive `k`, the created function always returns `NaN`'
 	mgf = factory( 1.0, 0.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.0, -1.0 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( 1.0, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( PINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NaN, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -113,31 +113,31 @@ tape( 'if provided a nonpositive `lambda`, the created function always returns `
 	mgf = factory( 0.0, 0.5 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( -1.0, 0.5 );
 
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mgf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, 1.0 );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, PINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NINF );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	mgf = factory( NINF, NaN );
 	y = mgf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.js
index 0bae2c9a8a3a..1bcdc8a2b0b0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,10 +56,10 @@ tape( 'if provided `0 < k <= 1` and `lambda > 0`, the function returns `0`', fun
 	var y;
 
 	y = mode( 0.3, 2.0 );
-	t.strictEqual( y, 0.0, 'returns NaN' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = mode( 0.9, 2.0 );
-	t.strictEqual( y, 0.0, 'returns NaN' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -68,19 +68,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,19 +89,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.native.js
index a72b63f4d159..521a13660539 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/mode/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = mode( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = mode( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,10 +65,10 @@ tape( 'if provided `0 < k <= 1` and `lambda > 0`, the function returns `0`', opt
 	var y;
 
 	y = mode( 0.3, 2.0 );
-	t.strictEqual( y, 0.0, 'returns NaN' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = mode( 0.9, 2.0 );
-	t.strictEqual( y, 0.0, 'returns NaN' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = mode( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -98,19 +98,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = mode( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = mode( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.factory.js
index 1dd7eac2d795..1c16ebd21603 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	pdf = factory( 1.0, 1.0 );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NaN );
 	y = pdf( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,7 +83,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( PINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -94,7 +94,7 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	pdf = factory( 0.5, 1.0 );
 	y = pdf( NINF );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
@@ -105,33 +105,33 @@ tape( 'if provided `k <= 0`, the created function always returns `NaN`', functio
 
 	pdf = factory( 0.0, 0.5 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( -1.0, 0.5 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, 1.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, PINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NaN );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -142,33 +142,33 @@ tape( 'if provided `lambda <= 0`, the created function always returns `NaN`', fu
 
 	pdf = factory( 1.0, 0.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, -1.0 );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( 1.0, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( PINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NINF, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	pdf = factory( NaN, NINF );
 	y = pdf( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -193,7 +193,7 @@ tape( 'if provided a positive `lambda` and `k` not equal to one, the  created fu
 
 	pdf = factory( 2.0, 1.0 );
 	y = pdf( 0.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.native.js
index 3d86f15f82fe..b3fcb7277e84 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', opts, function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -79,25 +79,25 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = pdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -106,25 +106,25 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -143,7 +143,7 @@ tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` equal to one, the
 
 tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` not equal to one, the function returns `0`', opts, function test( t ) {
 	var y = pdf( 0.0, 2.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.pdf.js
index db39b1371351..c6c4e678f14a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/pdf/test/test.pdf.js
@@ -46,23 +46,23 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var y = pdf( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = pdf( 0.0, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `x` and a finite `lambda` and `k`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 1.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -70,25 +70,25 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = pdf( 2.0, 0.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,25 +97,25 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = pdf( 2.0, 2.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 0.0, 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = pdf( 2.0, NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -134,7 +134,7 @@ tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` equal to one, the
 
 tape( 'if provided `0.0` for `x`, a positive `lambda` and `k` not equal to one, the function returns `0`', function test( t ) {
 	var y = pdf( 0.0, 2.0, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.factory.js
index 25f349c60947..764f9bdc8a47 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.factory.js
@@ -56,23 +56,23 @@ tape( 'if provided `NaN` for any parameter, the created function returns `NaN`',
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, 1.0 );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NaN );
 	y = quantile( NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -83,10 +83,10 @@ tape( 'if provided a valid `lambda` and `k`, the function returns a function whi
 
 	quantile = factory( 1.0, 1.0 );
 	y = quantile( -0.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 1.1 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -97,33 +97,33 @@ tape( 'if provided a nonpositive `k`, the created function always returns `NaN`'
 
 	quantile = factory( 1.0, 0.0 );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, -1.0 );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( 1.0, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( PINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NaN, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -134,33 +134,33 @@ tape( 'if provided a nonpositive `lambda`, the created function always returns `
 
 	quantile = factory( 0.0, 0.5 );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( -1.0, 0.5 );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, 1.0 );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, PINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NINF );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	quantile = factory( NINF, NaN );
 	y = quantile( 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.native.js
index df1751bf76df..01979a730a2d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/quantile/test/test.native.js
@@ -55,23 +55,23 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NaN, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.5, NaN, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	y = quantile( 0.5, 1.0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+infinity` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( PINF, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity` for `p`, the function returns `NaN`', opts, function test( t ) {
 	var y = quantile( NINF, 1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -79,16 +79,16 @@ tape( 'if provided `k <= 0` or `lambda <= 0`, the function returns `NaN`', opts,
 	var y;
 
 	y = quantile( 0.5, -1.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 1.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 0.0, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = quantile( 0.5, 1.0, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.js
index bde508eda493..f636c98841da 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.js
@@ -43,10 +43,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -55,19 +55,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -76,19 +76,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.native.js
index 26eab9beabdf..55cf3362ea22 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/test/test.native.js
@@ -52,10 +52,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = skewness( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = skewness( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -64,19 +64,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = skewness( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -85,19 +85,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = skewness( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = skewness( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.js
index 147477e04626..52b4b83f792a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.native.js
index 4e4e8e80cce7..4495f489335e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/stdev/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = stdev( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = stdev( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = stdev( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = stdev( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = stdev( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.js
index 03eba79a271f..68a561eb50fd 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.js
@@ -44,10 +44,10 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -56,19 +56,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', function test( t ) {
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,19 +77,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', function test( t
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.native.js
index c115609ef707..df7f8bf7490e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/variance/test/test.native.js
@@ -53,10 +53,10 @@ tape( 'main export is a function', opts, function test( t ) {
 
 tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, function test( t ) {
 	var v = variance( NaN, 0.5 );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	v = variance( 10.0, NaN );
-	t.strictEqual( isnan( v ), true, 'returns NaN' );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -65,19 +65,19 @@ tape( 'if provided `k <= 0`, the function returns `NaN`', opts, function test( t
 	var y;
 
 	y = variance( -1.0, 2.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, 1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, PINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NaN );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -86,19 +86,19 @@ tape( 'if provided `lambda <= 0`, the function returns `NaN`', opts, function te
 	var y;
 
 	y = variance( 2.0, -1.0 );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( 1.0, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( PINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NINF, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	y = variance( NaN, NINF );
-	t.strictEqual( isnan( y ), true, 'returns NaN' );
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/gmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/gmean/test/test.js
index c42784903bd2..1a790aea0aa0 100644
--- a/lib/node_modules/@stdlib/stats/incr/gmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/gmean/test/test.js
@@ -105,7 +105,7 @@ tape( 'the accumulator function can return a result which overflows', function t
 	for ( i = 0; i < 10000; i++ ) {
 		acc( 1.7976931348623157e+308 );
 	}
-	t.strictEqual( acc(), PINF, 'returns infinity' );
+	t.strictEqual( acc(), PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -116,7 +116,7 @@ tape( 'the accumulator function can return a result which underflows', function
 	for ( i = 0; i < 10000; i++ ) {
 		acc( 5.0e-324 );
 	}
-	t.strictEqual( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -130,11 +130,11 @@ tape( 'if provided a `NaN`, the accumulator function always returns `NaN`', func
 	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( NaN );
-	t.strictEqual( isnan( acc() ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	for ( i = 0; i < 100; i++ ) {
 		acc( 3.14 );
-		t.strictEqual( isnan( acc() ), true, 'returns NaN' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/grubbs/test/test.js b/lib/node_modules/@stdlib/stats/incr/grubbs/test/test.js
index 76d5145ce4ad..d56efa849522 100644
--- a/lib/node_modules/@stdlib/stats/incr/grubbs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/grubbs/test/test.js
@@ -590,26 +590,26 @@ tape( 'if provided a `NaN`, the accumulator function always returns `NaN` for th
 	acc( rnorm( 10.0, 5.0 ) );
 
 	r = acc( NaN );
-	t.strictEqual( isnan( r.statistic ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.mean ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.sd ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.min ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.max ), true, 'returns NaN' );
+	t.strictEqual( isnan( r.statistic ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.mean ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.sd ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.min ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.max ), true, 'returns expected value' );
 
 	r = acc();
-	t.strictEqual( isnan( r.statistic ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.mean ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.sd ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.min ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.max ), true, 'returns NaN' );
+	t.strictEqual( isnan( r.statistic ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.mean ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.sd ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.min ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.max ), true, 'returns expected value' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = acc( rnorm( 10.0, 5.0 ) );
-		t.strictEqual( isnan( r.statistic ), true, 'returns NaN' );
-		t.strictEqual( isnan( r.mean ), true, 'returns NaN' );
-		t.strictEqual( isnan( r.sd ), true, 'returns NaN' );
-		t.strictEqual( isnan( r.min ), true, 'returns NaN' );
-		t.strictEqual( isnan( r.max ), true, 'returns NaN' );
+		t.strictEqual( isnan( r.statistic ), true, 'returns expected value' );
+		t.strictEqual( isnan( r.mean ), true, 'returns expected value' );
+		t.strictEqual( isnan( r.sd ), true, 'returns expected value' );
+		t.strictEqual( isnan( r.min ), true, 'returns expected value' );
+		t.strictEqual( isnan( r.max ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.js b/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.js
index 5d0b0b3d22ec..225f6edbe024 100644
--- a/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mgrubbs/test/test.js
@@ -707,32 +707,32 @@ tape( 'if provided a `NaN`, the accumulator function returns `NaN` for the test
 	acc( rnorm( 10.0, 5.0 ) );
 
 	r = acc( NaN );
-	t.strictEqual( isnan( r.statistic ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.mean ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.sd ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.min ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.max ), true, 'returns NaN' );
+	t.strictEqual( isnan( r.statistic ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.mean ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.sd ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.min ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.max ), true, 'returns expected value' );
 
 	r = acc();
-	t.strictEqual( isnan( r.statistic ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.mean ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.sd ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.min ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.max ), true, 'returns NaN' );
+	t.strictEqual( isnan( r.statistic ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.mean ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.sd ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.min ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.max ), true, 'returns expected value' );
 
 	r = acc( rnorm( 10.0, 5.0 ) );
-	t.strictEqual( isnan( r.statistic ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.mean ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.sd ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.min ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.max ), true, 'returns NaN' );
+	t.strictEqual( isnan( r.statistic ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.mean ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.sd ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.min ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.max ), true, 'returns expected value' );
 
 	r = acc( rnorm( 10.0, 5.0 ) );
-	t.strictEqual( isnan( r.statistic ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.mean ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.sd ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.min ), true, 'returns NaN' );
-	t.strictEqual( isnan( r.max ), true, 'returns NaN' );
+	t.strictEqual( isnan( r.statistic ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.mean ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.sd ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.min ), true, 'returns expected value' );
+	t.strictEqual( isnan( r.max ), true, 'returns expected value' );
 
 	for ( i = 0; i < 100; i++ ) {
 		r = acc( rnorm( 10.0, 5.0 ) );
diff --git a/lib/node_modules/@stdlib/stats/incr/mprod/test/test.js b/lib/node_modules/@stdlib/stats/incr/mprod/test/test.js
index 97fcf60698cc..0590f69bb563 100644
--- a/lib/node_modules/@stdlib/stats/incr/mprod/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mprod/test/test.js
@@ -209,7 +209,7 @@ tape( 'the accumulator function can return a result which overflows', function t
 	acc( 5.0e300 );
 	acc( 1.0e300 );
 
-	t.strictEqual( acc(), PINF, 'returns infinity' );
+	t.strictEqual( acc(), PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -247,7 +247,7 @@ tape( 'the accumulator function can return a result which underflows', function
 	acc( 4.0e-302 );
 	acc( 9.0e-303 );
 
-	t.strictEqual( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -316,13 +316,13 @@ tape( 'if provided `+infinity`, the accumulator function returns `+-infinity` (u
 	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( PINF );
-	t.strictEqual( acc(), PINF, 'returns +infinity' );
+	t.strictEqual( acc(), PINF, 'returns expected value' );
 
 	acc( 3.0 );
-	t.strictEqual( acc(), PINF, 'returns +infinity' );
+	t.strictEqual( acc(), PINF, 'returns expected value' );
 
 	acc( -4.0 );
-	t.strictEqual( acc(), NINF, 'returns -infinity' );
+	t.strictEqual( acc(), NINF, 'returns expected value' );
 
 	for ( i = 0; i < 100; i++ ) {
 		x = ( randu()*100.0 ) - 50.0;
@@ -346,13 +346,13 @@ tape( 'if provided `-infinity`, the accumulator function returns `+-infinity` (u
 	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( NINF );
-	t.strictEqual( acc(), NINF, 'returns -infinity' );
+	t.strictEqual( acc(), NINF, 'returns expected value' );
 
 	acc( 3.0 );
-	t.strictEqual( acc(), NINF, 'returns -infinity' );
+	t.strictEqual( acc(), NINF, 'returns expected value' );
 
 	acc( -4.0 );
-	t.strictEqual( acc(), PINF, 'returns +infinity' );
+	t.strictEqual( acc(), PINF, 'returns expected value' );
 
 	for ( i = 0; i < 100; i++ ) {
 		x = ( randu()*100.0 ) - 50.0;
@@ -376,13 +376,13 @@ tape( 'if provided `+infinity`, the accumulator function returns `NaN` if also p
 	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( PINF );
-	t.strictEqual( acc(), PINF, 'returns +infinity' );
+	t.strictEqual( acc(), PINF, 'returns expected value' );
 
 	acc( 0.0 );
-	t.strictEqual( isnan( acc() ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	acc( 3.0 );
-	t.strictEqual( isnan( acc() ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	acc( 4.0 );
 	t.strictEqual( isnan( acc() ), false, 'does not return NaN' );
@@ -405,13 +405,13 @@ tape( 'if provided `-infinity`, the accumulator function returns `NaN` if also p
 	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( NINF );
-	t.strictEqual( acc(), NINF, 'returns -infinity' );
+	t.strictEqual( acc(), NINF, 'returns expected value' );
 
 	acc( 0.0 );
-	t.strictEqual( isnan( acc() ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	acc( 3.0 );
-	t.strictEqual( isnan( acc() ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	acc( 4.0 );
 	t.strictEqual( isnan( acc() ), false, 'does not return NaN' );
@@ -434,13 +434,13 @@ tape( 'if provided `0`, the accumulator function returns `0` (no +-infinity)', f
 	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( 0.0 );
-	t.strictEqual( acc(), 0.0, 'returns 0.0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 
 	acc( 3.0 );
-	t.strictEqual( acc(), 0.0, 'returns 0.0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 
 	acc( 4.0 );
-	t.strictEqual( acc(), 0.0, 'returns 0.0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 
 	for ( i = 0; i < 10; i++ ) {
 		p = acc( i+1 );
@@ -456,29 +456,29 @@ tape( 'the accumulator function returns a signed zero', function test( t ) {
 
 	acc = incrmprod( 3 );
 	p = acc( -0.0 );
-	t.strictEqual( isNegativeZero( p ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( p ), true, 'returns expected value' );
 
 	p = acc( -0.0 );
-	t.strictEqual( isPositiveZero( p ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( p ), true, 'returns expected value' );
 
 	for ( i = 0; i < 100; i++ ) {
 		p = acc( -0.0 );
-		t.strictEqual( isNegativeZero( p ), true, 'returns -0' );
+		t.strictEqual( isNegativeZero( p ), true, 'returns expected value' );
 	}
 
 	acc = incrmprod( 4 );
 	p = acc( -0.0 );
-	t.strictEqual( isNegativeZero( p ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( p ), true, 'returns expected value' );
 
 	p = acc( -0.0 );
-	t.strictEqual( isPositiveZero( p ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( p ), true, 'returns expected value' );
 
 	p = acc( -0.0 );
-	t.strictEqual( isNegativeZero( p ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( p ), true, 'returns expected value' );
 
 	for ( i = 0; i < 100; i++ ) {
 		p = acc( -0.0 );
-		t.strictEqual( isPositiveZero( p ), true, 'returns +0' );
+		t.strictEqual( isPositiveZero( p ), true, 'returns expected value' );
 	}
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/prod/test/test.js b/lib/node_modules/@stdlib/stats/incr/prod/test/test.js
index 121af092b8fb..1b0f6725ce82 100644
--- a/lib/node_modules/@stdlib/stats/incr/prod/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/prod/test/test.js
@@ -125,7 +125,7 @@ tape( 'the accumulator function can return a result which overflows', function t
 	acc( 5.0e300 );
 	acc( 1.0e300 );
 
-	t.strictEqual( acc(), PINF, 'returns infinity' );
+	t.strictEqual( acc(), PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -163,7 +163,7 @@ tape( 'the accumulator function can return a result which underflows', function
 	acc( 4.0e-302 );
 	acc( 9.0e-303 );
 
-	t.strictEqual( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -208,11 +208,11 @@ tape( 'if provided a `NaN`, the accumulator function always returns `NaN`', func
 	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( NaN );
-	t.strictEqual( isnan( acc() ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	for ( i = 0; i < 100; i++ ) {
 		acc( 3.14 );
-		t.strictEqual( isnan( acc() ), true, 'returns NaN' );
+		t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -228,7 +228,7 @@ tape( 'if provided `+infinity`, the accumulator function always returns `+-infin
 	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( PINF );
-	t.strictEqual( acc(), PINF, 'returns +infinity' );
+	t.strictEqual( acc(), PINF, 'returns expected value' );
 
 	for ( i = 0; i < 100; i++ ) {
 		x = ( randu()*100.0 ) - 50.0;
@@ -252,7 +252,7 @@ tape( 'if provided `-infinity`, the accumulator function always returns `+-infin
 	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( NINF );
-	t.strictEqual( acc(), NINF, 'returns -infinity' );
+	t.strictEqual( acc(), NINF, 'returns expected value' );
 
 	for ( i = 0; i < 100; i++ ) {
 		x = ( randu()*100.0 ) - 50.0;
@@ -276,14 +276,14 @@ tape( 'if provided `+infinity`, the accumulator function always returns `NaN` if
 	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( PINF );
-	t.strictEqual( acc(), PINF, 'returns +infinity' );
+	t.strictEqual( acc(), PINF, 'returns expected value' );
 
 	acc( 0.0 );
-	t.strictEqual( isnan( acc() ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		p = acc( i+1 );
-		t.strictEqual( isnan( p ), true, 'returns NaN' );
+		t.strictEqual( isnan( p ), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -299,14 +299,14 @@ tape( 'if provided `-infinity`, the accumulator function always returns `NaN` if
 	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( NINF );
-	t.strictEqual( acc(), NINF, 'returns -infinity' );
+	t.strictEqual( acc(), NINF, 'returns expected value' );
 
 	acc( 0.0 );
-	t.strictEqual( isnan( acc() ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc() ), true, 'returns expected value' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		p = acc( i+1 );
-		t.strictEqual( isnan( p ), true, 'returns NaN' );
+		t.strictEqual( isnan( p ), true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -322,11 +322,11 @@ tape( 'if provided `0`, the accumulator function always returns `0` (no +-infini
 	t.strictEqual( acc(), 5.0, 'returns expected value' );
 
 	acc( 0.0 );
-	t.strictEqual( acc(), 0.0, 'returns 0.0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 
 	for ( i = 0; i < 1000; i++ ) {
 		p = acc( i+1 );
-		t.strictEqual( p, 0.0, 'returns 0.0' );
+		t.strictEqual( p, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -341,9 +341,9 @@ tape( 'the accumulator function returns a signed zero', function test( t ) {
 	for ( i = 0; i < 100; i++ ) {
 		p = acc( -0.0 );
 		if ( isEven( i ) ) {
-			t.strictEqual( isPositiveZero( p ), true, 'returns +0' );
+			t.strictEqual( isPositiveZero( p ), true, 'returns expected value' );
 		} else {
-			t.strictEqual( isNegativeZero( p ), true, 'returns -0' );
+			t.strictEqual( isNegativeZero( p ), true, 'returns expected value' );
 		}
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/stats/incr/wmean/test/test.js b/lib/node_modules/@stdlib/stats/incr/wmean/test/test.js
index de864ee79f0a..b987122ec405 100644
--- a/lib/node_modules/@stdlib/stats/incr/wmean/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/wmean/test/test.js
@@ -101,22 +101,22 @@ tape( 'if not provided arguments, the accumulator function returns the current w
 
 tape( 'if not provided a weight, the accumulator function returns `NaN`', function test( t ) {
 	var acc = incrwmean();
-	t.strictEqual( isnan( acc( 2.0 ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( acc( 3.14 ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc( 2.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc( 3.14 ) ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN` for either a value or a weight, the accumulator function returns `NaN`', function test( t ) {
 	var acc = incrwmean();
-	t.strictEqual( isnan( acc( 2.0, NaN ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( acc( 3.14, NaN ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc( 2.0, NaN ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc( 3.14, NaN ) ), true, 'returns expected value' );
 
 	acc = incrwmean();
-	t.strictEqual( isnan( acc( NaN, 1.0 ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( acc( NaN, 1.0 ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc( NaN, 1.0 ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc( NaN, 1.0 ) ), true, 'returns expected value' );
 
 	acc = incrwmean();
-	t.strictEqual( isnan( acc( NaN, NaN ) ), true, 'returns NaN' );
-	t.strictEqual( isnan( acc( NaN, NaN ) ), true, 'returns NaN' );
+	t.strictEqual( isnan( acc( NaN, NaN ) ), true, 'returns expected value' );
+	t.strictEqual( isnan( acc( NaN, NaN ) ), true, 'returns expected value' );
 	t.end();
 });

From 7add0201c13e56a0381926ccfd4073c84eaf2ed4 Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Thu, 14 Aug 2025 17:48:47 -0500
Subject: [PATCH 17/32] test: use standardized assertion messages and fix lint
 errors

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../github/create-issue/test/test.query.js    |   2 +-
 .../github/create-repo/test/test.query.js     |   2 +-
 .../github/create-token/test/test.query.js    |   2 +-
 .../github/delete-token/test/test.query.js    |   2 +-
 .../dispatch-workflow/test/test.query.js      |   2 +-
 .../_tools/github/get/test/test.cache.js      |   2 +-
 .../github/rank-users/test/test.shuffle.js    |   2 +-
 .../github/set-topics/test/test.query.js      |   2 +-
 .../github/star-repo/test/test.query.js       |   2 +-
 .../insert-header-file-list/test/test.main.js |   4 +-
 .../insert-header-file-list/test/test.sync.js |   4 +-
 .../remove-header-file-list/test/test.main.js |   8 +-
 .../remove-header-file-list/test/test.sync.js |   8 +-
 .../update-header-file-list/test/test.main.js |   8 +-
 .../update-header-file-list/test/test.sync.js |   8 +-
 .../_tools/links/create/test/test.cli.js      |   4 +-
 .../_tools/links/create/test/test.sync.js     |   6 +-
 .../_tools/links/id2uri/test/test.sync.js     |   2 +-
 .../_tools/links/uri2id/test/test.sync.js     |   2 +-
 .../_tools/links/validate/test/test.sync.js   |   2 +-
 .../_tools/lint/filenames/test/test.async.js  |   6 +-
 .../_tools/lint/filenames/test/test.lint.js   |   4 +-
 .../_tools/lint/filenames/test/test.sync.js   |   6 +-
 .../lint/header-filenames/test/test.async.js  |   6 +-
 .../lint/header-filenames/test/test.lint.js   |  10 +-
 .../lint/header-filenames/test/test.sync.js   |   6 +-
 .../test/test.main.js                         |  28 +--
 .../test/test.sync.js                         |  28 +--
 .../license-header-glob/test/test.main.js     |  30 +--
 .../license-header-glob/test/test.sync.js     |  28 +--
 .../_tools/lint/pkg-json/test/test.async.js   |  10 +-
 .../_tools/lint/repl-txt/test/test.async.js   |  10 +-
 .../import-require-glob/test/test.async.js    |   2 +-
 .../import-require-glob/test/test.sync.js     |   2 +-
 .../modules/pkg-deps/test/test.async.js       |   2 +-
 .../pkg-deps/test/test.filter_builtins.js     |   4 +-
 .../_tools/modules/pkg-deps/test/test.sync.js |   2 +-
 .../modules/pkg-deps/test/test.to_array.js    |   2 +-
 .../modules/pkg-deps/test/test.walk_file.js   |  10 +-
 .../pkg-deps/test/test.walk_file.sync.js      |   4 +-
 .../_tools/pkgs/addons/test/test.async.js     |  10 +-
 .../_tools/pkgs/addons/test/test.inspect.js   |  14 +-
 .../_tools/pkgs/addons/test/test.sync.js      |  10 +-
 .../browser-compatible/test/test.async.js     |  12 +-
 .../pkgs/browser-compatible/test/test.sync.js |  10 +-
 .../_tools/pkgs/clis/test/test.async.js       |  10 +-
 .../_tools/pkgs/clis/test/test.read_pkgs.js   |   8 +-
 .../_tools/pkgs/clis/test/test.sync.js        |   8 +-
 .../_tools/pkgs/cmds/test/test.async.js       |  10 +-
 .../_tools/pkgs/cmds/test/test.read_pkgs.js   |   8 +-
 .../_tools/pkgs/cmds/test/test.sync.js        |   8 +-
 .../@stdlib/_tools/pkgs/dep-list/test/test.js |   4 +-
 .../_tools/pkgs/find/test/test.async.js       |   8 +-
 .../_tools/pkgs/find/test/test.sync.js        |   6 +-
 .../_tools/pkgs/includes/test/test.inspect.js |  14 +-
 .../_tools/pkgs/includes/test/test.main.js    |  10 +-
 .../_tools/pkgs/includes/test/test.sync.js    |  10 +-
 .../_tools/pkgs/names/test/test.async.js      |  12 +-
 .../_tools/pkgs/names/test/test.sync.js       |  10 +-
 .../_tools/pkgs/namespace-deps/test/test.js   |   6 +-
 .../pkgs/namespace-readmes/test/test.async.js |  10 +-
 .../pkgs/namespace-readmes/test/test.find.js  |   6 +-
 .../pkgs/namespace-readmes/test/test.sync.js  |  10 +-
 .../_tools/pkgs/namespaces/test/test.async.js |  12 +-
 .../_tools/pkgs/namespaces/test/test.sync.js  |  10 +-
 .../_tools/pkgs/readmes/test/test.async.js    |  10 +-
 .../_tools/pkgs/readmes/test/test.find.js     |   6 +-
 .../_tools/pkgs/readmes/test/test.sync.js     |  10 +-
 .../_tools/pkgs/repl-help/test/test.async.js  |  10 +-
 .../_tools/pkgs/repl-help/test/test.find.js   |   6 +-
 .../_tools/pkgs/repl-help/test/test.sync.js   |  10 +-
 .../pkgs/standalones/test/test.async.js       |  12 +-
 .../_tools/pkgs/standalones/test/test.sync.js |  10 +-
 .../_tools/pkgs/toposort/test/test.async.js   |  14 +-
 .../_tools/pkgs/toposort/test/test.sync.js    |  10 +-
 .../_tools/pkgs/tree/test/test.async.js       |   2 +-
 .../_tools/pkgs/types/test/test.inspect.js    |  14 +-
 .../_tools/pkgs/types/test/test.main.js       |  10 +-
 .../_tools/pkgs/types/test/test.sync.js       |  10 +-
 .../_tools/pkgs/wasm/test/test.async.js       |  10 +-
 .../_tools/pkgs/wasm/test/test.inspect.js     |  14 +-
 .../_tools/pkgs/wasm/test/test.sync.js        |  10 +-
 .../_tools/repl-txt/parse/test/test.js        |   2 +-
 .../_tools/search/pkg-index/test/test.js      |   4 +-
 .../js/lloc-file-list/test/test.async.js      |   8 +-
 .../js/lloc-file-list/test/test.sync.js       |   8 +-
 .../js/lloc-glob/test/test.async.js           |  14 +-
 .../js/lloc-glob/test/test.sync.js            |  10 +-
 .../js/sloc-file-list/test/test.async.js      |   8 +-
 .../js/sloc-file-list/test/test.sync.js       |   8 +-
 .../js/sloc-glob/test/test.async.js           |  14 +-
 .../js/sloc-glob/test/test.sync.js            |  10 +-
 .../js/summarize-file-list/test/test.async.js |   8 +-
 .../js/summarize-file-list/test/test.sync.js  |   8 +-
 .../js/summarize-glob/test/test.async.js      |  14 +-
 .../js/summarize-glob/test/test.sync.js       |  10 +-
 .../tex-equation-to-svg/test/test.factory.js  |   2 +-
 .../tex-equation-to-svg/test/test.main.js     |   2 +-
 .../@stdlib/array/base/accessor/test/test.js  |   4 +-
 .../@stdlib/array/bool/test/test.js           |  36 ++--
 .../@stdlib/array/bool/test/test.of.js        |   2 +-
 .../@stdlib/array/buffer/test/test.js         |  22 +--
 .../array/complex128/test/test.entries.js     |   2 +-
 .../array/complex128/test/test.from.js        |   2 +-
 .../@stdlib/array/complex128/test/test.js     |  40 ++--
 .../@stdlib/array/complex128/test/test.of.js  |   2 +-
 .../array/complex64/test/test.entries.js      |   2 +-
 .../@stdlib/array/complex64/test/test.js      |  40 ++--
 .../@stdlib/array/complex64/test/test.of.js   |   2 +-
 .../@stdlib/array/dataview/test/test.js       |   6 +-
 .../@stdlib/array/datespace/test/test.js      |   2 +-
 .../@stdlib/array/shared-buffer/test/test.js  |  22 +--
 .../bench/harness/test/test.benchmark.js      |   6 +-
 .../@stdlib/bench/harness/test/test.runner.js |   6 +-
 .../@stdlib/cli/ctor/test/test.js             |   4 +-
 .../datasets/afinn-111/test/test.browser.js   |   2 +-
 .../@stdlib/datasets/afinn-111/test/test.js   |   2 +-
 .../datasets/afinn-96/test/test.browser.js    |   2 +-
 .../@stdlib/datasets/afinn-96/test/test.js    |   2 +-
 .../anscombes-quartet/test/test.browser.js    |   2 +-
 .../datasets/anscombes-quartet/test/test.js   |   2 +-
 .../test/test.js                              |   2 +-
 .../harrison-boston-house-prices/test/test.js |   2 +-
 .../test/test.browser.js                      |   8 +-
 .../minard-napoleons-march/test/test.js       |   8 +-
 .../pace-boston-house-prices/test/test.js     |   2 +-
 .../@stdlib/datasets/sotu/test/test.js        |  24 +--
 .../@stdlib/datasets/test/test.js             |   4 +-
 .../dstructs/circular-buffer/test/test.js     |   8 +-
 .../compact-adjacency-matrix/test/test.js     |   4 +-
 .../dstructs/doubly-linked-list/test/test.js  |   4 +-
 .../@stdlib/dstructs/fifo/test/test.js        |   4 +-
 .../@stdlib/dstructs/linked-list/test/test.js |   4 +-
 .../@stdlib/dstructs/stack/test/test.js       |   4 +-
 .../@stdlib/error/tools/database/test/test.js |   2 +-
 .../@stdlib/fs/close/test/test.sync.js        |   2 +-
 .../@stdlib/fs/exists/test/test.async.js      |   4 +-
 .../@stdlib/fs/open/test/test.sync.js         |   6 +-
 .../@stdlib/fs/read-dir/test/test.async.js    |   2 +-
 .../@stdlib/fs/read-dir/test/test.sync.js     |   2 +-
 .../fs/read-file-list/test/test.sync.js       |   6 +-
 .../@stdlib/fs/read-file/test/test.sync.js    |   6 +-
 .../@stdlib/fs/read-json/test/test.sync.js    |  12 +-
 .../@stdlib/fs/read-wasm/test/test.sync.js    |   4 +-
 .../math/base/special/besselj0/test/test.js   |   4 +-
 .../base/special/besselj0/test/test.native.js |   4 +-
 .../math/base/special/besselj1/test/test.js   |   4 +-
 .../base/special/besselj1/test/test.native.js |   4 +-
 .../math/base/special/bessely0/test/test.js   |   4 +-
 .../base/special/bessely0/test/test.native.js |   4 +-
 .../math/base/special/bessely1/test/test.js   |   6 +-
 .../base/special/bessely1/test/test.native.js |   6 +-
 .../math/base/special/beta/test/test.js       |   4 +-
 .../base/special/beta/test/test.native.js     |   4 +-
 .../math/base/special/betaln/test/test.js     |   4 +-
 .../base/special/betaln/test/test.native.js   |   4 +-
 .../base/special/binomcoefln/test/test.js     |   4 +-
 .../special/binomcoefln/test/test.native.js   |   4 +-
 .../math/base/special/ccis/test/test.js       |   6 +-
 .../base/special/ccis/test/test.native.js     |   6 +-
 .../math/base/special/ceil/test/test.js       |   8 +-
 .../base/special/ceil/test/test.native.js     |   8 +-
 .../math/base/special/ceil10/test/test.js     |  18 +-
 .../base/special/ceil10/test/test.native.js   |  18 +-
 .../math/base/special/ceil2/test/test.js      |  14 +-
 .../base/special/ceil2/test/test.native.js    |  14 +-
 .../math/base/special/ceilb/test/test.js      |  16 +-
 .../base/special/ceilb/test/test.native.js    |  16 +-
 .../math/base/special/ceilf/test/test.js      |   8 +-
 .../base/special/ceilf/test/test.native.js    |   8 +-
 .../math/base/special/ceiln/test/test.js      |  16 +-
 .../base/special/ceiln/test/test.native.js    |  16 +-
 .../math/base/special/ceilsd/test/test.js     |  12 +-
 .../base/special/ceilsd/test/test.native.js   |  12 +-
 .../math/base/special/cexp/test/test.js       |  12 +-
 .../base/special/cexp/test/test.native.js     |  12 +-
 .../special/gamma/test/other/xtest.gamma.js   |   6 +-
 .../base/special/gamma/test/test.boost.js     |   2 +-
 .../math/base/special/gamma/test/test.js      |   2 +-
 .../base/special/gamma/test/test.native.js    |   2 +-
 .../math/base/special/hypot/test/test.js      |   2 +-
 .../base/special/hypot/test/test.native.js    |   2 +-
 .../math/base/special/hypotf/test/test.js     |   4 +-
 .../base/special/hypotf/test/test.native.js   |   4 +-
 .../base/special/kernel-betainc/test/test.js  |   2 +-
 .../math/base/special/maxn/test/test.js       |   2 +-
 .../special/minmaxabsn/test/test.assign.js    |   2 +-
 .../base/special/minmaxabsn/test/test.main.js |   2 +-
 .../base/special/modf/test/test.assign.js     |   4 +-
 .../math/base/special/modf/test/test.main.js  |   4 +-
 .../base/special/modf/test/test.native.js     |   4 +-
 .../math/base/special/pow/test/test.js        |   4 +-
 .../math/base/special/pow/test/test.native.js |   6 +-
 .../math/base/special/powm1/test/test.js      |   4 +-
 .../base/special/powm1/test/test.native.js    |   4 +-
 .../math/base/special/sici/test/test.main.js  |   8 +-
 .../iter/sequences/even-integers/test/test.js |   2 +-
 .../math/iter/sequences/integers/test/test.js |   2 +-
 .../iter/sequences/odd-integers/test/test.js  |   2 +-
 .../@stdlib/namespace/test/test.js            |   4 +-
 .../@stdlib/ndarray/base/ctor/test/test.js    |   6 +-
 .../@stdlib/ndarray/base/ind2sub/test/test.js | 180 +++++++++---------
 .../minmax-view-buffer-index/test/test.js     |  22 +--
 .../@stdlib/ndarray/base/numel/test/test.js   |   2 +-
 .../ndarray/base/shape2strides/test/test.js   |  20 +-
 .../ndarray/base/to-array/test/test.js        |  40 ++--
 .../ndarray/ctor/test/test.copy_array.js      |   4 +-
 .../@stdlib/ndarray/ctor/test/test.js         |  16 +-
 .../@stdlib/ndarray/fancy/test/test.js        |  16 +-
 .../@stdlib/ndarray/ind2sub/test/test.main.js |  46 ++---
 .../@stdlib/ndarray/to-array/test/test.js     |  40 ++--
 .../@stdlib/nlp/sentencize/test/test.js       |   2 +-
 .../@stdlib/nlp/tokenize/test/test.js         |   2 +-
 .../@stdlib/number/ctor/test/test.js          |   2 +-
 .../float32/base/from-word/test/test.js       |   2 +-
 .../base/from-word/test/test.native.js        |   2 +-
 .../float32/base/significand/test/test.js     |   8 +-
 .../base/significand/test/test.native.js      |   8 +-
 .../number/float32/base/to-int32/test/test.js |   6 +-
 .../float32/base/to-uint32/test/test.js       |   6 +-
 .../float64/base/get-high-word/test/test.js   |   2 +-
 .../base/get-high-word/test/test.native.js    |   2 +-
 .../float64/base/get-low-word/test/test.js    |   2 +-
 .../base/get-low-word/test/test.native.js     |   2 +-
 .../number/float64/base/to-int32/test/test.js |   6 +-
 .../float64/base/to-uint32/test/test.js       |   6 +-
 .../base/from-binary-string/test/test.js      |   2 +-
 .../base/from-binary-string/test/test.js      |   2 +-
 .../base/from-binary-string/test/test.js      |   2 +-
 .../@stdlib/os/num-cpus/test/test.browser.js  |   2 +-
 .../@stdlib/process/chdir/test/test.js        |   2 +-
 .../process/chdir/test/test.polyfill.js       |   2 +-
 .../@stdlib/process/read-stdin/test/test.js   |   4 +-
 .../test/test.discrete_uniform.js             |  22 +--
 .../discrete-uniform/test/test.factory.js     |   4 +-
 .../random/base/discrete-uniform/test/test.js |   2 +-
 .../random/base/randi/test/test.factory.js    |   2 +-
 .../@stdlib/random/base/randi/test/test.js    |   2 +-
 .../random/shuffle/test/test.factory.js       |   4 +-
 .../streams/arcsine/test/test.factory.js      |   8 +-
 .../streams/arcsine/test/test.object_mode.js  |   4 +-
 .../streams/bernoulli/test/test.factory.js    |   8 +-
 .../bernoulli/test/test.object_mode.js        |   4 +-
 .../random/streams/beta/test/test.factory.js  |   8 +-
 .../streams/beta/test/test.object_mode.js     |   4 +-
 .../streams/betaprime/test/test.factory.js    |   8 +-
 .../betaprime/test/test.object_mode.js        |   4 +-
 .../streams/binomial/test/test.factory.js     |   8 +-
 .../streams/binomial/test/test.object_mode.js |   4 +-
 .../streams/box-muller/test/test.factory.js   |   4 +-
 .../box-muller/test/test.object_mode.js       |   4 +-
 .../streams/cauchy/test/test.factory.js       |   8 +-
 .../streams/cauchy/test/test.object_mode.js   |   4 +-
 .../random/streams/chi/test/test.factory.js   |   8 +-
 .../streams/chi/test/test.object_mode.js      |   4 +-
 .../streams/chisquare/test/test.factory.js    |   8 +-
 .../chisquare/test/test.object_mode.js        |   4 +-
 .../streams/cosine/test/test.factory.js       |   8 +-
 .../streams/cosine/test/test.object_mode.js   |   4 +-
 .../discrete-uniform/test/test.factory.js     |   8 +-
 .../discrete-uniform/test/test.object_mode.js |   4 +-
 .../streams/erlang/test/test.factory.js       |   8 +-
 .../streams/erlang/test/test.object_mode.js   |   4 +-
 .../streams/exponential/test/test.factory.js  |   8 +-
 .../exponential/test/test.object_mode.js      |   4 +-
 .../random/streams/f/test/test.factory.js     |   8 +-
 .../random/streams/f/test/test.object_mode.js |   4 +-
 .../streams/frechet/test/test.factory.js      |   8 +-
 .../streams/frechet/test/test.object_mode.js  |   4 +-
 .../random/streams/gamma/test/test.factory.js |   8 +-
 .../streams/gamma/test/test.object_mode.js    |   4 +-
 .../streams/geometric/test/test.factory.js    |   8 +-
 .../geometric/test/test.object_mode.js        |   4 +-
 .../streams/gumbel/test/test.factory.js       |   8 +-
 .../streams/gumbel/test/test.object_mode.js   |   4 +-
 .../hypergeometric/test/test.factory.js       |   8 +-
 .../hypergeometric/test/test.object_mode.js   |   4 +-
 .../improved-ziggurat/test/test.factory.js    |   4 +-
 .../test/test.object_mode.js                  |   4 +-
 .../streams/invgamma/test/test.factory.js     |   8 +-
 .../streams/invgamma/test/test.object_mode.js |   4 +-
 .../streams/kumaraswamy/test/test.factory.js  |   8 +-
 .../kumaraswamy/test/test.object_mode.js      |   4 +-
 .../streams/laplace/test/test.factory.js      |   8 +-
 .../streams/laplace/test/test.object_mode.js  |   4 +-
 .../random/streams/levy/test/test.factory.js  |   8 +-
 .../streams/levy/test/test.object_mode.js     |   4 +-
 .../streams/logistic/test/test.factory.js     |   8 +-
 .../streams/logistic/test/test.object_mode.js |   4 +-
 .../streams/lognormal/test/test.factory.js    |   8 +-
 .../lognormal/test/test.object_mode.js        |   4 +-
 .../minstd-shuffle/test/test.factory.js       |   4 +-
 .../minstd-shuffle/test/test.object_mode.js   |   6 +-
 .../streams/minstd/test/test.factory.js       |   4 +-
 .../streams/minstd/test/test.object_mode.js   |   6 +-
 .../streams/mt19937/test/test.factory.js      |   4 +-
 .../streams/mt19937/test/test.object_mode.js  |   6 +-
 .../negative-binomial/test/test.factory.js    |   8 +-
 .../test/test.object_mode.js                  |   4 +-
 .../streams/normal/test/test.factory.js       |   8 +-
 .../streams/normal/test/test.object_mode.js   |   4 +-
 .../streams/pareto-type1/test/test.factory.js |   8 +-
 .../pareto-type1/test/test.object_mode.js     |   4 +-
 .../streams/poisson/test/test.factory.js      |   8 +-
 .../streams/poisson/test/test.object_mode.js  |   4 +-
 .../random/streams/randi/test/test.factory.js |   4 +-
 .../streams/randi/test/test.object_mode.js    |   6 +-
 .../random/streams/randn/test/test.factory.js |   4 +-
 .../streams/randn/test/test.object_mode.js    |   4 +-
 .../random/streams/randu/test/test.factory.js |   4 +-
 .../streams/randu/test/test.object_mode.js    |   4 +-
 .../streams/rayleigh/test/test.factory.js     |   8 +-
 .../streams/rayleigh/test/test.object_mode.js |   4 +-
 .../random/streams/t/test/test.factory.js     |   8 +-
 .../random/streams/t/test/test.object_mode.js |   4 +-
 .../streams/triangular/test/test.factory.js   |   8 +-
 .../triangular/test/test.object_mode.js       |   4 +-
 .../streams/uniform/test/test.factory.js      |   8 +-
 .../streams/uniform/test/test.object_mode.js  |   4 +-
 .../streams/weibull/test/test.factory.js      |   8 +-
 .../streams/weibull/test/test.object_mode.js  |   4 +-
 .../@stdlib/slice/ctor/test/test.js           | 100 +++++-----
 .../base/dists/arcsine/ctor/test/test.js      |   8 +-
 .../base/dists/bernoulli/ctor/test/test.js    |   8 +-
 .../stats/base/dists/beta/ctor/test/test.js   |   8 +-
 .../base/dists/beta/pdf/test/test.pdf.js      |   2 +-
 .../base/dists/betaprime/ctor/test/test.js    |   8 +-
 .../betaprime/logcdf/test/test.logcdf.js      |   2 +-
 .../base/dists/binomial/ctor/test/test.js     |   8 +-
 .../binomial/quantile/test/test.factory.js    |   2 +-
 .../stats/base/dists/cauchy/ctor/test/test.js |   8 +-
 .../stats/base/dists/chi/ctor/test/test.js    |   8 +-
 .../base/dists/chisquare/ctor/test/test.js    |   8 +-
 .../stats/base/dists/cosine/ctor/test/test.js |   8 +-
 .../base/dists/degenerate/ctor/test/test.js   |   8 +-
 .../dists/discrete-uniform/ctor/test/test.js  |   8 +-
 .../stats/base/dists/erlang/ctor/test/test.js |   8 +-
 .../base/dists/exponential/ctor/test/test.js  |   8 +-
 .../stats/base/dists/f/ctor/test/test.js      |   8 +-
 .../base/dists/frechet/ctor/test/test.js      |   8 +-
 .../stats/base/dists/gamma/ctor/test/test.js  |   8 +-
 .../gamma/quantile/test/test.quantile.js      |   4 +-
 .../base/dists/geometric/ctor/test/test.js    |   8 +-
 .../geometric/quantile/test/test.native.js    |   4 +-
 .../geometric/quantile/test/test.quantile.js  |   4 +-
 .../stats/base/dists/gumbel/ctor/test/test.js |   8 +-
 .../dists/hypergeometric/ctor/test/test.js    |   4 +-
 .../quantile/test/test.quantile.js            |   2 +-
 .../base/dists/invgamma/ctor/test/test.js     |   8 +-
 .../dists/kumaraswamy/cdf/test/test.cdf.js    |  16 +-
 .../dists/kumaraswamy/cdf/test/test.native.js |  16 +-
 .../base/dists/kumaraswamy/ctor/test/test.js  |   8 +-
 .../kumaraswamy/logcdf/test/test.logcdf.js    |  16 +-
 .../kumaraswamy/logcdf/test/test.native.js    |  16 +-
 .../dists/kumaraswamy/pdf/test/test.pdf.js    |  16 +-
 .../base/dists/laplace/ctor/test/test.js      |   8 +-
 .../stats/base/dists/levy/ctor/test/test.js   |   8 +-
 .../base/dists/logistic/ctor/test/test.js     |   8 +-
 .../base/dists/lognormal/ctor/test/test.js    |   8 +-
 .../dists/negative-binomial/ctor/test/test.js |   8 +-
 .../quantile/test/test.quantile.js            |   4 +-
 .../stats/base/dists/normal/ctor/test/test.js |   8 +-
 .../base/dists/pareto-type1/ctor/test/test.js |   8 +-
 .../dists/planck/logpmf/test/test.logpmf.js   |   2 +-
 .../dists/planck/logpmf/test/test.native.js   |   2 +-
 .../base/dists/poisson/ctor/test/test.js      |   8 +-
 .../poisson/quantile/test/test.quantile.js    |   8 +-
 .../base/dists/rayleigh/ctor/test/test.js     |   8 +-
 .../stats/base/dists/t/ctor/test/test.js      |   8 +-
 .../base/dists/triangular/ctor/test/test.js   |   8 +-
 .../base/dists/uniform/ctor/test/test.js      |   8 +-
 .../base/dists/weibull/ctor/test/test.js      |   8 +-
 .../@stdlib/stats/incr/apcorr/test/test.js    |   4 +-
 .../stats/incr/covariance/test/test.js        |   4 +-
 .../@stdlib/stats/incr/cv/test/test.js        |   4 +-
 .../@stdlib/stats/incr/mapcorr/test/test.js   |   4 +-
 .../stats/incr/mcovariance/test/test.js       |   4 +-
 .../@stdlib/stats/incr/mcv/test/test.js       |   4 +-
 .../@stdlib/stats/incr/mpcorr/test/test.js    |   4 +-
 .../@stdlib/stats/incr/mpcorr2/test/test.js   |   4 +-
 .../stats/incr/mpcorrdist/test/test.js        |   2 +-
 .../@stdlib/stats/incr/mstdev/test/test.js    |   4 +-
 .../@stdlib/stats/incr/mvariance/test/test.js |   4 +-
 .../@stdlib/stats/incr/mvmr/test/test.js      |   4 +-
 .../@stdlib/stats/incr/nanmstdev/test/test.js |   4 +-
 .../@stdlib/stats/incr/pcorr/test/test.js     |   4 +-
 .../@stdlib/stats/incr/pcorr2/test/test.js    |   4 +-
 .../@stdlib/stats/incr/pcorrdist/test/test.js |   2 +-
 .../@stdlib/stats/incr/variance/test/test.js  |   4 +-
 .../@stdlib/stats/incr/vmr/test/test.js       |   4 +-
 .../node/debug-sink/test/test.factory.js      |   2 +-
 .../node/debug-sink/test/test.object_mode.js  |   2 +-
 .../streams/node/debug/test/test.factory.js   |   2 +-
 .../node/debug/test/test.object_mode.js       |   2 +-
 .../streams/node/empty/test/test.factory.js   |   4 +-
 .../node/empty/test/test.object_mode.js       |   2 +-
 .../node/from-array/test/test.factory.js      |   4 +-
 .../node/from-array/test/test.object_mode.js  |   4 +-
 .../from-circular-array/test/test.factory.js  |   4 +-
 .../test/test.object_mode.js                  |   4 +-
 .../node/from-constant/test/test.factory.js   |   8 +-
 .../from-constant/test/test.object_mode.js    |   4 +-
 .../node/from-iterator/test/test.factory.js   |   4 +-
 .../from-iterator/test/test.object_mode.js    |   4 +-
 .../from-strided-array/test/test.factory.js   |   4 +-
 .../test/test.object_mode.js                  |   4 +-
 .../node/inspect-sink/test/test.factory.js    |   2 +-
 .../inspect-sink/test/test.object_mode.js     |   2 +-
 .../streams/node/inspect/test/test.factory.js |   2 +-
 .../node/inspect/test/test.object_mode.js     |   2 +-
 .../streams/node/join/test/test.factory.js    |   2 +-
 .../node/join/test/test.object_mode.js        |   2 +-
 .../streams/node/split/test/test.factory.js   |   2 +-
 .../node/split/test/test.object_mode.js       |   2 +-
 .../node/transform/test/test.factory.js       |   4 +-
 .../node/transform/test/test.object_mode.js   |   2 +-
 .../split-grapheme-clusters/test/test.js      |   2 +-
 .../async/bifurcate-by/test/test.main.js      |   2 +-
 .../series-waterfall/test/test.factory.js     |   2 +-
 .../async/series-waterfall/test/test.main.js  |   2 +-
 .../@stdlib/utils/deep-pluck/test/test.js     |   2 +-
 .../@stdlib/utils/from-entries/test/test.js   |   2 +-
 .../@stdlib/utils/parallel/test/test.main.js  |   2 +-
 .../utils/parallel/test/test.node.exec.js     |  10 +-
 .../parallel/test/test.node.worker.exec.js    |   2 +-
 .../parallel/test/test.node.worker.spawn.js   |  14 +-
 .../@stdlib/utils/parse-json/test/test.js     |   2 +-
 .../@stdlib/utils/parse-ndjson/test/test.js   |   4 +-
 .../@stdlib/utils/pluck/test/test.js          |   2 +-
 .../@stdlib/utils/pop/test/test.js            |  12 +-
 .../@stdlib/utils/shift/test/test.js          |  12 +-
 .../@stdlib/utils/timeit/test/test.main.js    |  20 +-
 .../@stdlib/utils/try-require/test/test.js    |  10 +-
 433 files changed, 1606 insertions(+), 1602 deletions(-)

diff --git a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.query.js
index 3276fae42546..494ae90e69b6 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-issue/test/test.query.js
@@ -175,7 +175,7 @@ tape( 'the function returns rate limit info to a provided callback (error)', fun
 	}
 
 	function done( error, data, info ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( data, null, 'no data' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
diff --git a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.query.js
index d925e84a410f..ccdbbccd2d82 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-repo/test/test.query.js
@@ -211,7 +211,7 @@ tape( 'function returns rate limit info to a provided callback (error)', functio
 	}
 
 	function done( error, data, info ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( data, null, 'no data' );
 
 		t.deepEqual( info, expected, 'deep equal' );
diff --git a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.query.js
index 73a29b4d985c..ae2128af9931 100644
--- a/lib/node_modules/@stdlib/_tools/github/create-token/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/create-token/test/test.query.js
@@ -179,7 +179,7 @@ tape( 'function returns rate limit info to a provided callback (error)', functio
 	}
 
 	function done( error, data, info ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( data, null, 'no data' );
 
 		t.deepEqual( info, expected, 'deep equal' );
diff --git a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.query.js
index fe12041254ff..f8b047b4cbfe 100644
--- a/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/delete-token/test/test.query.js
@@ -149,7 +149,7 @@ tape( 'function returns rate limit info to a provided callback (error)', functio
 	}
 
 	function done( error, info ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 
 		t.deepEqual( info, expected, 'deep equal' );
 
diff --git a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.query.js
index 9ebad176e94b..0a15c3fedfbc 100644
--- a/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/dispatch-workflow/test/test.query.js
@@ -146,7 +146,7 @@ tape( 'function returns rate limit info to a provided callback (error)', functio
 	}
 
 	function done( error, info ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/get/test/test.cache.js b/lib/node_modules/@stdlib/_tools/github/get/test/test.cache.js
index e015b573c12d..ef155bc6b17a 100644
--- a/lib/node_modules/@stdlib/_tools/github/get/test/test.cache.js
+++ b/lib/node_modules/@stdlib/_tools/github/get/test/test.cache.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a cache of a specified size', function test( t ) {
 	var cache = create( 10 );
-	t.strictEqual( isArray( cache ), true, 'returns an array' );
+	t.strictEqual( isArray( cache ), true, 'returns expected value' );
 	t.strictEqual( cache.length, 10, 'has length 10' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.shuffle.js b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.shuffle.js
index ac81e37398da..68ca6418b1fc 100644
--- a/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.shuffle.js
+++ b/lib/node_modules/@stdlib/_tools/github/rank-users/test/test.shuffle.js
@@ -68,6 +68,6 @@ tape( 'function returns a shuffled array based on a provided sort vector', funct
 	];
 	actual = shuffle( d, sorted );
 
-	t.deepEqual( actual, expected, 'returns a shuffled array' );
+	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.query.js
index e6a9af5ff773..10c91a9d1f17 100644
--- a/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/set-topics/test/test.query.js
@@ -146,7 +146,7 @@ tape( 'function returns rate limit info to a provided callback (error)', functio
 	}
 
 	function done( error, data, info ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.query.js b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.query.js
index e683a4d8a921..9c3c3cca858d 100644
--- a/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.query.js
+++ b/lib/node_modules/@stdlib/_tools/github/star-repo/test/test.query.js
@@ -146,7 +146,7 @@ tape( 'function returns rate limit info to a provided callback (error)', functio
 	}
 
 	function done( error, info ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.deepEqual( info, expected, 'deep equal' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/licenses/insert-header-file-list/test/test.main.js b/lib/node_modules/@stdlib/_tools/licenses/insert-header-file-list/test/test.main.js
index 872eea0a81ee..56109454b01e 100644
--- a/lib/node_modules/@stdlib/_tools/licenses/insert-header-file-list/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/licenses/insert-header-file-list/test/test.main.js
@@ -215,7 +215,7 @@ tape( 'the function returns an error if an error is encountered when reading a f
 	insertHeader( files, header, done );
 
 	function done( err ) {
-		t.strictEqual( err instanceof Error, true, 'returns an error' );
+		t.strictEqual( err instanceof Error, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -236,7 +236,7 @@ tape( 'the function returns an error if an error is encountered when writing a f
 	insertHeader( files, header, done );
 
 	function done( err ) {
-		t.strictEqual( err instanceof Error, true, 'returns an error' );
+		t.strictEqual( err instanceof Error, true, 'returns expected value' );
 		t.end();
 	}
 
diff --git a/lib/node_modules/@stdlib/_tools/licenses/insert-header-file-list/test/test.sync.js b/lib/node_modules/@stdlib/_tools/licenses/insert-header-file-list/test/test.sync.js
index 92dbc5639bef..b074acc6cc5d 100644
--- a/lib/node_modules/@stdlib/_tools/licenses/insert-header-file-list/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/licenses/insert-header-file-list/test/test.sync.js
@@ -185,7 +185,7 @@ tape( 'the function returns an error if an error is encountered when reading a f
 		'jsdfad': 'beep boop'
 	};
 	err = insertHeader( files, header );
-	t.strictEqual( err instanceof Error, true, 'returns an error' );
+	t.strictEqual( err instanceof Error, true, 'returns expected value' );
 
 	t.end();
 });
@@ -207,7 +207,7 @@ tape( 'the function returns an error if an error is encountered when writing a f
 		'js': '// @license Apache-2.0\n'
 	};
 	err = insertHeader( files, header );
-	t.strictEqual( err instanceof Error, true, 'returns an error' );
+	t.strictEqual( err instanceof Error, true, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/licenses/remove-header-file-list/test/test.main.js b/lib/node_modules/@stdlib/_tools/licenses/remove-header-file-list/test/test.main.js
index f0ec8dffd7d0..dde9f7d50732 100644
--- a/lib/node_modules/@stdlib/_tools/licenses/remove-header-file-list/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/licenses/remove-header-file-list/test/test.main.js
@@ -43,8 +43,8 @@ var EXPECTED = join( __dirname, 'fixtures', 'expected.js.txt' );
 var EXPECTED_SHEBANG = join( __dirname, 'fixtures', 'expected_shebang.js.txt' );
 var SINGLE_LINE_HEADER = join( __dirname, 'fixtures', 'single_line_header.js.txt' );
 var MULTI_LINE_HEADER = join( __dirname, 'fixtures', 'multiline_header.js.txt' );
-var SHEBANG_SINGLE_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_single_line_header.js.txt' ); // eslint-disable-line id-length
-var SHEBANG_MULTI_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_multiline_header.js.txt' ); // eslint-disable-line id-length
+var SHEBANG_SINGLE_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_single_line_header.js.txt' );
+var SHEBANG_MULTI_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_multiline_header.js.txt' );
 
 
 // FUNCTIONS //
@@ -227,7 +227,7 @@ tape( 'the function returns an error if an error is encountered when reading a f
 	removeHeader( files, header, done );
 
 	function done( err ) {
-		t.strictEqual( err instanceof Error, true, 'returns an error' );
+		t.strictEqual( err instanceof Error, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -248,7 +248,7 @@ tape( 'the function returns an error if an error is encountered when writing a f
 	removeHeader( files, header, done );
 
 	function done( err ) {
-		t.strictEqual( err instanceof Error, true, 'returns an error' );
+		t.strictEqual( err instanceof Error, true, 'returns expected value' );
 		t.end();
 	}
 
diff --git a/lib/node_modules/@stdlib/_tools/licenses/remove-header-file-list/test/test.sync.js b/lib/node_modules/@stdlib/_tools/licenses/remove-header-file-list/test/test.sync.js
index d9576c4297f7..16dd3fa4f4a9 100644
--- a/lib/node_modules/@stdlib/_tools/licenses/remove-header-file-list/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/licenses/remove-header-file-list/test/test.sync.js
@@ -42,8 +42,8 @@ var EXPECTED = join( __dirname, 'fixtures', 'expected.js.txt' );
 var EXPECTED_SHEBANG = join( __dirname, 'fixtures', 'expected_shebang.js.txt' );
 var SINGLE_LINE_HEADER = join( __dirname, 'fixtures', 'single_line_header.js.txt' );
 var MULTI_LINE_HEADER = join( __dirname, 'fixtures', 'multiline_header.js.txt' );
-var SHEBANG_SINGLE_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_single_line_header.js.txt' ); // eslint-disable-line id-length
-var SHEBANG_MULTI_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_multiline_header.js.txt' ); // eslint-disable-line id-length
+var SHEBANG_SINGLE_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_single_line_header.js.txt' );
+var SHEBANG_MULTI_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_multiline_header.js.txt' );
 
 
 // FUNCTIONS //
@@ -197,7 +197,7 @@ tape( 'the function returns an error if an error is encountered when reading a f
 		'jsdfad': 'beep boop'
 	};
 	err = removeHeader( files, header );
-	t.strictEqual( err instanceof Error, true, 'returns an error' );
+	t.strictEqual( err instanceof Error, true, 'returns expected value' );
 
 	t.end();
 });
@@ -219,7 +219,7 @@ tape( 'the function returns an error if an error is encountered when writing a f
 		'js': '// @license Apache-2.0\n'
 	};
 	err = removeHeader( files, header );
-	t.strictEqual( err instanceof Error, true, 'returns an error' );
+	t.strictEqual( err instanceof Error, true, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/licenses/update-header-file-list/test/test.main.js b/lib/node_modules/@stdlib/_tools/licenses/update-header-file-list/test/test.main.js
index b5c84e88f47e..6584457f264f 100644
--- a/lib/node_modules/@stdlib/_tools/licenses/update-header-file-list/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/licenses/update-header-file-list/test/test.main.js
@@ -44,8 +44,8 @@ var EXPECTED_SHEBANG = join( __dirname, 'fixtures', 'expected_shebang.js.txt' );
 var EXPECTED_NO_HEADER = join( __dirname, 'fixtures', 'expected_no_header.js.txt' );
 var SINGLE_LINE_HEADER = join( __dirname, 'fixtures', 'single_line_header.js.txt' );
 var MULTI_LINE_HEADER = join( __dirname, 'fixtures', 'multiline_header.js.txt' );
-var SHEBANG_SINGLE_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_single_line_header.js.txt' ); // eslint-disable-line id-length
-var SHEBANG_MULTI_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_multiline_header.js.txt' ); // eslint-disable-line id-length
+var SHEBANG_SINGLE_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_single_line_header.js.txt' );
+var SHEBANG_MULTI_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_multiline_header.js.txt' );
 
 
 // FUNCTIONS //
@@ -269,7 +269,7 @@ tape( 'the function returns an error if an error is encountered when reading a f
 	updateHeader( files, old, {}, done );
 
 	function done( err ) {
-		t.strictEqual( err instanceof Error, true, 'returns an error' );
+		t.strictEqual( err instanceof Error, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -290,7 +290,7 @@ tape( 'the function returns an error if an error is encountered when writing a f
 	updateHeader( files, {}, header, done );
 
 	function done( err ) {
-		t.strictEqual( err instanceof Error, true, 'returns an error' );
+		t.strictEqual( err instanceof Error, true, 'returns expected value' );
 		t.end();
 	}
 
diff --git a/lib/node_modules/@stdlib/_tools/licenses/update-header-file-list/test/test.sync.js b/lib/node_modules/@stdlib/_tools/licenses/update-header-file-list/test/test.sync.js
index 7da194d043b5..907c32f25f1a 100644
--- a/lib/node_modules/@stdlib/_tools/licenses/update-header-file-list/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/licenses/update-header-file-list/test/test.sync.js
@@ -43,8 +43,8 @@ var EXPECTED_SHEBANG = join( __dirname, 'fixtures', 'expected_shebang.js.txt' );
 var EXPECTED_NO_HEADER = join( __dirname, 'fixtures', 'expected_no_header.js.txt' );
 var SINGLE_LINE_HEADER = join( __dirname, 'fixtures', 'single_line_header.js.txt' );
 var MULTI_LINE_HEADER = join( __dirname, 'fixtures', 'multiline_header.js.txt' );
-var SHEBANG_SINGLE_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_single_line_header.js.txt' ); // eslint-disable-line id-length
-var SHEBANG_MULTI_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_multiline_header.js.txt' ); // eslint-disable-line id-length
+var SHEBANG_SINGLE_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_single_line_header.js.txt' );
+var SHEBANG_MULTI_LINE_HEADER = join( __dirname, 'fixtures', 'shebang_multiline_header.js.txt' );
 
 
 // FUNCTIONS //
@@ -239,7 +239,7 @@ tape( 'the function returns an error if an error is encountered when reading a f
 		'jsdfad': 'beep boop'
 	};
 	err = updateHeader( files, old, {} );
-	t.strictEqual( err instanceof Error, true, 'returns an error' );
+	t.strictEqual( err instanceof Error, true, 'returns expected value' );
 
 	t.end();
 });
@@ -261,7 +261,7 @@ tape( 'the function returns an error if an error is encountered when writing a f
 		'js': '// @license Apache-2.0\n'
 	};
 	err = updateHeader( files, {}, header );
-	t.strictEqual( err instanceof Error, true, 'returns an error' );
+	t.strictEqual( err instanceof Error, true, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/links/create/test/test.cli.js b/lib/node_modules/@stdlib/_tools/links/create/test/test.cli.js
index 4889f7b9be42..d90dd3b33f0d 100644
--- a/lib/node_modules/@stdlib/_tools/links/create/test/test.cli.js
+++ b/lib/node_modules/@stdlib/_tools/links/create/test/test.cli.js
@@ -156,7 +156,7 @@ tape( 'the command-line interface tries to insert an entry for the provided URI
 	expected = 'Error: duplicate entry. Database already contains an entry for the provided URI: https://stdlib.io/.\n';
 
 	function done( error, stdout, stderr ) {
-		t.strictEqual( error instanceof Error, true, 'returns an error' );
+		t.strictEqual( error instanceof Error, true, 'returns expected value' );
 		t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
 		t.strictEqual( stderr.toString(), expected, 'prints error message' );
 		t.end();
@@ -185,7 +185,7 @@ tape( 'the command-line interface tries to insert an entry for the provided URI
 	function done( error, stdout, stderr ) {
 		stdout = stdout.toString();
 		t.strictEqual( stdout.length > 10, true, 'prints prompts' );
-		t.strictEqual( error instanceof Error, true, 'returns an error' );
+		t.strictEqual( error instanceof Error, true, 'returns expected value' );
 		t.strictEqual( stderr.toString(), expected, 'prints error message' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/links/create/test/test.sync.js b/lib/node_modules/@stdlib/_tools/links/create/test/test.sync.js
index 69fe12fd4036..61f80bb4e91a 100644
--- a/lib/node_modules/@stdlib/_tools/links/create/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/links/create/test/test.sync.js
@@ -75,7 +75,7 @@ tape( 'if the function encounters an error when attempting to read a database, t
 		'database': './nonexisting.json'
 	};
 	var out = create( opts );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.end();
 });
 
@@ -195,7 +195,7 @@ tape( 'the function returns an error when the link database already contains an
 		'database': database
 	};
 	out = create( opts );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.end();
 });
 
@@ -214,6 +214,6 @@ tape( 'the function returns an error when the link database already contains an
 		'database': database
 	};
 	out = create( opts );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.sync.js b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.sync.js
index 0e65fbccfc41..f23507002c4f 100644
--- a/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/links/id2uri/test/test.sync.js
@@ -63,7 +63,7 @@ tape( 'if the function encounters an error when attempting to read a database, t
 	var out = id2uri( 'sublime-text', {
 		'database': './nonexisting.json'
 	});
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.sync.js b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.sync.js
index 37b53bac762b..7f3a5f688deb 100644
--- a/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/links/uri2id/test/test.sync.js
@@ -64,7 +64,7 @@ tape( 'if the function encounters an error when attempting to read a database, t
 	var out = uri2id( 'https://www.sublimetext.com/', {
 		'database': './nonexisting.json'
 	});
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/links/validate/test/test.sync.js b/lib/node_modules/@stdlib/_tools/links/validate/test/test.sync.js
index d02fe392cfc9..d7230a63e75d 100644
--- a/lib/node_modules/@stdlib/_tools/links/validate/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/links/validate/test/test.sync.js
@@ -70,7 +70,7 @@ tape( 'if the function encounters an error when attempting to read a database, t
 	var out = validateLinks( LINKS, {
 		'database': './nonexisting.json'
 	});
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.async.js b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.async.js
index 18b819eb61d5..3952bfc21568 100644
--- a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.async.js
@@ -118,7 +118,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -135,7 +135,7 @@ tape( 'the function returns an empty array if all filenames are valid', function
 			t.ok( false, error.message );
 		}
 		bool = ( isArray( names ) && names.length === 0 );
-		t.strictEqual( bool, true, 'returns an empty array' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -152,7 +152,7 @@ tape( 'the function returns an object array if filenames are not valid', functio
 			t.ok( false, error.message );
 		}
 		bool = isObjectArray( names );
-		t.strictEqual( bool, true, 'returns an object array' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.lint.js b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.lint.js
index 33b26ff2af59..3b740f1f438a 100644
--- a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.lint.js
+++ b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.lint.js
@@ -156,7 +156,7 @@ tape( 'the function returns an empty array if all filenames are valid', function
 	];
 	names = lint( values );
 
-	t.strictEqual( isArray( names ), true, 'returns an array' );
-	t.strictEqual( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns expected value' );
+	t.strictEqual( names.length, 0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.sync.js b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.sync.js
index f3adc2a053e8..402b06a2dbd9 100644
--- a/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/lint/filenames/test/test.sync.js
@@ -61,7 +61,7 @@ tape( 'the function returns an empty array if unable to resolve files', function
 	names = lint();
 	bool = ( isArray( names ) && names.length === 0 );
 
-	t.strictEqual( bool, true, 'returns an empty array' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 
 	function glob() {
@@ -80,7 +80,7 @@ tape( 'the function returns an empty array if all filenames are valid', function
 	names = lint( opts );
 
 	bool = ( isArray( names ) && names.length === 0 );
-	t.strictEqual( bool, true, 'returns an empty array' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -93,7 +93,7 @@ tape( 'the function returns an object array if filenames are not valid', functio
 	};
 	names = lint( opts );
 
-	t.strictEqual( isObjectArray( names ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( names ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.async.js b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.async.js
index 3a45d30b1f4e..6f2c4885f9c6 100644
--- a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.async.js
@@ -118,7 +118,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -134,7 +134,7 @@ tape( 'the function returns an empty array if all header filenames are valid', f
 			t.ok( false, error.message );
 		}
 		bool = ( isArray( names ) && names.length === 0 );
-		t.strictEqual( bool, true, 'returns an empty array' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -150,7 +150,7 @@ tape( 'the function returns an object array if header filenames are not valid',
 			t.ok( false, error.message );
 		}
 		bool = isObjectArray( names );
-		t.strictEqual( bool, true, 'returns an object array' );
+		t.strictEqual( bool, true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.lint.js b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.lint.js
index 7aba63eeb2bf..914393c6cc81 100644
--- a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.lint.js
+++ b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.lint.js
@@ -46,7 +46,7 @@ tape( 'the function enforces that all header base filenames differ from C standa
 	];
 	names = lint( values );
 
-	t.strictEqual( isObjectArray( names ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( names ), true, 'returns expected value' );
 	t.strictEqual( names.length, values.length, 'has expected length' );
 	t.end();
 });
@@ -62,7 +62,7 @@ tape( 'the function enforces that all header base filenames differ from C++ stan
 	];
 	names = lint( values );
 
-	t.strictEqual( isObjectArray( names ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( names ), true, 'returns expected value' );
 	t.strictEqual( names.length, values.length, 'has expected length' );
 	t.end();
 });
@@ -88,7 +88,7 @@ tape( 'the function enforces that all header base filenames are valid', function
 	}
 	names = lint( values );
 
-	t.strictEqual( isObjectArray( names ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( names ), true, 'returns expected value' );
 	t.strictEqual( names.length, values.length, 'has expected length' );
 	t.end();
 });
@@ -114,7 +114,7 @@ tape( 'the function returns an empty array if all header base filenames are vali
 	}
 	names = lint( values );
 
-	t.strictEqual( isArray( names ), true, 'returns an array' );
-	t.strictEqual( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns expected value' );
+	t.strictEqual( names.length, 0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.sync.js b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.sync.js
index 0e8fa93fcd2e..514e81e006a0 100644
--- a/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/lint/header-filenames/test/test.sync.js
@@ -61,7 +61,7 @@ tape( 'the function returns an empty array if unable to resolve header files', f
 	names = lint();
 	bool = ( isArray( names ) && names.length === 0 );
 
-	t.strictEqual( bool, true, 'returns an empty array' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 
 	function glob() {
@@ -80,7 +80,7 @@ tape( 'the function returns an empty array if all header filenames are valid', f
 	names = lint( opts );
 
 	bool = ( isArray( names ) && names.length === 0 );
-	t.strictEqual( bool, true, 'returns an empty array' );
+	t.strictEqual( bool, true, 'returns expected value' );
 	t.end();
 });
 
@@ -93,7 +93,7 @@ tape( 'the function returns an object array if header filenames are not valid',
 	};
 	names = lint( opts );
 
-	t.strictEqual( isObjectArray( names ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( names ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/license-header-file-list/test/test.main.js b/lib/node_modules/@stdlib/_tools/lint/license-header-file-list/test/test.main.js
index 10ec315ab231..617a8d5805e6 100644
--- a/lib/node_modules/@stdlib/_tools/lint/license-header-file-list/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/lint/license-header-file-list/test/test.main.js
@@ -206,7 +206,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	lint( [ './kdfjalkfjdsakjfsadjf/balkdfladsjfkl.kdflasj' ], clbk );
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -216,7 +216,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	lint( [ './kdfjalkfjdsakjfsadjf/balkdfladsjfkl.kdflasj' ], 'beep boop', clbk );
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -228,7 +228,7 @@ tape( 'the function returns an empty array if provided an empty file array', opt
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+		t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -240,7 +240,7 @@ tape( 'the function returns an empty array if provided an empty file array (head
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+		t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -252,7 +252,7 @@ tape( 'the function returns an empty array if all files are valid', opts, functi
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+		t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -264,7 +264,7 @@ tape( 'the function returns an object array if files are not valid', opts, funct
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -276,7 +276,7 @@ tape( 'the function returns an object array if files are not valid (multiple hea
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.strictEqual( errs.length, 1, 'has expected length' );
 		t.end();
 	}
@@ -289,7 +289,7 @@ tape( 'the function returns an object array if files are not valid (start locati
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.strictEqual( errs.length, 1, 'has expected length' );
 		t.end();
 	}
@@ -303,7 +303,7 @@ tape( 'the function supports specifying a license header string to lint against'
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -316,7 +316,7 @@ tape( 'the function supports specifying a license header regular expression to l
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -332,7 +332,7 @@ tape( 'the function supports specifying a license header object mapping strings
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -345,7 +345,7 @@ tape( 'the function supports specifying an empty license header object', opts, f
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+		t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -360,7 +360,7 @@ tape( 'the function supports specifying a default license header when providing
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+		t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -375,7 +375,7 @@ tape( 'the function supports specifying a default license header when providing
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/license-header-file-list/test/test.sync.js b/lib/node_modules/@stdlib/_tools/lint/license-header-file-list/test/test.sync.js
index 2a7e4588c965..cff60188d5c4 100644
--- a/lib/node_modules/@stdlib/_tools/lint/license-header-file-list/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/lint/license-header-file-list/test/test.sync.js
@@ -151,7 +151,7 @@ tape( 'the function returns an error if an error is encountered when linting fil
 	files = [ 'dakfjdlfjsdfjasdjf/aldfkajdlfjsadl.jsdfad' ]; // File should not exist!
 
 	errs = lint( files );
-	t.strictEqual( errs instanceof Error, true, 'returns an error' );
+	t.strictEqual( errs instanceof Error, true, 'returns expected value' );
 
 	t.end();
 });
@@ -163,45 +163,45 @@ tape( 'the function returns an error if an error is encountered when linting fil
 	files = [ 'dakfjdlfjsdfjasdjf/aldfkajdlfjsadl.jsdfad' ]; // File should not exist!
 
 	errs = lint( files, '// @license Apache-2.0' );
-	t.strictEqual( errs instanceof Error, true, 'returns an error' );
+	t.strictEqual( errs instanceof Error, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns an empty array if provided an empty file array', opts, function test( t ) {
 	var errs = lint( [] );
-	t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+	t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an empty array if provided an empty file array (header argument)', opts, function test( t ) {
 	var errs = lint( [], '// @license Apache-2.0' );
-	t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+	t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an empty array if all files are valid', opts, function test( t ) {
 	var errs = lint( fixtures.good );
-	t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+	t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an object array if files are not valid', opts, function test( t ) {
 	var errs = lint( fixtures.bad );
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an object array if files are not valid (multiple headers)', opts, function test( t ) {
 	var errs = lint( fixtures.multiple );
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.strictEqual( errs.length, 1, 'has expected length' );
 	t.end();
 });
 
 tape( 'the function returns an object array if files are not valid (start location)', opts, function test( t ) {
 	var errs = lint( fixtures.startLocation );
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.strictEqual( errs.length, 1, 'has expected length' );
 	t.end();
 });
@@ -213,7 +213,7 @@ tape( 'the function supports specifying a license header string to lint against'
 	header = '// This file is licensed under Apache-2.0.';
 	errs = lint( fixtures.good, header );
 
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -224,7 +224,7 @@ tape( 'the function supports specifying a license header regular expression to l
 	header = /\/\/ This file is licensed under Apache-2\.0\./;
 	errs = lint( fixtures.good, header );
 
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -238,7 +238,7 @@ tape( 'the function supports specifying a license header object mapping strings
 	};
 	errs = lint( fixtures.good, header );
 
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -249,7 +249,7 @@ tape( 'the function supports specifying an empty license header object', opts, f
 	header = {};
 	errs = lint( fixtures.good, header );
 
-	t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+	t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -262,7 +262,7 @@ tape( 'the function supports specifying a default license header when providing
 	};
 	errs = lint( fixtures.good, header );
 
-	t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+	t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -275,6 +275,6 @@ tape( 'the function supports specifying a default license header when providing
 	};
 	errs = lint( fixtures.bad, header );
 
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.main.js b/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.main.js
index e4aaa2077c98..c4ba00d70193 100644
--- a/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.main.js
@@ -128,7 +128,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -159,7 +159,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -177,7 +177,7 @@ tape( 'the function returns an empty array if all files are valid', opts, functi
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+		t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -195,7 +195,7 @@ tape( 'the function returns an object array if files are not valid', opts, funct
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -213,7 +213,7 @@ tape( 'the function returns an object array if files are not valid (multiple hea
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.strictEqual( errs.length, 1, 'has expected length' );
 		t.end();
 	}
@@ -232,7 +232,7 @@ tape( 'the function returns an object array if files are not valid (start locati
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.strictEqual( errs.length, 1, 'has expected length' );
 		t.end();
 	}
@@ -252,7 +252,7 @@ tape( 'the function supports specifying a filename pattern (valid)', opts, funct
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+		t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -271,7 +271,7 @@ tape( 'the function supports specifying a filename pattern (invalid)', opts, fun
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -291,7 +291,7 @@ tape( 'the function supports specifying a list of glob patterns to exclude match
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+		t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -311,7 +311,7 @@ tape( 'the function supports specifying a license header string to lint against'
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -331,7 +331,7 @@ tape( 'the function supports specifying a license header regular expression to l
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -354,7 +354,7 @@ tape( 'the function supports specifying a license header object mapping strings
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -374,7 +374,7 @@ tape( 'the function supports specifying an empty license header object', opts, f
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+		t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -396,7 +396,7 @@ tape( 'the function supports specifying a default license header when providing
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+		t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -418,7 +418,7 @@ tape( 'the function supports specifying a default license header when providing
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+		t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.sync.js b/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.sync.js
index 76c506277de2..25c8bae1aacf 100644
--- a/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/lint/license-header-glob/test/test.sync.js
@@ -92,7 +92,7 @@ tape( 'the function returns an empty array if unable to resolve files', opts, fu
 
 	errs = lint();
 
-	t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+	t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 	t.end();
 
 	function glob() {
@@ -112,7 +112,7 @@ tape( 'the function returns an empty array if all files are valid', opts, functi
 	};
 	errs = lint( opts );
 
-	t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+	t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -128,7 +128,7 @@ tape( 'the function returns an object array if files are not valid', opts, funct
 	};
 	errs = lint( opts );
 
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -144,7 +144,7 @@ tape( 'the function returns an object array if files are not valid (multiple hea
 	};
 	errs = lint( opts );
 
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.strictEqual( errs.length, 1, 'has expected length' );
 	t.end();
 });
@@ -161,7 +161,7 @@ tape( 'the function returns an object array if files are not valid (start locati
 	};
 	errs = lint( opts );
 
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.strictEqual( errs.length, 1, 'has expected length' );
 	t.end();
 });
@@ -179,7 +179,7 @@ tape( 'the function supports specifying a filename pattern (valid)', opts, funct
 	};
 	errs = lint( opts );
 
-	t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+	t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -196,7 +196,7 @@ tape( 'the function supports specifying a filename pattern (invalid)', opts, fun
 	};
 	errs = lint( opts );
 
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -212,7 +212,7 @@ tape( 'the function supports specifying a list of glob patterns to exclude match
 	};
 	errs = lint( opts );
 
-	t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+	t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -230,7 +230,7 @@ tape( 'the function supports specifying a license header string to lint against'
 	};
 	errs = lint( opts );
 
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -248,7 +248,7 @@ tape( 'the function supports specifying a license header regular expression to l
 	};
 	errs = lint( opts );
 
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -269,7 +269,7 @@ tape( 'the function supports specifying a license header object mapping strings
 	};
 	errs = lint( opts );
 
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -287,7 +287,7 @@ tape( 'the function supports specifying an empty license header object', opts, f
 	};
 	errs = lint( opts );
 
-	t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+	t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -307,7 +307,7 @@ tape( 'the function supports specifying a default license header when providing
 	};
 	errs = lint( opts );
 
-	t.strictEqual( isEmptyArray( errs ), true, 'returns an empty array' );
+	t.strictEqual( isEmptyArray( errs ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -327,6 +327,6 @@ tape( 'the function supports specifying a default license header when providing
 	};
 	errs = lint( opts );
 
-	t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/lint/pkg-json/test/test.async.js b/lib/node_modules/@stdlib/_tools/lint/pkg-json/test/test.async.js
index de848bb76c3b..8040625eb128 100644
--- a/lib/node_modules/@stdlib/_tools/lint/pkg-json/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/lint/pkg-json/test/test.async.js
@@ -122,7 +122,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -149,7 +149,7 @@ tape( 'the function returns an error to a provided callback if a fatal error is
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -212,10 +212,10 @@ tape( 'the function returns an array of lint errors to a provided callback if on
 		var cb = arguments[ arguments.length-1 ];
 		setTimeout( onTimeout, 0 );
 		function onTimeout() {
-			cb( null, [ {
+			cb( null, [{
 				'file': 'beep',
 				'message': 'boop'
-			} ] );
+			}]);
 		}
 	}
 
@@ -223,7 +223,7 @@ tape( 'the function returns an array of lint errors to a provided callback if on
 		if ( error ) {
 			t.ok( false, error.message );
 		} else {
-			t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+			t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		}
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/lint/repl-txt/test/test.async.js b/lib/node_modules/@stdlib/_tools/lint/repl-txt/test/test.async.js
index 6b6f915e4409..823e7b226c30 100644
--- a/lib/node_modules/@stdlib/_tools/lint/repl-txt/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/lint/repl-txt/test/test.async.js
@@ -122,7 +122,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -150,7 +150,7 @@ tape( 'the function returns an error to a provided callback if a fatal error is
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -215,10 +215,10 @@ tape( 'the function returns an array of lint errors to a provided callback if on
 		var cb = arguments[ arguments.length-1 ];
 		setTimeout( onTimeout, 0 );
 		function onTimeout() {
-			cb( null, [ {
+			cb( null, [{
 				'file': 'beep',
 				'message': 'boop'
-			} ] );
+			}]);
 		}
 	}
 
@@ -226,7 +226,7 @@ tape( 'the function returns an array of lint errors to a provided callback if on
 		if ( error ) {
 			t.ok( false, error.message );
 		} else {
-			t.strictEqual( isObjectArray( errs ), true, 'returns an object array' );
+			t.strictEqual( isObjectArray( errs ), true, 'returns expected value' );
 		}
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.async.js b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.async.js
index b34b279dd485..415af4c9fc76 100644
--- a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.async.js
@@ -131,7 +131,7 @@ tape( 'the function returns an empty array if unable to find matching files', fu
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.deepEqual( actual, expected, 'returns an empty array' );
+		t.deepEqual( actual, expected, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.sync.js b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.sync.js
index d05409f7cd08..f3b6a85e8e78 100644
--- a/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/modules/import-require-glob/test/test.sync.js
@@ -75,7 +75,7 @@ tape( 'the function returns an empty array if unable to find matching files', fu
 	expected = [];
 	actual = ls( opts );
 
-	t.deepEqual( actual, expected, 'returns an empty array' );
+	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.async.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.async.js
index f459c3d14ec3..fb772af25eb0 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.async.js
@@ -377,7 +377,7 @@ tape( 'the function returns an error if an error occurs while resolving package
 	pkgDeps( 'kaflasdjflsajflkjsd2r0923lajdflkaj20902', clbk );
 
 	function clbk( err ) {
-		t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.filter_builtins.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.filter_builtins.js
index bfa81fc26907..6a55fd06c31b 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.filter_builtins.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.filter_builtins.js
@@ -63,7 +63,7 @@ tape( 'the function removes built-in module names from a list of strings', funct
 
 tape( 'if provided an empty array, the function returns an empty array', function test( t ) {
 	var out = filter( [] );
-	t.deepEqual( out, [], 'returns an empty array' );
+	t.deepEqual( out, [], 'returns expected value' );
 	t.end();
 });
 
@@ -82,7 +82,7 @@ tape( 'if provided a list of built-in module names, the function returns an empt
 	expected = [];
 
 	actual = filter( arr );
-	t.deepEqual( actual, expected, 'returns an empty array' );
+	t.deepEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.sync.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.sync.js
index 6fa44a6f87a0..ae0ce5b7a360 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.sync.js
@@ -279,6 +279,6 @@ tape( 'the function returns a list of package dependencies (no built-ins)', func
 
 tape( 'the function returns an error if an error occurs while resolving package dependencies', function test( t ) {
 	var err = pkgDeps( 'kaflasdjflsajflkjsd2r0923lajdflkaj20902' );
-	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.to_array.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.to_array.js
index 38469e984dbb..efce77c8180a 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.to_array.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.to_array.js
@@ -68,7 +68,7 @@ tape( 'the function converts a file cache object to an array', function test( t
 
 	actual = toArray( obj );
 
-	t.strictEqual( isArray( actual ), true, 'returns an array' );
+	t.strictEqual( isArray( actual ), true, 'returns expected value' );
 
 	// Note: key iteration order is non-deterministic, so must account for result order variability...
 	if ( actual[ 0 ].file === expected[ 0 ].file ) {
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.js
index 6927e76aeae4..8eb3e52c4c4d 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.js
@@ -171,7 +171,7 @@ tape( 'the function returns an error if unable to read an input file', function
 	}
 
 	function clbk( err ) {
-		t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 		t.strictEqual( err.message, 'beep', 'returns expected error' );
 		t.end();
 	}
@@ -208,7 +208,7 @@ tape( 'the function returns an error if unable to read a relative module depende
 	}
 
 	function clbk( err ) {
-		t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 		t.strictEqual( err.message, 'boop', 'returns expected error' );
 		t.end();
 	}
@@ -246,7 +246,7 @@ tape( 'the function returns an error if unable to read a relative module depende
 	}
 
 	function clbk( err ) {
-		t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 		t.strictEqual( err.message, 'boop1', 'returns expected error' );
 		t.end();
 	}
@@ -281,7 +281,7 @@ tape( 'the function returns an error if unable to resolve a relative module depe
 	}
 
 	function clbk( err ) {
-		t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 		t.strictEqual( err.message, 'boop', 'returns expected error' );
 		t.end();
 	}
@@ -316,7 +316,7 @@ tape( 'the function returns an error if unable to resolve a relative module depe
 	}
 
 	function clbk( err ) {
-		t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 		t.strictEqual( err.message, 'boop1', 'returns expected error' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.sync.js b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.sync.js
index db27ba80508b..c6c321d93689 100644
--- a/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.sync.js
+++ b/lib/node_modules/@stdlib/_tools/modules/pkg-deps/test/test.walk_file.sync.js
@@ -156,7 +156,7 @@ tape( 'the function returns an error if unable to read an input file', function
 
 	err = walk( {}, '/beep/boop.js', opts );
 
-	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 	t.strictEqual( err.message, 'beep', 'returns expected error' );
 	t.end();
 
@@ -187,7 +187,7 @@ tape( 'the function returns an error if unable to read a relative module depende
 
 	err = walk( {}, fpath1, opts );
 
-	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 	t.strictEqual( err.message, 'boop', 'returns expected error' );
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.async.js
index 0b279d8a0a68..cc4443f0d407 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.async.js
@@ -123,7 +123,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -150,7 +150,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -174,8 +174,8 @@ tape( 'the function returns an empty array if unable to resolve any add-ons', fu
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+		t.strictEqual( pkgs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -201,7 +201,7 @@ tape( 'the function returns a string array (if at least one add-on is detected;
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( pkgs ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( pkgs ), true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.inspect.js b/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.inspect.js
index df571abd5882..387082dffbf2 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.inspect.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.inspect.js
@@ -59,7 +59,7 @@ tape( 'the function returns a string array if able to detect at least one add-on
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( pkgs ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( pkgs ), true, 'returns expected value' );
 		t.strictEqual( pkgs.length, 1, 'expected length' );
 		t.end();
 	}
@@ -72,8 +72,8 @@ tape( 'the function returns an empty array if unable to detect at least one add-
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+		t.strictEqual( pkgs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -93,8 +93,8 @@ tape( 'the function returns an empty array if unable to detect at least one add-
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+		t.strictEqual( pkgs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -114,8 +114,8 @@ tape( 'the function returns an empty array if unable to detect at least one add-
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+		t.strictEqual( pkgs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.sync.js
index e9b5c92ff0f6..e643e713f2eb 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/addons/test/test.sync.js
@@ -74,7 +74,7 @@ tape( 'the function returns a string array (if at least one add-on is detected)'
 	};
 	pkgs = findAddons( opts );
 
-	t.strictEqual( isStringArray( pkgs ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( pkgs ), true, 'returns expected value' );
 	t.strictEqual( pkgs.length, 1, 'expected length' );
 
 	t.end();
@@ -104,8 +104,8 @@ tape( 'the function returns an empty array if unable to resolve any add-ons', fu
 
 	pkgs = findAddons();
 
-	t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-	t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+	t.strictEqual( pkgs.length, 0, 'returns expected value' );
 
 	t.end();
 
@@ -126,8 +126,8 @@ tape( 'the function returns an empty array if unable to resolve any packages', f
 
 	pkgs = findAddons();
 
-	t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-	t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+	t.strictEqual( pkgs.length, 0, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.async.js
index b16fcc669432..e6d4f2ca6ef6 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.async.js
@@ -147,7 +147,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -158,7 +158,7 @@ tape( 'the function returns a string array', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -172,7 +172,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -186,7 +186,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -203,8 +203,8 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( names ), true, 'returns an array' );
-		t.strictEqual( names.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( names ), true, 'returns expected value' );
+		t.strictEqual( names.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.sync.js
index 648c1a86b1c3..92ca73f389f2 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/browser-compatible/test/test.sync.js
@@ -75,7 +75,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var names = ls();
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -88,7 +88,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 	};
 	names = ls( opts );
 
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -101,7 +101,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 	};
 	names = ls( opts );
 
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -117,7 +117,7 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 	};
 	names = ls( opts );
 
-	t.strictEqual( isArray( names ), true, 'returns an array' );
-	t.strictEqual( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns expected value' );
+	t.strictEqual( names.length, 0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.async.js
index 6fd9a03b0e89..25688f269e59 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.async.js
@@ -123,7 +123,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -150,7 +150,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -174,8 +174,8 @@ tape( 'the function returns an empty array if unable to resolve any packages', f
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( files ), true, 'returns an array' );
-		t.strictEqual( files.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( files ), true, 'returns expected value' );
+		t.strictEqual( files.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -189,7 +189,7 @@ tape( 'the function returns a string array (if at least one `package.json` refer
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( files ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( files ), true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.read_pkgs.js b/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.read_pkgs.js
index 9e9e65b9d0a1..3d0e1f4d4462 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.read_pkgs.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.read_pkgs.js
@@ -59,7 +59,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -71,7 +71,7 @@ tape( 'the function returns a string array', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( files ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( files ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -83,8 +83,8 @@ tape( 'the function returns an empty array if no `package.json` files reference
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( files ), true, 'returns an array' );
-		t.strictEqual( files.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( files ), true, 'returns expected value' );
+		t.strictEqual( files.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.sync.js
index 9ef702e25c5c..6892e4ccb544 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/clis/test/test.sync.js
@@ -90,7 +90,7 @@ tape( 'the function returns a string array (if at least one `package.json` refer
 	};
 	files = findCLIs( opts );
 
-	t.strictEqual( isStringArray( files ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( files ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -107,7 +107,7 @@ tape( 'the function supports `package.json` files having `bin` fields with strin
 
 	files = findCLIs();
 
-	t.strictEqual( isStringArray( files ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( files ), true, 'returns expected value' );
 
 	t.end();
 
@@ -128,8 +128,8 @@ tape( 'the function returns an empty array if unable to resolve any CLIs', funct
 
 	files = findCLIs();
 
-	t.strictEqual( isArray( files ), true, 'returns an array' );
-	t.strictEqual( files.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( files ), true, 'returns expected value' );
+	t.strictEqual( files.length, 0, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.async.js
index 096940828cd7..bcd5593ed69a 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.async.js
@@ -125,7 +125,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -152,7 +152,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -176,8 +176,8 @@ tape( 'the function returns an empty array if unable to resolve any packages', f
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( cmds ), true, 'returns an array' );
-		t.strictEqual( cmds.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( cmds ), true, 'returns expected value' );
+		t.strictEqual( cmds.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -191,7 +191,7 @@ tape( 'the function returns a string array (if at least one `package.json` refer
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( cmds ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( cmds ), true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.read_pkgs.js b/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.read_pkgs.js
index d04531a88259..71a63d051610 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.read_pkgs.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.read_pkgs.js
@@ -59,7 +59,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -71,7 +71,7 @@ tape( 'the function returns a string array', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( cmds ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( cmds ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -83,8 +83,8 @@ tape( 'the function returns an empty array if no `package.json` files reference
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( cmds ), true, 'returns an array' );
-		t.strictEqual( cmds.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( cmds ), true, 'returns expected value' );
+		t.strictEqual( cmds.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.sync.js
index e71156af59f6..3e96860c8541 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/cmds/test/test.sync.js
@@ -90,7 +90,7 @@ tape( 'the function returns a string array (if at least one `package.json` refer
 	};
 	cmds = findCommands( opts );
 
-	t.strictEqual( isStringArray( cmds ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( cmds ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -107,7 +107,7 @@ tape( 'the function supports `package.json` files having `bin` fields with strin
 
 	cmds = findCommands();
 
-	t.strictEqual( isStringArray( cmds ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( cmds ), true, 'returns expected value' );
 
 	t.end();
 
@@ -128,8 +128,8 @@ tape( 'the function returns an empty array if unable to resolve any CLIs', funct
 
 	cmds = findCommands();
 
-	t.strictEqual( isArray( cmds ), true, 'returns an array' );
-	t.strictEqual( cmds.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( cmds ), true, 'returns expected value' );
+	t.strictEqual( cmds.length, 0, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.js
index e8d26cbb69f3..96667b804923 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/dep-list/test/test.js
@@ -102,7 +102,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var deps = depList( '@stdlib/regexp' );
-	t.strictEqual( isStringArray( deps ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( deps ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -127,6 +127,6 @@ tape( 'the function returns a string array (dev option)', function test( t ) {
 	};
 	deps = depList( '@stdlib/regexp', opts );
 
-	t.strictEqual( isStringArray( deps ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( deps ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.async.js
index 1861df3b4d41..e9cae9418aab 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.async.js
@@ -123,7 +123,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -137,7 +137,7 @@ tape( 'the function returns a string array (if able to resolve packages)', funct
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( pkgs ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( pkgs ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -161,8 +161,8 @@ tape( 'the function returns an empty array (if unable to resolve packages)', fun
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+		t.strictEqual( pkgs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.sync.js
index 0db414b0ce36..d32a01d3e5e0 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/find/test/test.sync.js
@@ -61,7 +61,7 @@ tape( 'the function returns a string array (if able to resolve packages)', funct
 	};
 	pkgs = findPkgs( opts );
 
-	t.strictEqual( isStringArray( pkgs ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( pkgs ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -77,8 +77,8 @@ tape( 'the function returns an empty array (if unable to resolve packages)', fun
 	});
 	pkgs = findPkgs();
 
-	t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-	t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+	t.strictEqual( pkgs.length, 0, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.inspect.js b/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.inspect.js
index b49df75d05d1..d0be093bdf3c 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.inspect.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.inspect.js
@@ -69,7 +69,7 @@ tape( 'the function returns a string array if able to detect at least one packag
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( dirs ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( dirs ), true, 'returns expected value' );
 		t.strictEqual( dirs.length, 1, 'expected length' );
 		t.end();
 	}
@@ -93,8 +93,8 @@ tape( 'the function returns an empty array if unable to detect at least one pack
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( dirs ), true, 'returns an array' );
-		t.strictEqual( dirs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( dirs ), true, 'returns expected value' );
+		t.strictEqual( dirs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -115,8 +115,8 @@ tape( 'the function returns an empty array if unable to detect at least one pack
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( dirs ), true, 'returns an array' );
-		t.strictEqual( dirs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( dirs ), true, 'returns expected value' );
+		t.strictEqual( dirs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -137,8 +137,8 @@ tape( 'the function returns an empty array if unable to detect at least one pack
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( dirs ), true, 'returns an array' );
-		t.strictEqual( dirs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( dirs ), true, 'returns expected value' );
+		t.strictEqual( dirs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.main.js b/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.main.js
index 4717807954da..a407a0db9e2f 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.main.js
@@ -123,7 +123,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -150,7 +150,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -174,8 +174,8 @@ tape( 'the function returns an empty array if unable to resolve any packages con
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( dirs ), true, 'returns an array' );
-		t.strictEqual( dirs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( dirs ), true, 'returns expected value' );
+		t.strictEqual( dirs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -202,7 +202,7 @@ tape( 'the function returns a string array (if at least one package containing a
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( dirs ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( dirs ), true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.sync.js
index ae7c601e7631..17b0620deeb7 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/includes/test/test.sync.js
@@ -73,7 +73,7 @@ tape( 'the function returns a string array (if at least one package containing a
 	};
 	dirs = findIncludes( opts );
 
-	t.strictEqual( isStringArray( dirs ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( dirs ), true, 'returns expected value' );
 	t.strictEqual( dirs.length, 1, 'expected length' );
 
 	t.end();
@@ -113,8 +113,8 @@ tape( 'the function returns an empty array if unable to resolve any packages con
 
 	dirs = findIncludes();
 
-	t.strictEqual( isArray( dirs ), true, 'returns an array' );
-	t.strictEqual( dirs.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( dirs ), true, 'returns expected value' );
+	t.strictEqual( dirs.length, 0, 'returns expected value' );
 
 	t.end();
 
@@ -139,8 +139,8 @@ tape( 'the function returns an empty array if unable to resolve any `include` di
 
 	dirs = findIncludes();
 
-	t.strictEqual( isArray( dirs ), true, 'returns an array' );
-	t.strictEqual( dirs.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( dirs ), true, 'returns expected value' );
+	t.strictEqual( dirs.length, 0, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.async.js
index a24068db2b10..f50449c46750 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.async.js
@@ -145,7 +145,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -156,7 +156,7 @@ tape( 'the function returns a string array', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -170,7 +170,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -184,7 +184,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -201,8 +201,8 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( names ), true, 'returns an array' );
-		t.strictEqual( names.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( names ), true, 'returns expected value' );
+		t.strictEqual( names.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.sync.js
index 648c1a86b1c3..92ca73f389f2 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/names/test/test.sync.js
@@ -75,7 +75,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var names = ls();
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -88,7 +88,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 	};
 	names = ls( opts );
 
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -101,7 +101,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 	};
 	names = ls( opts );
 
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -117,7 +117,7 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 	};
 	names = ls( opts );
 
-	t.strictEqual( isArray( names ), true, 'returns an array' );
-	t.strictEqual( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns expected value' );
+	t.strictEqual( names.length, 0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.js b/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.js
index 3031b444196f..9dce3c84deef 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespace-deps/test/test.js
@@ -102,7 +102,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var deps = namespaceDeps( '@stdlib/regexp' );
-	t.strictEqual( isStringArray( deps ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( deps ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -115,7 +115,7 @@ tape( 'the function returns a string array (dev option)', function test( t ) {
 	};
 	deps = namespaceDeps( '@stdlib/regexp', opts );
 
-	t.strictEqual( isStringArray( deps ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( deps ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -128,6 +128,6 @@ tape( 'the function returns a string array (level option)', function test( t ) {
 	};
 	deps = namespaceDeps( '@stdlib/regexp', opts );
 
-	t.strictEqual( isStringArray( deps ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( deps ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.async.js
index 5628aa5ad304..928ab98fcf8d 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.async.js
@@ -124,7 +124,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -163,7 +163,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -187,8 +187,8 @@ tape( 'the function returns an empty array if unable to resolve any namespace pa
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( files ), true, 'returns an array' );
-		t.strictEqual( files.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( files ), true, 'returns expected value' );
+		t.strictEqual( files.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -227,7 +227,7 @@ tape( 'the function returns a string array (if at least one namespace package RE
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( files ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( files ), true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.find.js b/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.find.js
index 55cd8b2788cb..9291540db30b 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.find.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.find.js
@@ -70,7 +70,7 @@ tape( 'the function returns a string array if able to find at least one namespac
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( files ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( files ), true, 'returns expected value' );
 		t.strictEqual( files.length, 1, 'expected length' );
 		t.end();
 	}
@@ -101,8 +101,8 @@ tape( 'the function returns an empty array if unable to find at least one namesp
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( files ), true, 'returns an array' );
-		t.strictEqual( files.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( files ), true, 'returns expected value' );
+		t.strictEqual( files.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.sync.js
index 2e2f0dab4135..be0528f13325 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespace-readmes/test/test.sync.js
@@ -73,7 +73,7 @@ tape( 'the function returns a string array (if at least one namespace package RE
 	};
 	files = findREADMEs( opts );
 
-	t.strictEqual( isStringArray( files ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( files ), true, 'returns expected value' );
 	t.strictEqual( files.length, 1, 'expected length' );
 
 	t.end();
@@ -109,8 +109,8 @@ tape( 'the function returns an empty array if unable to find any namespace packa
 
 	files = findREADMEs();
 
-	t.strictEqual( isArray( files ), true, 'returns an array' );
-	t.strictEqual( files.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( files ), true, 'returns expected value' );
+	t.strictEqual( files.length, 0, 'returns expected value' );
 
 	t.end();
 
@@ -135,8 +135,8 @@ tape( 'the function returns an empty array if unable to resolve any namespace pa
 
 	files = findREADMEs();
 
-	t.strictEqual( isArray( files ), true, 'returns an array' );
-	t.strictEqual( files.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( files ), true, 'returns expected value' );
+	t.strictEqual( files.length, 0, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.async.js
index 634098b889d9..a9b2720eff91 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.async.js
@@ -147,7 +147,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -158,7 +158,7 @@ tape( 'the function returns a string array', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -172,7 +172,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -186,7 +186,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -203,8 +203,8 @@ tape( 'the function returns an empty array if unable to resolve any namespaces (
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( names ), true, 'returns an array' );
-		t.strictEqual( names.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( names ), true, 'returns expected value' );
+		t.strictEqual( names.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.sync.js
index 648c1a86b1c3..92ca73f389f2 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/namespaces/test/test.sync.js
@@ -75,7 +75,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var names = ls();
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -88,7 +88,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 	};
 	names = ls( opts );
 
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -101,7 +101,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 	};
 	names = ls( opts );
 
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -117,7 +117,7 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 	};
 	names = ls( opts );
 
-	t.strictEqual( isArray( names ), true, 'returns an array' );
-	t.strictEqual( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns expected value' );
+	t.strictEqual( names.length, 0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.async.js
index 37767422aea5..d75015817a99 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.async.js
@@ -124,7 +124,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -151,7 +151,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -175,8 +175,8 @@ tape( 'the function returns an empty array if unable to resolve any packages', f
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( files ), true, 'returns an array' );
-		t.strictEqual( files.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( files ), true, 'returns expected value' );
+		t.strictEqual( files.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -203,7 +203,7 @@ tape( 'the function returns a string array (if at least one package README is fo
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( files ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( files ), true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.find.js b/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.find.js
index 418d8ad84d7b..e49cefca6899 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.find.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.find.js
@@ -59,7 +59,7 @@ tape( 'the function returns a string array if able to find at least one package
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( files ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( files ), true, 'returns expected value' );
 		t.strictEqual( files.length, 1, 'expected length' );
 		t.end();
 	}
@@ -81,8 +81,8 @@ tape( 'the function returns an empty array if unable to find at least one packag
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( files ), true, 'returns an array' );
-		t.strictEqual( files.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( files ), true, 'returns expected value' );
+		t.strictEqual( files.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.sync.js
index 3473d8b57e5c..a7a80bb98fb6 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/readmes/test/test.sync.js
@@ -73,7 +73,7 @@ tape( 'the function returns a string array (if at least one package README is fo
 	};
 	files = findREADMEs( opts );
 
-	t.strictEqual( isStringArray( files ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( files ), true, 'returns expected value' );
 	t.strictEqual( files.length, 1, 'expected length' );
 
 	t.end();
@@ -109,8 +109,8 @@ tape( 'the function returns an empty array if unable to find any package READMEs
 
 	files = findREADMEs();
 
-	t.strictEqual( isArray( files ), true, 'returns an array' );
-	t.strictEqual( files.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( files ), true, 'returns expected value' );
+	t.strictEqual( files.length, 0, 'returns expected value' );
 
 	t.end();
 
@@ -135,8 +135,8 @@ tape( 'the function returns an empty array if unable to resolve any packages', f
 
 	files = findREADMEs();
 
-	t.strictEqual( isArray( files ), true, 'returns an array' );
-	t.strictEqual( files.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( files ), true, 'returns expected value' );
+	t.strictEqual( files.length, 0, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.async.js
index 5ea207b291e2..ca02e58aff0f 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.async.js
@@ -124,7 +124,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -151,7 +151,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -175,8 +175,8 @@ tape( 'the function returns an empty array if unable to resolve any packages', f
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( files ), true, 'returns an array' );
-		t.strictEqual( files.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( files ), true, 'returns expected value' );
+		t.strictEqual( files.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -203,7 +203,7 @@ tape( 'the function returns a string array (if at least one package REPL help fi
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( files ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( files ), true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.find.js b/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.find.js
index 527ba7d5c79a..b9524bad9246 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.find.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.find.js
@@ -68,7 +68,7 @@ tape( 'the function returns a string array if able to find at least one package
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( files ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( files ), true, 'returns expected value' );
 		t.strictEqual( files.length, 1, 'expected length' );
 		t.end();
 	}
@@ -99,8 +99,8 @@ tape( 'the function returns an empty array if unable to find at least one packag
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( files ), true, 'returns an array' );
-		t.strictEqual( files.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( files ), true, 'returns expected value' );
+		t.strictEqual( files.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.sync.js
index de065d23c29e..92e2beff0cd4 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/repl-help/test/test.sync.js
@@ -73,7 +73,7 @@ tape( 'the function returns a string array (if at least one package REPL help fi
 	};
 	files = findREPLHelp( opts );
 
-	t.strictEqual( isStringArray( files ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( files ), true, 'returns expected value' );
 	t.strictEqual( files.length, 1, 'expected length' );
 
 	t.end();
@@ -109,8 +109,8 @@ tape( 'the function returns an empty array if unable to find any package REPL he
 
 	files = findREPLHelp();
 
-	t.strictEqual( isArray( files ), true, 'returns an array' );
-	t.strictEqual( files.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( files ), true, 'returns expected value' );
+	t.strictEqual( files.length, 0, 'returns expected value' );
 
 	t.end();
 
@@ -135,8 +135,8 @@ tape( 'the function returns an empty array if unable to resolve any packages', f
 
 	files = findREPLHelp();
 
-	t.strictEqual( isArray( files ), true, 'returns an array' );
-	t.strictEqual( files.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( files ), true, 'returns expected value' );
+	t.strictEqual( files.length, 0, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.async.js
index d2e561de8251..b3fd51289f23 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.async.js
@@ -147,7 +147,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -158,7 +158,7 @@ tape( 'the function returns a string array', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -172,7 +172,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -186,7 +186,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -203,8 +203,8 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( names ), true, 'returns an array' );
-		t.strictEqual( names.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( names ), true, 'returns expected value' );
+		t.strictEqual( names.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.sync.js
index 729ccc7916c2..3bfb243ece75 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/standalones/test/test.sync.js
@@ -75,7 +75,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var names = ls();
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -88,7 +88,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 	};
 	names = ls( opts );
 
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -101,7 +101,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 	};
 	names = ls( opts );
 
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -117,7 +117,7 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 	};
 	names = ls( opts );
 
-	t.strictEqual( isArray( names ), true, 'returns an array' );
-	t.strictEqual( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns expected value' );
+	t.strictEqual( names.length, 0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.async.js
index 7f8fa58fd703..5d0fe004a41d 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.async.js
@@ -147,7 +147,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -173,7 +173,7 @@ tape( 'the function returns an error to a provided callback if unable to perform
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -184,7 +184,7 @@ tape( 'the function returns a string array', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -198,7 +198,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -212,7 +212,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -229,8 +229,8 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( names ), true, 'returns an array' );
-		t.strictEqual( names.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( names ), true, 'returns expected value' );
+		t.strictEqual( names.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.sync.js
index e341e73729bf..440d491800ff 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/toposort/test/test.sync.js
@@ -76,7 +76,7 @@ tape( 'the function throws an error if provided an invalid option', function tes
 
 tape( 'the function returns a string array', function test( t ) {
 	var names = ls();
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -89,7 +89,7 @@ tape( 'the function returns a string array (dir option)', function test( t ) {
 	};
 	names = ls( opts );
 
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -102,7 +102,7 @@ tape( 'the function returns a string array (pattern option)', function test( t )
 	};
 	names = ls( opts );
 
-	t.strictEqual( isStringArray( names ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( names ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -118,8 +118,8 @@ tape( 'the function returns an empty array if unable to resolve any packages (ig
 	};
 	names = ls( opts );
 
-	t.strictEqual( isArray( names ), true, 'returns an array' );
-	t.strictEqual( names.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( names ), true, 'returns expected value' );
+	t.strictEqual( names.length, 0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.async.js
index 66566f9f642d..55a16497a115 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/tree/test/test.async.js
@@ -147,7 +147,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.inspect.js b/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.inspect.js
index 684e83454cfe..f44993ab9bf2 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.inspect.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.inspect.js
@@ -67,7 +67,7 @@ tape( 'the function returns a string array if able to detect at least one packag
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( pkgs ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( pkgs ), true, 'returns expected value' );
 		t.strictEqual( pkgs.length, 1, 'expected length' );
 		t.end();
 	}
@@ -91,8 +91,8 @@ tape( 'the function returns an empty array if unable to detect at least one pack
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+		t.strictEqual( pkgs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -113,8 +113,8 @@ tape( 'the function returns an empty array if unable to detect at least one pack
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+		t.strictEqual( pkgs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -135,8 +135,8 @@ tape( 'the function returns an empty array if unable to detect at least one pack
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+		t.strictEqual( pkgs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.main.js b/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.main.js
index 055c9dc2b742..46eeb5d5ef7c 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.main.js
@@ -123,7 +123,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -150,7 +150,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -174,8 +174,8 @@ tape( 'the function returns an empty array if unable to resolve any packages con
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+		t.strictEqual( pkgs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -202,7 +202,7 @@ tape( 'the function returns a string array (if at least one package containing T
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( pkgs ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( pkgs ), true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.sync.js
index e1547bb680a4..ee74ccbd6257 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/types/test/test.sync.js
@@ -73,7 +73,7 @@ tape( 'the function returns a string array (if at least one package containing T
 	};
 	pkgs = findTypes( opts );
 
-	t.strictEqual( isStringArray( pkgs ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( pkgs ), true, 'returns expected value' );
 	t.strictEqual( pkgs.length, 1, 'expected length' );
 
 	t.end();
@@ -111,8 +111,8 @@ tape( 'the function returns an empty array if unable to resolve any packages con
 
 	pkgs = findTypes();
 
-	t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-	t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+	t.strictEqual( pkgs.length, 0, 'returns expected value' );
 
 	t.end();
 
@@ -137,8 +137,8 @@ tape( 'the function returns an empty array if unable to resolve any packages', f
 
 	pkgs = findTypes();
 
-	t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-	t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+	t.strictEqual( pkgs.length, 0, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.async.js b/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.async.js
index 800422e4608b..ab69fd98b914 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.async.js
@@ -123,7 +123,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -150,7 +150,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -174,8 +174,8 @@ tape( 'the function returns an empty array if unable to resolve any packages con
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+		t.strictEqual( pkgs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -202,7 +202,7 @@ tape( 'the function returns a string array (if at least one package containing W
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( pkgs ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( pkgs ), true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.inspect.js b/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.inspect.js
index 761d994a446c..31bebe20e742 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.inspect.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.inspect.js
@@ -71,7 +71,7 @@ tape( 'the function returns a string array if able to detect at least one packag
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isStringArray( pkgs ), true, 'returns a string array' );
+		t.strictEqual( isStringArray( pkgs ), true, 'returns expected value' );
 		t.strictEqual( pkgs.length, 1, 'expected length' );
 		t.end();
 	}
@@ -95,8 +95,8 @@ tape( 'the function returns an empty array if unable to detect at least one pack
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+		t.strictEqual( pkgs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -117,8 +117,8 @@ tape( 'the function returns an empty array if unable to detect at least one pack
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+		t.strictEqual( pkgs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
@@ -139,8 +139,8 @@ tape( 'the function returns an empty array if unable to detect at least one pack
 		if ( error ) {
 			t.ok( false, error.message );
 		}
-		t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-		t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+		t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+		t.strictEqual( pkgs.length, 0, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.sync.js b/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.sync.js
index 8364f70580d0..8b2a4801561b 100644
--- a/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/pkgs/wasm/test/test.sync.js
@@ -73,7 +73,7 @@ tape( 'the function returns a string array (if at least one package containing W
 	};
 	pkgs = findWASM( opts );
 
-	t.strictEqual( isStringArray( pkgs ), true, 'returns a string array' );
+	t.strictEqual( isStringArray( pkgs ), true, 'returns expected value' );
 	t.strictEqual( pkgs.length, 1, 'expected length' );
 
 	t.end();
@@ -113,8 +113,8 @@ tape( 'the function returns an empty array if unable to resolve any packages con
 
 	pkgs = findWASM();
 
-	t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-	t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+	t.strictEqual( pkgs.length, 0, 'returns expected value' );
 
 	t.end();
 
@@ -139,8 +139,8 @@ tape( 'the function returns an empty array if unable to resolve any packages', f
 
 	pkgs = findWASM();
 
-	t.strictEqual( isArray( pkgs ), true, 'returns an array' );
-	t.strictEqual( pkgs.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( pkgs ), true, 'returns expected value' );
+	t.strictEqual( pkgs.length, 0, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/_tools/repl-txt/parse/test/test.js b/lib/node_modules/@stdlib/_tools/repl-txt/parse/test/test.js
index 0fa242ceda3f..b35299708458 100644
--- a/lib/node_modules/@stdlib/_tools/repl-txt/parse/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/repl-txt/parse/test/test.js
@@ -95,7 +95,7 @@ tape( 'the function returns an expected syntax tree if provided a `repl.txt` str
 
 	for ( i = 0; i < values.length; i++ ) {
 		ast = parse( values[ i ] );
-		t.strictEqual( isArray( ast ), true, 'returns an array' );
+		t.strictEqual( isArray( ast ), true, 'returns expected value' );
 		t.deepEqual( ast, expected[ i ], 'has expected properties' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/_tools/search/pkg-index/test/test.js b/lib/node_modules/@stdlib/_tools/search/pkg-index/test/test.js
index e0e5cc2e47d0..6062a3c00e4b 100644
--- a/lib/node_modules/@stdlib/_tools/search/pkg-index/test/test.js
+++ b/lib/node_modules/@stdlib/_tools/search/pkg-index/test/test.js
@@ -127,7 +127,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -162,7 +162,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-file-list/test/test.async.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-file-list/test/test.async.js
index 84d1b5563e03..45fb97702f21 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-file-list/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-file-list/test/test.async.js
@@ -212,7 +212,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	analyze( [ doesNotExist ], clbk );
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -222,7 +222,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	analyze( [ doesNotExist ], {}, clbk );
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -235,7 +235,7 @@ tape( 'by default, the function analyzes input files and returns a cumulative LL
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+			t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 			t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 		}
 		t.end();
@@ -256,7 +256,7 @@ tape( 'if the `cumulative` option is `true`, the function analyzes input files a
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+			t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 			t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 		}
 		t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-file-list/test/test.sync.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-file-list/test/test.sync.js
index 133f1b07282f..0408862dd2c5 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-file-list/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-file-list/test/test.sync.js
@@ -156,7 +156,7 @@ tape( 'the function returns an error if an error is encountered when reading fil
 	var doesNotExist = 'akfjdalfkjsdlfjdasfjadsfjdslfjldajfasdjfasjfjasdlfjasdlfj.js';
 	var err = analyze( [ doesNotExist ] );
 
-	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -164,7 +164,7 @@ tape( 'the function returns an error if an error is encountered when reading fil
 	var doesNotExist = 'akfjdalfkjsdlfjdasfjadsfjdslfjldajfasdjfasjfjasdlfjasdlfj.js';
 	var err = analyze( [ doesNotExist ], {} );
 
-	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -175,7 +175,7 @@ tape( 'by default, the function analyzes input files and returns a cumulative LL
 	files = [ __filename, __filename ];
 	o = analyze( files );
 
-	t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 	t.end();
 });
@@ -191,7 +191,7 @@ tape( 'if the `cumulative` option is `true`, the function analyzes input files a
 	};
 	o = analyze( files, opts );
 
-	t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.async.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.async.js
index a83d284c36ef..cdea61dcc54a 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.async.js
@@ -166,7 +166,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -187,7 +187,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -213,7 +213,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -262,8 +262,8 @@ tape( 'if unable to resolve source files and the `cumulative` option is `false`,
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isArray( o ), true, 'returns an array' );
-			t.strictEqual( o.length, 0, 'returns an empty array' );
+			t.strictEqual( isArray( o ), true, 'returns expected value' );
+			t.strictEqual( o.length, 0, 'returns expected value' );
 		}
 		t.end();
 	}
@@ -279,7 +279,7 @@ tape( 'by default, the function analyzes a file glob and returns a cumulative LL
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+			t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 			t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 		}
 		t.end();
@@ -297,7 +297,7 @@ tape( 'if the `cumulative` option is `true`, the function analyzes a file glob a
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+			t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 			t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 		}
 		t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.sync.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.sync.js
index c1f6293b9349..f4b63aef6051 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/lloc-glob/test/test.sync.js
@@ -110,7 +110,7 @@ tape( 'the function returns an error if an error is encountered when analyzing f
 	};
 	err = analyze( opts );
 
-	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 	t.end();
 
 	function mock() {
@@ -174,8 +174,8 @@ tape( 'if unable to resolve any files and the `cumulative` option is `false`, th
 	};
 	out = analyze( opts );
 
-	t.strictEqual( isArray( out ), true, 'returns an array' );
-	t.strictEqual( out.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
+	t.strictEqual( out.length, 0, 'returns expected value' );
 	t.end();
 });
 
@@ -188,7 +188,7 @@ tape( 'by default, the function analyzes a glob and calculates cumulative LLOC',
 	};
 	o = analyze( opts );
 
-	t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 	t.end();
 });
@@ -203,7 +203,7 @@ tape( 'if the `cumulative` option is `true`, the function analyzes a glob and ca
 	};
 	o = analyze( opts );
 
-	t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-file-list/test/test.async.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-file-list/test/test.async.js
index 52de60dc820b..75aebb3023e7 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-file-list/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-file-list/test/test.async.js
@@ -212,7 +212,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	analyze( [ doesNotExist ], clbk );
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -222,7 +222,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	analyze( [ doesNotExist ], {}, clbk );
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -235,7 +235,7 @@ tape( 'by default, the function analyzes input files and returns a cumulative SL
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+			t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 			t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 		}
 		t.end();
@@ -256,7 +256,7 @@ tape( 'if the `cumulative` option is `true`, the function analyzes input files a
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+			t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 			t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 		}
 		t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-file-list/test/test.sync.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-file-list/test/test.sync.js
index 13d2ed166365..d6d66134586e 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-file-list/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-file-list/test/test.sync.js
@@ -156,7 +156,7 @@ tape( 'the function returns an error if an error is encountered when reading fil
 	var doesNotExist = 'akfjdalfkjsdlfjdasfjadsfjdslfjldajfasdjfasjfjasdlfjasdlfj.js';
 	var err = analyze( [ doesNotExist ] );
 
-	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -164,7 +164,7 @@ tape( 'the function returns an error if an error is encountered when reading fil
 	var doesNotExist = 'akfjdalfkjsdlfjdasfjadsfjdslfjldajfasdjfasjfjasdlfjasdlfj.js';
 	var err = analyze( [ doesNotExist ], {} );
 
-	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -175,7 +175,7 @@ tape( 'by default, the function analyzes input files and returns a cumulative SL
 	files = [ __filename, __filename ];
 	o = analyze( files );
 
-	t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 	t.end();
 });
@@ -191,7 +191,7 @@ tape( 'if the `cumulative` option is `true`, the function analyzes input files a
 	};
 	o = analyze( files, opts );
 
-	t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.async.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.async.js
index 9e5e810a8dd0..cb162ce5d1c0 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.async.js
@@ -166,7 +166,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -187,7 +187,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -213,7 +213,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -262,8 +262,8 @@ tape( 'if unable to resolve source files and the `cumulative` option is `false`,
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isArray( o ), true, 'returns an array' );
-			t.strictEqual( o.length, 0, 'returns an empty array' );
+			t.strictEqual( isArray( o ), true, 'returns expected value' );
+			t.strictEqual( o.length, 0, 'returns expected value' );
 		}
 		t.end();
 	}
@@ -279,7 +279,7 @@ tape( 'by default, the function analyzes a file glob and returns a cumulative SL
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+			t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 			t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 		}
 		t.end();
@@ -297,7 +297,7 @@ tape( 'if the `cumulative` option is `true`, the function analyzes a file glob a
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+			t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 			t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 		}
 		t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.sync.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.sync.js
index 370cd699897d..79595e95f705 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/sloc-glob/test/test.sync.js
@@ -110,7 +110,7 @@ tape( 'the function returns an error if an error is encountered when analyzing f
 	};
 	err = analyze( opts );
 
-	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 	t.end();
 
 	function mock() {
@@ -174,8 +174,8 @@ tape( 'if unable to resolve any files and the `cumulative` option is `false`, th
 	};
 	out = analyze( opts );
 
-	t.strictEqual( isArray( out ), true, 'returns an array' );
-	t.strictEqual( out.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
+	t.strictEqual( out.length, 0, 'returns expected value' );
 	t.end();
 });
 
@@ -188,7 +188,7 @@ tape( 'by default, the function analyzes a glob and calculates cumulative SLOC',
 	};
 	o = analyze( opts );
 
-	t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 	t.end();
 });
@@ -203,7 +203,7 @@ tape( 'if the `cumulative` option is `true`, the function analyzes a glob and ca
 	};
 	o = analyze( opts );
 
-	t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-file-list/test/test.async.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-file-list/test/test.async.js
index d5cc606c182d..4c56261260b6 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-file-list/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-file-list/test/test.async.js
@@ -212,7 +212,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	analyze( [ doesNotExist ], clbk );
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -222,7 +222,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	analyze( [ doesNotExist ], {}, clbk );
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -235,7 +235,7 @@ tape( 'by default, the function analyzes input files and returns a cumulative st
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+			t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 			t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 		}
 		t.end();
@@ -256,7 +256,7 @@ tape( 'if the `cumulative` option is `true`, the function analyzes input files a
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+			t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 			t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 		}
 		t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-file-list/test/test.sync.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-file-list/test/test.sync.js
index ec8d6488ef97..11c6db9e4eec 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-file-list/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-file-list/test/test.sync.js
@@ -156,7 +156,7 @@ tape( 'the function returns an error if an error is encountered when reading fil
 	var doesNotExist = 'akfjdalfkjsdlfjdasfjadsfjdslfjldajfasdjfasjfjasdlfjasdlfj.js';
 	var err = analyze( [ doesNotExist ] );
 
-	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -164,7 +164,7 @@ tape( 'the function returns an error if an error is encountered when reading fil
 	var doesNotExist = 'akfjdalfkjsdlfjdasfjadsfjdslfjldajfasdjfasjfjasdlfjasdlfj.js';
 	var err = analyze( [ doesNotExist ], {} );
 
-	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -175,7 +175,7 @@ tape( 'by default, the function analyzes input files and returns a cumulative st
 	files = [ __filename, __filename ];
 	o = analyze( files );
 
-	t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 	t.end();
 });
@@ -191,7 +191,7 @@ tape( 'if the `cumulative` option is `true`, the function analyzes input files a
 	};
 	o = analyze( files, opts );
 
-	t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.async.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.async.js
index c23500dc3c4e..1e2aff0d1454 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.async.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.async.js
@@ -166,7 +166,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -187,7 +187,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -213,7 +213,7 @@ tape( 'the function returns an error to a provided callback if an error is encou
 	}
 
 	function clbk( error ) {
-		t.strictEqual( instanceOf( error, Error ), true, 'returns an error' );
+		t.strictEqual( instanceOf( error, Error ), true, 'returns expected value' );
 		t.end();
 	}
 });
@@ -262,8 +262,8 @@ tape( 'if unable to resolve source files and the `cumulative` option is `false`,
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isArray( o ), true, 'returns an array' );
-			t.strictEqual( o.length, 0, 'returns an empty array' );
+			t.strictEqual( isArray( o ), true, 'returns expected value' );
+			t.strictEqual( o.length, 0, 'returns expected value' );
 		}
 		t.end();
 	}
@@ -279,7 +279,7 @@ tape( 'by default, the function analyzes a file glob and returns a cumulative st
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+			t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 			t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 		}
 		t.end();
@@ -297,7 +297,7 @@ tape( 'if the `cumulative` option is `true`, the function analyzes a file glob a
 		if ( error ) {
 			t.fail( error.message );
 		} else {
-			t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+			t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 			t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 		}
 		t.end();
diff --git a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.sync.js b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.sync.js
index 28804b631d8a..14ef3db6209d 100644
--- a/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.sync.js
+++ b/lib/node_modules/@stdlib/_tools/static-analysis/js/summarize-glob/test/test.sync.js
@@ -110,7 +110,7 @@ tape( 'the function returns an error if an error is encountered when analyzing f
 	};
 	err = analyze( opts );
 
-	t.strictEqual( instanceOf( err, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( err, Error ), true, 'returns expected value' );
 	t.end();
 
 	function mock() {
@@ -174,8 +174,8 @@ tape( 'if unable to resolve any files and the `cumulative` option is `false`, th
 	};
 	out = analyze( opts );
 
-	t.strictEqual( isArray( out ), true, 'returns an array' );
-	t.strictEqual( out.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
+	t.strictEqual( out.length, 0, 'returns expected value' );
 	t.end();
 });
 
@@ -188,7 +188,7 @@ tape( 'by default, the function analyzes a glob and returns a cumulative static
 	};
 	o = analyze( opts );
 
-	t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 	t.end();
 });
@@ -203,7 +203,7 @@ tape( 'if the `cumulative` option is `true`, the function analyzes a glob and re
 	};
 	o = analyze( opts );
 
-	t.strictEqual( isPlainObject( o ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( o ), true, 'returns expected value' );
 	t.strictEqual( objectKeys( o ).length > 0, true, 'has key-value pairs' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.factory.js b/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.factory.js
index df079043ba7f..78b7f50666d6 100644
--- a/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.factory.js
+++ b/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.factory.js
@@ -146,7 +146,7 @@ tape( 'the function returns a function which returns any errors to a provided ca
 	tex2svg( '\\infinity', clbk );
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.main.js b/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.main.js
index 95311e44b717..49d7b8e7e7b2 100644
--- a/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.main.js
+++ b/lib/node_modules/@stdlib/_tools/utils/tex-equation-to-svg/test/test.main.js
@@ -195,7 +195,7 @@ tape( 'the function returns any errors to the provided callback', function test(
 	tex2svg( '\\infinity', clbk );
 
 	function clbk( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/array/base/accessor/test/test.js b/lib/node_modules/@stdlib/array/base/accessor/test/test.js
index 57733bff236f..a46d55117950 100644
--- a/lib/node_modules/@stdlib/array/base/accessor/test/test.js
+++ b/lib/node_modules/@stdlib/array/base/accessor/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function is a constructor', function test( t ) {
 	var arr = new AccessorArray( [ 1, 2, 3 ] );
-	t.strictEqual( arr instanceof AccessorArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof AccessorArray, true, 'returns expected value' );
 	t.end();
 });
 
@@ -47,7 +47,7 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 	ctor = AccessorArray;
 
 	arr = ctor( [ 1, 2, 3 ] );
-	t.strictEqual( arr instanceof AccessorArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof AccessorArray, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/bool/test/test.js b/lib/node_modules/@stdlib/array/bool/test/test.js
index cba1465cb1e3..f8bb59a98663 100644
--- a/lib/node_modules/@stdlib/array/bool/test/test.js
+++ b/lib/node_modules/@stdlib/array/bool/test/test.js
@@ -39,7 +39,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function is a constructor', function test( t ) {
 	var arr = new BooleanArray( 0 );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 	t.end();
 });
 
@@ -50,14 +50,14 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 	ctor = BooleanArray;
 
 	arr = ctor( 0 );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a boolean array (no argument)', function test( t ) {
 	var arr = new BooleanArray();
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 	t.end();
 });
 
@@ -68,14 +68,14 @@ tape( 'the constructor returns a boolean array (no argument, no new)', function
 	ctor = BooleanArray;
 
 	arr = ctor();
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a boolean array (length)', function test( t ) {
 	var arr = new BooleanArray( 10 );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 	t.end();
 });
 
@@ -86,14 +86,14 @@ tape( 'the constructor returns a boolean array (length, no new)', function test(
 	ctor = BooleanArray;
 
 	arr = ctor( 10 );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a boolean array (array)', function test( t ) {
 	var arr = new BooleanArray( [] );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 	t.end();
 });
 
@@ -104,14 +104,14 @@ tape( 'the constructor returns a boolean array (array, no new)', function test(
 	ctor = BooleanArray;
 
 	arr = ctor( [] );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a boolean array (typed array)', function test( t ) {
 	var arr = new BooleanArray( new Uint8Array( 0 ) );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 	t.end();
 });
 
@@ -122,7 +122,7 @@ tape( 'the constructor returns a boolean array (typed array, no new)', function
 	ctor = BooleanArray;
 
 	arr = ctor( new Uint8Array( 0 ) );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 
 	t.end();
 });
@@ -137,7 +137,7 @@ tape( 'the constructor returns a boolean array (iterable)', function test( t ) {
 	});
 
 	arr = new BooleanArray( createIterable() );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 
 	t.end();
 
@@ -174,7 +174,7 @@ tape( 'the constructor returns a boolean array (iterable, no new)', function tes
 	});
 
 	arr = ctor( createIterable() );
-	t.strictEqual( arr instanceof ctor, true, 'returns an instance' );
+	t.strictEqual( arr instanceof ctor, true, 'returns expected value' );
 
 	t.end();
 
@@ -203,7 +203,7 @@ tape( 'the constructor returns a boolean array (iterable, no new)', function tes
 
 tape( 'the constructor returns a boolean array (ArrayBuffer)', function test( t ) {
 	var arr = new BooleanArray( new ArrayBuffer( 0 ) );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 	t.end();
 });
 
@@ -214,14 +214,14 @@ tape( 'the constructor returns a boolean array (ArrayBuffer, no new)', function
 	ctor = BooleanArray;
 
 	arr = ctor( new ArrayBuffer( 0 ) );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a boolean array (ArrayBuffer, byte offset)', function test( t ) {
 	var arr = new BooleanArray( new ArrayBuffer( 8 ), 8 );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 	t.end();
 });
 
@@ -232,14 +232,14 @@ tape( 'the constructor returns a boolean array (ArrayBuffer, byte offset, no new
 	ctor = BooleanArray;
 
 	arr = ctor( new ArrayBuffer( 8 ), 8 );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a boolean array (ArrayBuffer, byte offset, length)', function test( t ) {
 	var arr = new BooleanArray( new ArrayBuffer( 8 ), 8, 0 );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 	t.end();
 });
 
@@ -250,7 +250,7 @@ tape( 'the constructor returns a boolean array (ArrayBuffer, byte offset, length
 	ctor = BooleanArray;
 
 	arr = ctor( new ArrayBuffer( 8 ), 8, 0 );
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/bool/test/test.of.js b/lib/node_modules/@stdlib/array/bool/test/test.of.js
index b9e6dc4e0c23..0f4bf3d18a1e 100644
--- a/lib/node_modules/@stdlib/array/bool/test/test.of.js
+++ b/lib/node_modules/@stdlib/array/bool/test/test.of.js
@@ -41,7 +41,7 @@ tape( 'attached to the main export is an `of` method for creating a boolean arra
 	t.strictEqual( isFunction( BooleanArray.of ), true, 'has method' );
 
 	arr = BooleanArray.of();
-	t.strictEqual( arr instanceof BooleanArray, true, 'returns an instance' );
+	t.strictEqual( arr instanceof BooleanArray, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/buffer/test/test.js b/lib/node_modules/@stdlib/array/buffer/test/test.js
index 14d30e4f7f10..98deab53404f 100644
--- a/lib/node_modules/@stdlib/array/buffer/test/test.js
+++ b/lib/node_modules/@stdlib/array/buffer/test/test.js
@@ -87,7 +87,7 @@ tape( 'if an environment does not support `ArrayBuffer`, the export is a polyfil
 
 tape( 'the main export is a constructor', opts, function test( t ) {
 	var buf = new Ctor( 10 );
-	t.strictEqual( instanceOf( buf, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( buf, Ctor ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -142,52 +142,52 @@ tape( 'the constructor returns an `ArrayBuffer` instance having a `slice` method
 	t.strictEqual( hasProp( b1, 'slice' ), true, 'has property' );
 
 	b2 = b1.slice();
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, b1.byteLength, 'has same number of bytes' );
 
 	b2 = b1.slice( 2 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 8, 'has expected number of bytes' );
 
 	b2 = b1.slice( b1.byteLength + 10 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 0, 'has expected number of bytes' );
 
 	b2 = b1.slice( -2 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 2, 'has expected number of bytes' );
 
 	b2 = b1.slice( -100 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 10, 'has expected number of bytes' );
 
 	b2 = b1.slice( 0, 6 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 6, 'has expected number of bytes' );
 
 	b2 = b1.slice( 2, 6 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 4, 'has expected number of bytes' );
 
 	b2 = b1.slice( 0, -2 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 8, 'has expected number of bytes' );
 
 	b2 = b1.slice( 0, -100 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 0, 'has expected number of bytes' );
 
 	b2 = b1.slice( -4, -2 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 2, 'has expected number of bytes' );
 
diff --git a/lib/node_modules/@stdlib/array/complex128/test/test.entries.js b/lib/node_modules/@stdlib/array/complex128/test/test.entries.js
index b1090c3e4154..157765242d28 100644
--- a/lib/node_modules/@stdlib/array/complex128/test/test.entries.js
+++ b/lib/node_modules/@stdlib/array/complex128/test/test.entries.js
@@ -93,7 +93,7 @@ tape( 'the method returns an iterator protocol-compliant object', function test(
 	j = 0;
 	for ( i = 0; i < arr.length; i++ ) {
 		v = it.next();
-		t.strictEqual( isArray( v.value ), true, 'returns an array' );
+		t.strictEqual( isArray( v.value ), true, 'returns expected value' );
 		t.strictEqual( v.value[ 0 ], i, 'returns an index' );
 		t.strictEqual( isComplex128( v.value[ 1 ] ), true, 'returns a complex number' );
 		t.strictEqual( real( v.value[ 1 ] ), buf[ j ], 'returns expected real component' );
diff --git a/lib/node_modules/@stdlib/array/complex128/test/test.from.js b/lib/node_modules/@stdlib/array/complex128/test/test.from.js
index c45d81c9fddb..af4a523382cd 100644
--- a/lib/node_modules/@stdlib/array/complex128/test/test.from.js
+++ b/lib/node_modules/@stdlib/array/complex128/test/test.from.js
@@ -49,7 +49,7 @@ tape( 'attached to the main export is a `from` method for creating a complex num
 	t.strictEqual( isFunction( Complex128Array.from ), true, 'has method' );
 
 	arr = Complex128Array.from( [] );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/complex128/test/test.js b/lib/node_modules/@stdlib/array/complex128/test/test.js
index 3306441fba76..bbc62f741828 100644
--- a/lib/node_modules/@stdlib/array/complex128/test/test.js
+++ b/lib/node_modules/@stdlib/array/complex128/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function is a constructor', function test( t ) {
 	var arr = new Complex128Array( 0 );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -53,14 +53,14 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 	ctor = Complex128Array;
 
 	arr = ctor( 0 );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 128-bit complex number array (no argument)', function test( t ) {
 	var arr = new Complex128Array();
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -71,14 +71,14 @@ tape( 'the constructor returns a 128-bit complex number array (no argument, no n
 	ctor = Complex128Array;
 
 	arr = ctor();
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 128-bit complex number array (length)', function test( t ) {
 	var arr = new Complex128Array( 10 );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -89,14 +89,14 @@ tape( 'the constructor returns a 128-bit complex number array (length, no new)',
 	ctor = Complex128Array;
 
 	arr = ctor( 10 );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 128-bit complex number array (array)', function test( t ) {
 	var arr = new Complex128Array( [] );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -107,14 +107,14 @@ tape( 'the constructor returns a 128-bit complex number array (array, no new)',
 	ctor = Complex128Array;
 
 	arr = ctor( [] );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 128-bit complex number array (typed array)', function test( t ) {
 	var arr = new Complex128Array( new Float64Array( 0 ) );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -125,14 +125,14 @@ tape( 'the constructor returns a 128-bit complex number array (typed array, no n
 	ctor = Complex128Array;
 
 	arr = ctor( new Float64Array( 0 ) );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 128-bit complex number array (complex typed array)', function test( t ) {
 	var arr = new Complex128Array( new Complex128Array( 0 ) );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -143,7 +143,7 @@ tape( 'the constructor returns a 128-bit complex number array (complex typed arr
 	ctor = Complex128Array;
 
 	arr = ctor( new Complex128Array( 0 ) );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the constructor returns a 128-bit complex number array (iterable)', funct
 	});
 
 	arr = new Complex128Array( createIterable() );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 
 	t.end();
 
@@ -195,7 +195,7 @@ tape( 'the constructor returns a 128-bit complex number array (iterable, no new)
 	});
 
 	arr = ctor( createIterable() );
-	t.strictEqual( arr instanceof ctor, true, 'returns an instance' );
+	t.strictEqual( arr instanceof ctor, true, 'returns expected value' );
 
 	t.end();
 
@@ -224,7 +224,7 @@ tape( 'the constructor returns a 128-bit complex number array (iterable, no new)
 
 tape( 'the constructor returns a 128-bit complex number array (ArrayBuffer)', function test( t ) {
 	var arr = new Complex128Array( new ArrayBuffer( 0 ) );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -235,14 +235,14 @@ tape( 'the constructor returns a 128-bit complex number array (ArrayBuffer, no n
 	ctor = Complex128Array;
 
 	arr = ctor( new ArrayBuffer( 0 ) );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 128-bit complex number array (ArrayBuffer, byte offset)', function test( t ) {
 	var arr = new Complex128Array( new ArrayBuffer( 16 ), 16 );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -253,14 +253,14 @@ tape( 'the constructor returns a 128-bit complex number array (ArrayBuffer, byte
 	ctor = Complex128Array;
 
 	arr = ctor( new ArrayBuffer( 16 ), 16 );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 128-bit complex number array (ArrayBuffer, byte offset, length)', function test( t ) {
 	var arr = new Complex128Array( new ArrayBuffer( 16 ), 16, 0 );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -271,7 +271,7 @@ tape( 'the constructor returns a 128-bit complex number array (ArrayBuffer, byte
 	ctor = Complex128Array;
 
 	arr = ctor( new ArrayBuffer( 16 ), 16, 0 );
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/complex128/test/test.of.js b/lib/node_modules/@stdlib/array/complex128/test/test.of.js
index 2e07f499187d..8825140992e3 100644
--- a/lib/node_modules/@stdlib/array/complex128/test/test.of.js
+++ b/lib/node_modules/@stdlib/array/complex128/test/test.of.js
@@ -43,7 +43,7 @@ tape( 'attached to the main export is an `of` method for creating a complex numb
 	t.strictEqual( isFunction( Complex128Array.of ), true, 'has method' );
 
 	arr = Complex128Array.of();
-	t.strictEqual( arr instanceof Complex128Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex128Array, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/complex64/test/test.entries.js b/lib/node_modules/@stdlib/array/complex64/test/test.entries.js
index cc40b95cb24d..ba86a25e41bf 100644
--- a/lib/node_modules/@stdlib/array/complex64/test/test.entries.js
+++ b/lib/node_modules/@stdlib/array/complex64/test/test.entries.js
@@ -93,7 +93,7 @@ tape( 'the method returns an iterator protocol-compliant object', function test(
 	j = 0;
 	for ( i = 0; i < arr.length; i++ ) {
 		v = it.next();
-		t.strictEqual( isArray( v.value ), true, 'returns an array' );
+		t.strictEqual( isArray( v.value ), true, 'returns expected value' );
 		t.strictEqual( v.value[ 0 ], i, 'returns an index' );
 		t.strictEqual( isComplex64( v.value[ 1 ] ), true, 'returns a complex number' );
 		t.strictEqual( realf( v.value[ 1 ] ), buf[ j ], 'returns expected real component' );
diff --git a/lib/node_modules/@stdlib/array/complex64/test/test.js b/lib/node_modules/@stdlib/array/complex64/test/test.js
index f7d7b3ea6070..4509a8a8b970 100644
--- a/lib/node_modules/@stdlib/array/complex64/test/test.js
+++ b/lib/node_modules/@stdlib/array/complex64/test/test.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function is a constructor', function test( t ) {
 	var arr = new Complex64Array( 0 );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -53,14 +53,14 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 	ctor = Complex64Array;
 
 	arr = ctor( 0 );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 64-bit complex number array (no argument)', function test( t ) {
 	var arr = new Complex64Array();
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -71,14 +71,14 @@ tape( 'the constructor returns a 64-bit complex number array (no argument, no ne
 	ctor = Complex64Array;
 
 	arr = ctor();
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 64-bit complex number array (length)', function test( t ) {
 	var arr = new Complex64Array( 10 );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -89,14 +89,14 @@ tape( 'the constructor returns a 64-bit complex number array (length, no new)',
 	ctor = Complex64Array;
 
 	arr = ctor( 10 );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 64-bit complex number array (array)', function test( t ) {
 	var arr = new Complex64Array( [] );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -107,14 +107,14 @@ tape( 'the constructor returns a 64-bit complex number array (array, no new)', f
 	ctor = Complex64Array;
 
 	arr = ctor( [] );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 64-bit complex number array (typed array)', function test( t ) {
 	var arr = new Complex64Array( new Float32Array( 0 ) );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -125,14 +125,14 @@ tape( 'the constructor returns a 64-bit complex number array (typed array, no ne
 	ctor = Complex64Array;
 
 	arr = ctor( new Float32Array( 0 ) );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 64-bit complex number array (complex typed array)', function test( t ) {
 	var arr = new Complex64Array( new Complex64Array( 0 ) );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -143,7 +143,7 @@ tape( 'the constructor returns a 64-bit complex number array (complex typed arra
 	ctor = Complex64Array;
 
 	arr = ctor( new Complex64Array( 0 ) );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 
 	t.end();
 });
@@ -158,7 +158,7 @@ tape( 'the constructor returns a 64-bit complex number array (iterable)', functi
 	});
 
 	arr = new Complex64Array( createIterable() );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 
 	t.end();
 
@@ -195,7 +195,7 @@ tape( 'the constructor returns a 64-bit complex number array (iterable, no new)'
 	});
 
 	arr = ctor( createIterable() );
-	t.strictEqual( arr instanceof ctor, true, 'returns an instance' );
+	t.strictEqual( arr instanceof ctor, true, 'returns expected value' );
 
 	t.end();
 
@@ -224,7 +224,7 @@ tape( 'the constructor returns a 64-bit complex number array (iterable, no new)'
 
 tape( 'the constructor returns a 64-bit complex number array (ArrayBuffer)', function test( t ) {
 	var arr = new Complex64Array( new ArrayBuffer( 0 ) );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -235,14 +235,14 @@ tape( 'the constructor returns a 64-bit complex number array (ArrayBuffer, no ne
 	ctor = Complex64Array;
 
 	arr = ctor( new ArrayBuffer( 0 ) );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 64-bit complex number array (ArrayBuffer, byte offset)', function test( t ) {
 	var arr = new Complex64Array( new ArrayBuffer( 8 ), 8 );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -253,14 +253,14 @@ tape( 'the constructor returns a 64-bit complex number array (ArrayBuffer, byte
 	ctor = Complex64Array;
 
 	arr = ctor( new ArrayBuffer( 8 ), 8 );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the constructor returns a 64-bit complex number array (ArrayBuffer, byte offset, length)', function test( t ) {
 	var arr = new Complex64Array( new ArrayBuffer( 8 ), 8, 0 );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 	t.end();
 });
 
@@ -271,7 +271,7 @@ tape( 'the constructor returns a 64-bit complex number array (ArrayBuffer, byte
 	ctor = Complex64Array;
 
 	arr = ctor( new ArrayBuffer( 8 ), 8, 0 );
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/complex64/test/test.of.js b/lib/node_modules/@stdlib/array/complex64/test/test.of.js
index 11a4288e2bd9..7a176cc1faed 100644
--- a/lib/node_modules/@stdlib/array/complex64/test/test.of.js
+++ b/lib/node_modules/@stdlib/array/complex64/test/test.of.js
@@ -43,7 +43,7 @@ tape( 'attached to the main export is an `of` method for creating a complex numb
 	t.strictEqual( isFunction( Complex64Array.of ), true, 'has method' );
 
 	arr = Complex64Array.of();
-	t.strictEqual( arr instanceof Complex64Array, true, 'returns an instance' );
+	t.strictEqual( arr instanceof Complex64Array, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/dataview/test/test.js b/lib/node_modules/@stdlib/array/dataview/test/test.js
index b2e1f3c70033..dec877e28ba6 100644
--- a/lib/node_modules/@stdlib/array/dataview/test/test.js
+++ b/lib/node_modules/@stdlib/array/dataview/test/test.js
@@ -90,13 +90,13 @@ tape( 'the main export is a constructor', opts, function test( t ) {
 	buf = new ArrayBuffer( 10 );
 
 	dv = new Ctor( buf );
-	t.strictEqual( instanceOf( dv, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( dv, Ctor ), true, 'returns expected value' );
 
 	dv = new Ctor( buf, 4 );
-	t.strictEqual( instanceOf( dv, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( dv, Ctor ), true, 'returns expected value' );
 
 	dv = new Ctor( buf, 4, 2 );
-	t.strictEqual( instanceOf( dv, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( dv, Ctor ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/array/datespace/test/test.js b/lib/node_modules/@stdlib/array/datespace/test/test.js
index aa7cb7cb11f5..bb31be97de7f 100644
--- a/lib/node_modules/@stdlib/array/datespace/test/test.js
+++ b/lib/node_modules/@stdlib/array/datespace/test/test.js
@@ -228,7 +228,7 @@ tape( 'the function returns an array of `Date` objects', function test( t ) {
 
 	actual = datespace( start, stop );
 
-	t.strictEqual( isArray( actual ), true, 'returns an array' );
+	t.strictEqual( isArray( actual ), true, 'returns expected value' );
 	for ( i = 0; i < actual.length; i++ ) {
 		t.ok( actual[i] instanceof Date, 'returns a date' );
 	}
diff --git a/lib/node_modules/@stdlib/array/shared-buffer/test/test.js b/lib/node_modules/@stdlib/array/shared-buffer/test/test.js
index 2282b30d40d5..fb92eb08c4b8 100644
--- a/lib/node_modules/@stdlib/array/shared-buffer/test/test.js
+++ b/lib/node_modules/@stdlib/array/shared-buffer/test/test.js
@@ -84,7 +84,7 @@ tape( 'if an environment does not support `SharedArrayBuffer`, the export is a p
 
 tape( 'the main export is a constructor', opts, function test( t ) {
 	var buf = new Ctor( 10 );
-	t.strictEqual( instanceOf( buf, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( buf, Ctor ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -127,52 +127,52 @@ tape( 'the constructor returns a `SharedArrayBuffer` instance having a `slice` m
 	t.strictEqual( hasProp( b1, 'slice' ), true, 'has property' );
 
 	b2 = b1.slice();
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, b1.byteLength, 'has same number of bytes' );
 
 	b2 = b1.slice( 2 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 8, 'has expected number of bytes' );
 
 	b2 = b1.slice( b1.byteLength + 10 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 0, 'has expected number of bytes' );
 
 	b2 = b1.slice( -2 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 2, 'has expected number of bytes' );
 
 	b2 = b1.slice( -100 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 10, 'has expected number of bytes' );
 
 	b2 = b1.slice( 0, 6 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 6, 'has expected number of bytes' );
 
 	b2 = b1.slice( 2, 6 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 4, 'has expected number of bytes' );
 
 	b2 = b1.slice( 0, -2 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 8, 'has expected number of bytes' );
 
 	b2 = b1.slice( 0, -100 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 0, 'has expected number of bytes' );
 
 	b2 = b1.slice( -4, -2 );
-	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( b2, Ctor ), true, 'returns expected value' );
 	t.notEqual( b2, b1, 'returns a new reference' );
 	t.strictEqual( b2.byteLength, 2, 'has expected number of bytes' );
 
diff --git a/lib/node_modules/@stdlib/bench/harness/test/test.benchmark.js b/lib/node_modules/@stdlib/bench/harness/test/test.benchmark.js
index 63aed4610def..ab623df96eec 100644
--- a/lib/node_modules/@stdlib/bench/harness/test/test.benchmark.js
+++ b/lib/node_modules/@stdlib/bench/harness/test/test.benchmark.js
@@ -45,7 +45,7 @@ tape( 'the function is a constructor (no benchmark)', function test( t ) {
 	};
 	b = new Benchmark( 'beep', opts );
 
-	t.strictEqual( b instanceof Benchmark, true, 'returns an instance' );
+	t.strictEqual( b instanceof Benchmark, true, 'returns expected value' );
 	t.end();
 });
 
@@ -60,7 +60,7 @@ tape( 'the function is a constructor (benchmark)', function test( t ) {
 	};
 	b = new Benchmark( 'beep', opts, benchmark );
 
-	t.strictEqual( b instanceof Benchmark, true, 'returns an instance' );
+	t.strictEqual( b instanceof Benchmark, true, 'returns expected value' );
 	t.end();
 
 	function benchmark( b ) {
@@ -97,7 +97,7 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 	createBenchmark = Benchmark;
 	b = createBenchmark( 'beep', opts );
 
-	t.strictEqual( b instanceof Benchmark, true, 'returns an instance' );
+	t.strictEqual( b instanceof Benchmark, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/bench/harness/test/test.runner.js b/lib/node_modules/@stdlib/bench/harness/test/test.runner.js
index f5c090c4029d..d58fa447ed70 100644
--- a/lib/node_modules/@stdlib/bench/harness/test/test.runner.js
+++ b/lib/node_modules/@stdlib/bench/harness/test/test.runner.js
@@ -21,7 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
-var TransformStream = require( '@stdlib/streams/node/transform' );
+var TransformStream = require( '@stdlib/streams/node/transform' ); // eslint-disable-line stdlib/no-redeclare
 var randu = require( '@stdlib/random/base/randu' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var isRegExp = require( '@stdlib/assert/is-regexp' );
@@ -52,7 +52,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function is a constructor', function test( t ) {
 	var runner = new Runner();
-	t.strictEqual( runner instanceof Runner, true, 'returns an instance' );
+	t.strictEqual( runner instanceof Runner, true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,7 +63,7 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 	createRunner = Runner;
 	runner = createRunner();
 
-	t.strictEqual( runner instanceof Runner, true, 'returns an instance' );
+	t.strictEqual( runner instanceof Runner, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/cli/ctor/test/test.js b/lib/node_modules/@stdlib/cli/ctor/test/test.js
index 238bb10b312c..f3e42a37b273 100644
--- a/lib/node_modules/@stdlib/cli/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/cli/ctor/test/test.js
@@ -52,7 +52,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'the function is a constructor', function test( t ) {
-	t.strictEqual( instanceOf( new CLI(), CLI ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( new CLI(), CLI ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -63,7 +63,7 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 	ctor = CLI;
 	cli = ctor();
 
-	t.strictEqual( instanceOf( cli, CLI ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( cli, CLI ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/datasets/afinn-111/test/test.browser.js b/lib/node_modules/@stdlib/datasets/afinn-111/test/test.browser.js
index 81448e380ca2..2ead78265ca7 100644
--- a/lib/node_modules/@stdlib/datasets/afinn-111/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/afinn-111/test/test.browser.js
@@ -38,7 +38,7 @@ tape( 'the function returns an array of 2-element arrays', function test( t ) {
 	var i;
 
 	list = afinn111();
-	t.strictEqual( isArray( list ), true, 'returns an array' );
+	t.strictEqual( isArray( list ), true, 'returns expected value' );
 	for ( i = 0; i < list.length; i++ ) {
 		t.strictEqual( isArray( list[i] ), true, 'element '+i+' is an array' );
 		t.strictEqual( list[i].length, 2, 'element '+i+' is a 2-element array' );
diff --git a/lib/node_modules/@stdlib/datasets/afinn-111/test/test.js b/lib/node_modules/@stdlib/datasets/afinn-111/test/test.js
index 01c54af7e8b3..5038dbd8820b 100644
--- a/lib/node_modules/@stdlib/datasets/afinn-111/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/afinn-111/test/test.js
@@ -46,7 +46,7 @@ tape( 'the function returns an array of 2-element arrays', opts, function test(
 	var i;
 
 	list = afinn111();
-	t.strictEqual( isArray( list ), true, 'returns an array' );
+	t.strictEqual( isArray( list ), true, 'returns expected value' );
 	for ( i = 0; i < list.length; i++ ) {
 		t.strictEqual( isArray( list[i] ), true, 'element '+i+' is an array' );
 		t.strictEqual( list[i].length, 2, 'element '+i+' is a 2-element array' );
diff --git a/lib/node_modules/@stdlib/datasets/afinn-96/test/test.browser.js b/lib/node_modules/@stdlib/datasets/afinn-96/test/test.browser.js
index 980322fe89c9..9e7bd106fef8 100644
--- a/lib/node_modules/@stdlib/datasets/afinn-96/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/afinn-96/test/test.browser.js
@@ -37,7 +37,7 @@ tape( 'the function returns an array of 2-element arrays', function test( t ) {
 	var list;
 	var i;
 	list = afinn96();
-	t.strictEqual( isArray( list ), true, 'returns an array' );
+	t.strictEqual( isArray( list ), true, 'returns expected value' );
 	for ( i = 0; i < list.length; i++ ) {
 		t.strictEqual( isArray( list[i] ), true, 'element '+i+' is an array' );
 		t.strictEqual( list[i].length, 2, 'element '+i+' is a 2-element array' );
diff --git a/lib/node_modules/@stdlib/datasets/afinn-96/test/test.js b/lib/node_modules/@stdlib/datasets/afinn-96/test/test.js
index 048f8f3b7186..5e99d753a700 100644
--- a/lib/node_modules/@stdlib/datasets/afinn-96/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/afinn-96/test/test.js
@@ -46,7 +46,7 @@ tape( 'the function returns an array of 2-element arrays', opts, function test(
 	var i;
 
 	list = afinn96();
-	t.strictEqual( isArray( list ), true, 'returns an array' );
+	t.strictEqual( isArray( list ), true, 'returns expected value' );
 	for ( i = 0; i < list.length; i++ ) {
 		t.strictEqual( isArray( list[i] ), true, 'element '+i+' is an array' );
 		t.strictEqual( list[i].length, 2, 'element '+i+' is a 2-element array' );
diff --git a/lib/node_modules/@stdlib/datasets/anscombes-quartet/test/test.browser.js b/lib/node_modules/@stdlib/datasets/anscombes-quartet/test/test.browser.js
index 597c2ddcb694..a6afe440b285 100644
--- a/lib/node_modules/@stdlib/datasets/anscombes-quartet/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/anscombes-quartet/test/test.browser.js
@@ -39,7 +39,7 @@ tape( 'the function returns an array of arrays of 2-element arrays', function te
 	var j;
 
 	d = data();
-	t.strictEqual( isArray( d ), true, 'returns an array' );
+	t.strictEqual( isArray( d ), true, 'returns expected value' );
 	for ( i = 0; i < d.length; i++ ) {
 		t.strictEqual( isArray( d[i] ), true, 'element '+i+' is an array' );
 		for ( j = 0; j < d[i].length; j++ ) {
diff --git a/lib/node_modules/@stdlib/datasets/anscombes-quartet/test/test.js b/lib/node_modules/@stdlib/datasets/anscombes-quartet/test/test.js
index 7b2a30add6e5..40ee045ea8f9 100644
--- a/lib/node_modules/@stdlib/datasets/anscombes-quartet/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/anscombes-quartet/test/test.js
@@ -47,7 +47,7 @@ tape( 'the function returns an array of arrays of 2-element arrays', opts, funct
 	var j;
 
 	d = data();
-	t.strictEqual( isArray( d ), true, 'returns an array' );
+	t.strictEqual( isArray( d ), true, 'returns expected value' );
 	for ( i = 0; i < d.length; i++ ) {
 		t.strictEqual( isArray( d[i] ), true, 'element '+i+' is an array' );
 		for ( j = 0; j < d[i].length; j++ ) {
diff --git a/lib/node_modules/@stdlib/datasets/harrison-boston-house-prices-corrected/test/test.js b/lib/node_modules/@stdlib/datasets/harrison-boston-house-prices-corrected/test/test.js
index 19fe19e04815..6457b19dcb9a 100644
--- a/lib/node_modules/@stdlib/datasets/harrison-boston-house-prices-corrected/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/harrison-boston-house-prices-corrected/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', opts, function test( t ) {
 	var data = dataset();
-	t.strictEqual( isObjectArray( data ), true, 'returns an array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
 	t.strictEqual( data.length, 506, 'has expected length' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/harrison-boston-house-prices/test/test.js b/lib/node_modules/@stdlib/datasets/harrison-boston-house-prices/test/test.js
index 19fe19e04815..6457b19dcb9a 100644
--- a/lib/node_modules/@stdlib/datasets/harrison-boston-house-prices/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/harrison-boston-house-prices/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', opts, function test( t ) {
 	var data = dataset();
-	t.strictEqual( isObjectArray( data ), true, 'returns an array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
 	t.strictEqual( data.length, 506, 'has expected length' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.browser.js b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.browser.js
index 8fd07673c01c..673fc897f08f 100644
--- a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.browser.js
+++ b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.browser.js
@@ -160,7 +160,7 @@ tape( 'if the `data` option is `army`, the function returns an array of objects'
 	};
 	data = minard( opts );
 
-	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -180,7 +180,7 @@ tape( 'if the `data` option is `cities`, the function returns an array of object
 	};
 	data = minard( opts );
 
-	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -200,7 +200,7 @@ tape( 'if the `data` option is `labels`, the function returns an array of object
 	};
 	data = minard( opts );
 
-	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -240,7 +240,7 @@ tape( 'if the `data` option is `temperature`, the function returns an array of o
 	};
 	data = minard( opts );
 
-	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
diff --git a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.js b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.js
index 595ef28ede99..983bf1e5e88f 100644
--- a/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/minard-napoleons-march/test/test.js
@@ -168,7 +168,7 @@ tape( 'if the `data` option is `army`, the function returns an array of objects'
 	};
 	data = minard( opts );
 
-	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -188,7 +188,7 @@ tape( 'if the `data` option is `cities`, the function returns an array of object
 	};
 	data = minard( opts );
 
-	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -208,7 +208,7 @@ tape( 'if the `data` option is `labels`, the function returns an array of object
 	};
 	data = minard( opts );
 
-	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
@@ -248,7 +248,7 @@ tape( 'if the `data` option is `temperature`, the function returns an array of o
 	};
 	data = minard( opts );
 
-	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
 
 	// Should return a deep copy...
 	d2 = minard( opts );
diff --git a/lib/node_modules/@stdlib/datasets/pace-boston-house-prices/test/test.js b/lib/node_modules/@stdlib/datasets/pace-boston-house-prices/test/test.js
index 19fe19e04815..6457b19dcb9a 100644
--- a/lib/node_modules/@stdlib/datasets/pace-boston-house-prices/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/pace-boston-house-prices/test/test.js
@@ -43,7 +43,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an array of objects', opts, function test( t ) {
 	var data = dataset();
-	t.strictEqual( isObjectArray( data ), true, 'returns an array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
 	t.strictEqual( data.length, 506, 'has expected length' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/datasets/sotu/test/test.js b/lib/node_modules/@stdlib/datasets/sotu/test/test.js
index bc4d7bad040c..5f6fd7213471 100644
--- a/lib/node_modules/@stdlib/datasets/sotu/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/sotu/test/test.js
@@ -130,7 +130,7 @@ tape( 'the function throws an error if provided a unrecognized `party`', functio
 
 tape( 'the function returns an object array', function test( t ) {
 	var out = sotu();
-	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -142,7 +142,7 @@ tape( 'the `name` option can be used to retrieve SOTU addresses by specific Pres
 	out = sotu({
 		'name': 'Barack Obama'
 	});
-	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 8, 'returns selected speeches' );
 
 	for ( i = 0; i < out.length; i++ ) {
@@ -152,7 +152,7 @@ tape( 'the `name` option can be used to retrieve SOTU addresses by specific Pres
 	out = sotu({
 		'name': [ 'William J Clinton', 'Barack Obama' ]
 	});
-	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 16, 'returns selected speeches' );
 
 	for ( i = 0; i < out.length; i++ ) {
@@ -170,7 +170,7 @@ tape( 'the `party` option can be used to retrieve SOTU addresses from Presidents
 	out = sotu({
 		'party': 'Democratic'
 	});
-	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns expected value' );
 
 	for ( i = 0; i < out.length; i++ ) {
 		t.strictEqual( out[ i ].party, 'Democratic', 'speech is from a Democratic President' );
@@ -179,7 +179,7 @@ tape( 'the `party` option can be used to retrieve SOTU addresses from Presidents
 	out = sotu({
 		'party': [ 'Democratic', 'Republican' ]
 	});
-	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns expected value' );
 
 	for ( i = 0; i < out.length; i++ ) {
 		bool = ( out[ i ].party === 'Democratic' || out[ i ].party === 'Republican' );
@@ -194,13 +194,13 @@ tape( 'the `year` option can be used to retrieve SOTU addresses from particular
 	out = sotu({
 		'year': 2009
 	});
-	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns expected value' );
 	t.strictEqual( out[ 0 ].name, 'Barack Obama', 'speech is from expected President' );
 
 	out = sotu({
 		'year': [ 1998, 2009 ]
 	});
-	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns expected value' );
 	t.strictEqual( out[ 0 ].name, 'William J Clinton', 'speech is from expected President' );
 	t.strictEqual( out[ 1 ].name, 'Barack Obama', 'speech is from expected President' );
 
@@ -213,25 +213,25 @@ tape( 'the `range` option can be used to retrieve SOTU addresses of a given time
 	out = sotu({
 		'range': [ 1980, 1995 ]
 	});
-	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 16, 'returns speeches from 1980 to 1995' );
 
 	out = sotu({
 		'range': [ 1880, 1920 ]
 	});
-	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 41, 'returns speeches from 1880 to 1920' );
 
 	out = sotu({
 		'range': [ 1920, 1970 ]
 	});
-	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 52, 'returns speeches from 1920 to 1970' );
 
 	out = sotu({
 		'range': [ 1935, 1960 ]
 	});
-	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 27, 'returns speeches from 1935 to 1960' );
 
 	t.end();
@@ -256,7 +256,7 @@ tape( 'if provided multiple options, the function returns the union', function t
 		'party': 0
 	};
 
-	t.strictEqual( isObjectArray( out ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 24, 'returned array has expected length' );
 
 	for ( i = 0; i < out.length; i++ ) {
diff --git a/lib/node_modules/@stdlib/datasets/test/test.js b/lib/node_modules/@stdlib/datasets/test/test.js
index e3173ecd0aad..f93e0cf43491 100644
--- a/lib/node_modules/@stdlib/datasets/test/test.js
+++ b/lib/node_modules/@stdlib/datasets/test/test.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns datasets', function test( t ) {
 	var data = datasets( 'MONTH_NAMES_EN' );
-	t.strictEqual( isArray( data ), true, 'returns an array' );
+	t.strictEqual( isArray( data ), true, 'returns expected value' );
 	t.strictEqual( data.length, 12, 'has length of 12' );
 	t.end();
 });
@@ -50,7 +50,7 @@ tape( 'the function supports dataset options', function tests( t ) {
 	};
 	data = datasets( 'SOTU', opts );
 
-	t.strictEqual( isObjectArray( data ), true, 'returns an object array' );
+	t.strictEqual( isObjectArray( data ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/dstructs/circular-buffer/test/test.js b/lib/node_modules/@stdlib/dstructs/circular-buffer/test/test.js
index 0ccb1a2301dd..0e44bce29ebf 100644
--- a/lib/node_modules/@stdlib/dstructs/circular-buffer/test/test.js
+++ b/lib/node_modules/@stdlib/dstructs/circular-buffer/test/test.js
@@ -71,13 +71,13 @@ tape( 'the function throws an error if not provided either a positive integer or
 
 tape( 'the function is a constructor (size)', function test( t ) {
 	var buf = new CircularBuffer( 3 );
-	t.strictEqual( instanceOf( buf, CircularBuffer ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( buf, CircularBuffer ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function is a constructor (buffer)', function test( t ) {
 	var buf = new CircularBuffer( [ 0, 0, 0 ] );
-	t.strictEqual( instanceOf( buf, CircularBuffer ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( buf, CircularBuffer ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -87,7 +87,7 @@ tape( 'the constructor does not require the `new` keyword (size)', function test
 
 	circularBuffer = CircularBuffer;
 	buf = circularBuffer( 3 );
-	t.strictEqual( instanceOf( buf, CircularBuffer ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( buf, CircularBuffer ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -97,7 +97,7 @@ tape( 'the constructor does not require the `new` keyword (buffer)', function te
 
 	circularBuffer = CircularBuffer;
 	buf = circularBuffer( [ 0, 0, 0 ] );
-	t.strictEqual( instanceOf( buf, CircularBuffer ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( buf, CircularBuffer ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/dstructs/compact-adjacency-matrix/test/test.js b/lib/node_modules/@stdlib/dstructs/compact-adjacency-matrix/test/test.js
index 115fd7545421..e5d8979a1af6 100644
--- a/lib/node_modules/@stdlib/dstructs/compact-adjacency-matrix/test/test.js
+++ b/lib/node_modules/@stdlib/dstructs/compact-adjacency-matrix/test/test.js
@@ -35,7 +35,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function is a constructor', function test( t ) {
 	var mat = new CompactAdjacencyMatrix( 4 );
-	t.strictEqual( instanceOf( mat, CompactAdjacencyMatrix ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( mat, CompactAdjacencyMatrix ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -45,6 +45,6 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 
 	compactAdjacencyMatrix = CompactAdjacencyMatrix;
 	mat = compactAdjacencyMatrix( 4 );
-	t.strictEqual( instanceOf( mat, CompactAdjacencyMatrix ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( mat, CompactAdjacencyMatrix ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/dstructs/doubly-linked-list/test/test.js b/lib/node_modules/@stdlib/dstructs/doubly-linked-list/test/test.js
index 9c47be38c867..5d945ebb7209 100644
--- a/lib/node_modules/@stdlib/dstructs/doubly-linked-list/test/test.js
+++ b/lib/node_modules/@stdlib/dstructs/doubly-linked-list/test/test.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function is a constructor', function test( t ) {
 	var list = new DoublyLinkedList();
-	t.strictEqual( instanceOf( list, DoublyLinkedList ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( list, DoublyLinkedList ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -48,7 +48,7 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 
 	linkedList = DoublyLinkedList;
 	list = linkedList();
-	t.strictEqual( instanceOf( list, DoublyLinkedList ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( list, DoublyLinkedList ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/dstructs/fifo/test/test.js b/lib/node_modules/@stdlib/dstructs/fifo/test/test.js
index 83772cc0c643..dfbb45741ee0 100644
--- a/lib/node_modules/@stdlib/dstructs/fifo/test/test.js
+++ b/lib/node_modules/@stdlib/dstructs/fifo/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function is a constructor', function test( t ) {
 	var q = new FIFO();
-	t.strictEqual( instanceOf( q, FIFO ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( q, FIFO ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -47,7 +47,7 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 
 	fifo = FIFO;
 	q = fifo();
-	t.strictEqual( instanceOf( q, FIFO ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( q, FIFO ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/dstructs/linked-list/test/test.js b/lib/node_modules/@stdlib/dstructs/linked-list/test/test.js
index 777e483fad55..c69b894e59bd 100644
--- a/lib/node_modules/@stdlib/dstructs/linked-list/test/test.js
+++ b/lib/node_modules/@stdlib/dstructs/linked-list/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function is a constructor', function test( t ) {
 	var list = new LinkedList();
-	t.strictEqual( instanceOf( list, LinkedList ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( list, LinkedList ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -47,7 +47,7 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 
 	linkedList = LinkedList;
 	list = linkedList();
-	t.strictEqual( instanceOf( list, LinkedList ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( list, LinkedList ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/dstructs/stack/test/test.js b/lib/node_modules/@stdlib/dstructs/stack/test/test.js
index d15c6504d0aa..4a8bf8f65342 100644
--- a/lib/node_modules/@stdlib/dstructs/stack/test/test.js
+++ b/lib/node_modules/@stdlib/dstructs/stack/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function is a constructor', function test( t ) {
 	var s = new Stack();
-	t.strictEqual( instanceOf( s, Stack ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Stack ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -47,7 +47,7 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 
 	stack = Stack;
 	s = stack();
-	t.strictEqual( instanceOf( s, Stack ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Stack ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/error/tools/database/test/test.js b/lib/node_modules/@stdlib/error/tools/database/test/test.js
index 4ce9c298b05d..03d013f55ebc 100644
--- a/lib/node_modules/@stdlib/error/tools/database/test/test.js
+++ b/lib/node_modules/@stdlib/error/tools/database/test/test.js
@@ -37,7 +37,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns an object mappping error codes to error messages', function test( t ) {
 	var data = database();
 	var keys = objectKeys( data );
-	t.strictEqual( isPlainObject( data ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( data ), true, 'returns expected value' );
 	t.strictEqual( keys.length > 0, true, 'the returned object has keys' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/close/test/test.sync.js b/lib/node_modules/@stdlib/fs/close/test/test.sync.js
index 82df558ab33d..d31d68bd6eb9 100644
--- a/lib/node_modules/@stdlib/fs/close/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/close/test/test.sync.js
@@ -93,7 +93,7 @@ tape( 'if the function encounters an error, the function returns the error', opt
 		}
 	});
 	err = close( 9999999999999999999 );
-	t.strictEqual( err instanceof Error, true, 'returns an error' );
+	t.strictEqual( err instanceof Error, true, 'returns expected value' );
 	t.end();
 
 	function mock() {
diff --git a/lib/node_modules/@stdlib/fs/exists/test/test.async.js b/lib/node_modules/@stdlib/fs/exists/test/test.async.js
index ea51ec568216..d13eb1b7532b 100644
--- a/lib/node_modules/@stdlib/fs/exists/test/test.async.js
+++ b/lib/node_modules/@stdlib/fs/exists/test/test.async.js
@@ -99,7 +99,7 @@ tape( 'the function supports error-first callbacks (success)', opts, function te
 tape( 'the function supports error-first callbacks (failure)', opts, function test( t ) {
 	exists( 'beepboopbebop', onExists );
 	function onExists( error, bool ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
@@ -129,7 +129,7 @@ tape( 'the function supports using `fs.stat` with error-first callbacks (failure
 	});
 	exists( 'beepboopbebop', onExists );
 	function onExists( error, bool ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( bool, false, 'returns expected value' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/fs/open/test/test.sync.js b/lib/node_modules/@stdlib/fs/open/test/test.sync.js
index 40f7b90fa2ac..74398046e33d 100644
--- a/lib/node_modules/@stdlib/fs/open/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/open/test/test.sync.js
@@ -66,18 +66,18 @@ tape( 'the function opens a file (flags+mode)', opts, function test( t ) {
 
 tape( 'if the function encounters an error, the function returns the error', opts, function test( t ) {
 	var fd = open( 'beepboopbapbop' );
-	t.strictEqual( fd instanceof Error, true, 'returns an error' );
+	t.strictEqual( fd instanceof Error, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if the function encounters an error, the function returns the error (flags)', opts, function test( t ) {
 	var fd = open( 'beepboopbapbop', 'r+' );
-	t.strictEqual( fd instanceof Error, true, 'returns an error' );
+	t.strictEqual( fd instanceof Error, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if the function encounters an error, the function returns the error (flags+mode)', opts, function test( t ) {
 	var fd = open( 'beepboopbapbop', 'r+', 438 );
-	t.strictEqual( fd instanceof Error, true, 'returns an error' );
+	t.strictEqual( fd instanceof Error, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/read-dir/test/test.async.js b/lib/node_modules/@stdlib/fs/read-dir/test/test.async.js
index 02a4a42f18b9..7627f180b5db 100644
--- a/lib/node_modules/@stdlib/fs/read-dir/test/test.async.js
+++ b/lib/node_modules/@stdlib/fs/read-dir/test/test.async.js
@@ -62,7 +62,7 @@ tape( 'if the function encounters an error, the function returns the error', opt
 	readDir( 'beepboopbapbop', onRead );
 
 	function onRead( error ) {
-		t.strictEqual( error instanceof Error, true, 'returns an error' );
+		t.strictEqual( error instanceof Error, true, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/fs/read-dir/test/test.sync.js b/lib/node_modules/@stdlib/fs/read-dir/test/test.sync.js
index a52f4d1fd122..55b28ffead7f 100644
--- a/lib/node_modules/@stdlib/fs/read-dir/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/read-dir/test/test.sync.js
@@ -57,7 +57,7 @@ tape( 'the function reads a directory', opts, function test( t ) {
 tape( 'if the function encounters an error, the function returns the error', opts, function test( t ) {
 	var out = readDir( 'beepboopbapbop' );
 
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/read-file-list/test/test.sync.js b/lib/node_modules/@stdlib/fs/read-file-list/test/test.sync.js
index 1cc5fe1f32c1..7af13c9ec76a 100644
--- a/lib/node_modules/@stdlib/fs/read-file-list/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/read-file-list/test/test.sync.js
@@ -155,7 +155,7 @@ tape( 'the function reads the contents of each file in a file list using provide
 tape( 'if the function encounters an error, the function returns the error', opts, function test( t ) {
 	var out = readFileList( [ 'beepboopbapbop' ] );
 
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 
 	t.end();
 });
@@ -165,13 +165,13 @@ tape( 'if the function encounters an error, the function returns the error (opti
 	var out;
 
 	out = readFileList( [ 'beepboopbapbop' ], 'utf8' );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 
 	opts = {
 		'encoding': 'utf8'
 	};
 	out = readFileList( [ 'beepboopbapbop' ], opts );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/read-file/test/test.sync.js b/lib/node_modules/@stdlib/fs/read-file/test/test.sync.js
index 122acb995feb..4d790a231991 100644
--- a/lib/node_modules/@stdlib/fs/read-file/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/read-file/test/test.sync.js
@@ -83,13 +83,13 @@ tape( 'the function reads the contents of a file using provided options (option
 
 tape( 'if the function encounters an error, the function returns the error', opts, function test( t ) {
 	var out = readFile( 'beepboopbapbop' );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if the function encounters an error, the function returns the error (option string)', opts, function test( t ) {
 	var out = readFile( 'beepboopbapbop', 'utf8' );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.end();
 });
 
@@ -101,7 +101,7 @@ tape( 'if the function encounters an error, the function returns the error (opti
 		'encoding': 'utf8'
 	};
 	out = readFile( 'beepboopbapbop', opts );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/read-json/test/test.sync.js b/lib/node_modules/@stdlib/fs/read-json/test/test.sync.js
index 605c0b127c19..2e7e36598269 100644
--- a/lib/node_modules/@stdlib/fs/read-json/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/read-json/test/test.sync.js
@@ -79,7 +79,7 @@ tape( 'the function throws an error if provided an options argument which is nei
 
 tape( 'if the function encounters an error when attempting to read a file, the function returns the error', opts, function test( t ) {
 	var out = readJSON( 'beepboopbapbop' );
-	t.strictEqual( instanceOf( out, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( out, Error ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -87,19 +87,19 @@ tape( 'if the function encounters an error when attempting to read a file, the f
 	var out;
 
 	out = readJSON( 'beepboopbapbop', 'utf8' );
-	t.strictEqual( instanceOf( out, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( out, Error ), true, 'returns expected value' );
 
 	out = readJSON( 'beepboopbapbop', {
 		'encoding': 'utf8'
 	});
-	t.strictEqual( instanceOf( out, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( out, Error ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if the function encounters an error when attempting to parse file contents as JSON, the function returns the error', opts, function test( t ) {
 	var out = readJSON( badJSON );
-	t.strictEqual( instanceOf( out, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( out, Error ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -107,12 +107,12 @@ tape( 'if the function encounters an error when attempting to parse file content
 	var out;
 
 	out = readJSON( badJSON, 'utf8' );
-	t.strictEqual( instanceOf( out, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( out, Error ), true, 'returns expected value' );
 
 	out = readJSON( badJSON, {
 		'encoding': 'utf8'
 	});
-	t.strictEqual( instanceOf( out, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( out, Error ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/read-wasm/test/test.sync.js b/lib/node_modules/@stdlib/fs/read-wasm/test/test.sync.js
index 629e9d5ebfe4..7dfb91561fec 100644
--- a/lib/node_modules/@stdlib/fs/read-wasm/test/test.sync.js
+++ b/lib/node_modules/@stdlib/fs/read-wasm/test/test.sync.js
@@ -82,7 +82,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'if the function encounters an error when attempting to read a file, the function returns the error', opts, function test( t ) {
 	var out = readWASM( 'beepboopbapbop' );
-	t.strictEqual( instanceOf( out, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( out, Error ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -90,7 +90,7 @@ tape( 'if the function encounters an error when attempting to read a file, the f
 	var out = readWASM( 'beepboopbapbop', {
 		'flag': 'r'
 	});
-	t.strictEqual( instanceOf( out, Error ), true, 'returns an error' );
+	t.strictEqual( instanceOf( out, Error ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/besselj0/test/test.js b/lib/node_modules/@stdlib/math/base/special/besselj0/test/test.js
index 5a854807321d..f964d0681e47 100644
--- a/lib/node_modules/@stdlib/math/base/special/besselj0/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/besselj0/test/test.js
@@ -325,12 +325,12 @@ tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 
 tape( 'the function returns `0.0` if provided `+infinity`', function test( t ) {
 	var v = j0( NINF );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0.0` if provided `-infinity`', function test( t ) {
 	var v = j0( PINF );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/besselj0/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/besselj0/test/test.native.js
index 2ce53317c078..ead45b4ec171 100644
--- a/lib/node_modules/@stdlib/math/base/special/besselj0/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/besselj0/test/test.native.js
@@ -338,12 +338,12 @@ tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 
 tape( 'the function returns `0.0` if provided `+infinity`', opts, function test( t ) {
 	var v = j0( NINF );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0.0` if provided `-infinity`', opts, function test( t ) {
 	var v = j0( PINF );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/besselj1/test/test.js b/lib/node_modules/@stdlib/math/base/special/besselj1/test/test.js
index 0cc1b653fed1..0b03f5afac1b 100644
--- a/lib/node_modules/@stdlib/math/base/special/besselj1/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/besselj1/test/test.js
@@ -325,12 +325,12 @@ tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 
 tape( 'the function returns `0.0` if provided `+infinity`', function test( t ) {
 	var v = j1( NINF );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0.0` if provided `-infinity`', function test( t ) {
 	var v = j1( PINF );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/besselj1/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/besselj1/test/test.native.js
index 2bb7d8453fa2..720cf46f180c 100644
--- a/lib/node_modules/@stdlib/math/base/special/besselj1/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/besselj1/test/test.native.js
@@ -334,12 +334,12 @@ tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 
 tape( 'the function returns `0.0` if provided `+infinity`', opts, function test( t ) {
 	var v = j1( NINF );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `0.0` if provided `-infinity`', opts, function test( t ) {
 	var v = j1( PINF );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/bessely0/test/test.js b/lib/node_modules/@stdlib/math/base/special/bessely0/test/test.js
index ef815fbcbdf8..c96d7a646cd1 100644
--- a/lib/node_modules/@stdlib/math/base/special/bessely0/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/bessely0/test/test.js
@@ -273,7 +273,7 @@ tape( 'the function returns `NaN` for negative numbers', function test( t ) {
 
 tape( 'the function returns `-Infintiy` if provided `0.0`', function test( t ) {
 	var v = y0( 0.0 );
-	t.strictEqual( v, NINF, 'returns -Infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -285,7 +285,7 @@ tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 
 tape( 'the function returns `0.0` if provided `+infinity`', function test( t ) {
 	var v = y0( PINF );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/bessely0/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/bessely0/test/test.native.js
index 8a6e3f967e43..e42f9c03b6a3 100644
--- a/lib/node_modules/@stdlib/math/base/special/bessely0/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/bessely0/test/test.native.js
@@ -286,7 +286,7 @@ tape( 'the function returns `NaN` for negative numbers', opts, function test( t
 
 tape( 'the function returns `-Infintiy` if provided `0.0`', opts, function test( t ) {
 	var v = y0( 0.0 );
-	t.strictEqual( v, NINF, 'returns -Infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -298,7 +298,7 @@ tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 
 tape( 'the function returns `0.0` if provided `+infinity`', opts, function test( t ) {
 	var v = y0( PINF );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/bessely1/test/test.js b/lib/node_modules/@stdlib/math/base/special/bessely1/test/test.js
index 6dd01e114395..2e33f3c9d0fa 100644
--- a/lib/node_modules/@stdlib/math/base/special/bessely1/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/bessely1/test/test.js
@@ -197,7 +197,7 @@ tape( 'The Bessel function of the second kind of one order (Y_1) (subnormal valu
 	x = subnormal.x;
 	for ( i = 0; i < x.length; i++ ) {
 		y = y1( x[i] );
-		t.strictEqual( y, NINF, 'returns -Infinity' );
+		t.strictEqual( y, NINF, 'returns expected value' );
 	}
 	t.end();
 });
@@ -263,7 +263,7 @@ tape( 'the function returns `NaN` for negative numbers', function test( t ) {
 
 tape( 'the function returns `-Infinity` if provided `0`', function test( t ) {
 	var v = y1( 0.0 );
-	t.strictEqual( v, NINF, 'returns -Infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -275,7 +275,7 @@ tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 
 tape( 'the function returns `0.0` if provided `+infinity`', function test( t ) {
 	var v = y1( PINF );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/bessely1/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/bessely1/test/test.native.js
index fc9766c8eb57..4e5b0c901c67 100644
--- a/lib/node_modules/@stdlib/math/base/special/bessely1/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/bessely1/test/test.native.js
@@ -206,7 +206,7 @@ tape( 'The Bessel function of the second kind of one order (Y_1) (subnormal valu
 	x = subnormal.x;
 	for ( i = 0; i < x.length; i++ ) {
 		y = y1( x[i] );
-		t.strictEqual( y, NINF, 'returns -Infinity' );
+		t.strictEqual( y, NINF, 'returns expected value' );
 	}
 	t.end();
 });
@@ -272,7 +272,7 @@ tape( 'the function returns `NaN` for negative numbers', opts, function test( t
 
 tape( 'the function returns `-Infinity` if provided `0`', opts, function test( t ) {
 	var v = y1( 0.0 );
-	t.strictEqual( v, NINF, 'returns -Infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -284,7 +284,7 @@ tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 
 tape( 'the function returns `0.0` if provided `+infinity`', opts, function test( t ) {
 	var v = y1( PINF );
-	t.strictEqual( v, 0.0, 'returns 0.0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/beta/test/test.js b/lib/node_modules/@stdlib/math/base/special/beta/test/test.js
index e96e6cd1a8a9..58061dfd3996 100644
--- a/lib/node_modules/@stdlib/math/base/special/beta/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/beta/test/test.js
@@ -77,9 +77,9 @@ tape( 'the function returns `NaN` if provided negative values', function test( t
 
 tape( 'the function returns +Infinity if at least one argument is zero', function test( t ) {
 	var val = beta( 0.0, 2.0 );
-	t.strictEqual( val, PINF, 'returns +Infinity' );
+	t.strictEqual( val, PINF, 'returns expected value' );
 	val = beta( 1.0, 0.0 );
-	t.strictEqual( val, PINF, 'returns +Infinity' );
+	t.strictEqual( val, PINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/beta/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/beta/test/test.native.js
index 02326be6d9b1..682c8881c34d 100644
--- a/lib/node_modules/@stdlib/math/base/special/beta/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/beta/test/test.native.js
@@ -86,9 +86,9 @@ tape( 'the function returns `NaN` if provided negative values', opts, function t
 
 tape( 'the function returns +Infinity if at least one argument is zero', opts, function test( t ) {
 	var val = beta( 0.0, 2.0 );
-	t.strictEqual( val, PINF, 'returns +Infinity' );
+	t.strictEqual( val, PINF, 'returns expected value' );
 	val = beta( 1.0, 0.0 );
-	t.strictEqual( val, PINF, 'returns +Infinity' );
+	t.strictEqual( val, PINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/betaln/test/test.js b/lib/node_modules/@stdlib/math/base/special/betaln/test/test.js
index cb9340cdca57..78bd36d59391 100644
--- a/lib/node_modules/@stdlib/math/base/special/betaln/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/betaln/test/test.js
@@ -73,9 +73,9 @@ tape( 'the function returns `NaN` if provided negative values', function test( t
 
 tape( 'the function returns +Infinity if at least one argument is zero', function test( t ) {
 	var val = betaln( 0.0, 2.0 );
-	t.strictEqual( val, PINF, 'returns +Infinity' );
+	t.strictEqual( val, PINF, 'returns expected value' );
 	val = betaln( 1.0, 0.0 );
-	t.strictEqual( val, PINF, 'returns +Infinity' );
+	t.strictEqual( val, PINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/betaln/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/betaln/test/test.native.js
index 56a8bce31269..fbbf18d23270 100644
--- a/lib/node_modules/@stdlib/math/base/special/betaln/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/betaln/test/test.native.js
@@ -82,9 +82,9 @@ tape( 'the function returns `NaN` if provided negative values', opts, function t
 
 tape( 'the function returns +Infinity if at least one argument is zero', opts, function test( t ) {
 	var val = betaln( 0.0, 2.0 );
-	t.strictEqual( val, PINF, 'returns +Infinity' );
+	t.strictEqual( val, PINF, 'returns expected value' );
 	val = betaln( 1.0, 0.0 );
-	t.strictEqual( val, PINF, 'returns +Infinity' );
+	t.strictEqual( val, PINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/binomcoefln/test/test.js b/lib/node_modules/@stdlib/math/base/special/binomcoefln/test/test.js
index eba367e62f43..79b2a47552a0 100644
--- a/lib/node_modules/@stdlib/math/base/special/binomcoefln/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/binomcoefln/test/test.js
@@ -127,9 +127,9 @@ tape( 'the function returns `NaN` if the `k` value is not an integer', function
 
 tape( 'the function returns `-Infinity` for a negative integer `k`', function test( t ) {
 	var v = binomcoefln( 2, -1 );
-	t.strictEqual( v, NINF, 'returns -Infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 
 	v = binomcoefln( 2, -2 );
-	t.strictEqual( v, NINF, 'returns -Infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/binomcoefln/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/binomcoefln/test/test.native.js
index 116209eb305f..7a4d20f35532 100644
--- a/lib/node_modules/@stdlib/math/base/special/binomcoefln/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/binomcoefln/test/test.native.js
@@ -83,9 +83,9 @@ tape( 'the function evaluates the binomial coefficient for integers `m` and `k`'
 
 tape( 'the function returns `-Infinity` for a negative integer `k`', opts, function test( t ) {
 	var v = binomcoefln( 2, -1 );
-	t.strictEqual( v, NINF, 'returns -Infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 
 	v = binomcoefln( 2, -2 );
-	t.strictEqual( v, NINF, 'returns -Infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ccis/test/test.js b/lib/node_modules/@stdlib/math/base/special/ccis/test/test.js
index 7ab1ed569d20..709036b109ff 100644
--- a/lib/node_modules/@stdlib/math/base/special/ccis/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/ccis/test/test.js
@@ -157,8 +157,8 @@ tape( 'if imaginary component is `+Infinity`, all components are zero', function
 	var v;
 
 	v = ccis( new Complex128( 1.0, PINF ) );
-	t.strictEqual( real( v ), 0.0, 'returns 0.0' );
-	t.strictEqual( imag( v ), 0.0, 'returns 0.0' );
+	t.strictEqual( real( v ), 0.0, 'returns expected value' );
+	t.strictEqual( imag( v ), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -168,7 +168,7 @@ tape( 'if imaginary component is `-Infinity`, the function computes the correct
 	v = ccis( new Complex128( 0.0, NINF ) );
 
 	// The real component is computed as Infinity * 1.0 = Infinity:
-	t.strictEqual( real( v ), PINF, 'returns +Infinity' );
+	t.strictEqual( real( v ), PINF, 'returns expected value' );
 
 	// The imaginary component is computed as Infinity * 0.0 = NaN:
 	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/math/base/special/ccis/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/ccis/test/test.native.js
index 3e06ff1e76ea..d7102f07b38f 100644
--- a/lib/node_modules/@stdlib/math/base/special/ccis/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/ccis/test/test.native.js
@@ -167,8 +167,8 @@ tape( 'if imaginary component is `+Infinity`, all components are zeros', opts, f
 	var v;
 
 	v = ccis( new Complex128( 1.0, PINF ) );
-	t.strictEqual( real( v ), 0.0, 'returns 0.0' );
-	t.strictEqual( imag( v ), 0.0, 'returns 0.0' );
+	t.strictEqual( real( v ), 0.0, 'returns expected value' );
+	t.strictEqual( imag( v ), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -178,7 +178,7 @@ tape( 'if imaginary component is `-Infinity`, the function computes the correct
 	v = ccis( new Complex128( 0.0, NINF ) );
 
 	// The real component is computed as Infinity * 1.0 = Infinity:
-	t.strictEqual( real( v ), PINF, 'returns +Infinity' );
+	t.strictEqual( real( v ), PINF, 'returns expected value' );
 
 	// The imaginary component is computed as Infinity * 0.0 = NaN:
 	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/math/base/special/ceil/test/test.js b/lib/node_modules/@stdlib/math/base/special/ceil/test/test.js
index 31469d1200f1..be16359a87e7 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceil/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceil/test/test.js
@@ -52,24 +52,24 @@ tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 
 tape( 'the function returns `-0` if provided `-0`', function test( t ) {
 	var val = ceil( -0.0 );
-	t.strictEqual( isNegativeZero( val ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( val ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+0` if provided `+0`', function test( t ) {
 	var val = ceil( +0.0 );
-	t.strictEqual( isPositiveZero( val ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( val ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+infinity` if provided `+infinity`', function test( t ) {
 	var val = ceil( PINF );
-	t.strictEqual( val, PINF, 'returns +infinity' );
+	t.strictEqual( val, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', function test( t ) {
 	var val = ceil( NINF );
-	t.strictEqual( val, NINF, 'returns -infinity' );
+	t.strictEqual( val, NINF, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ceil/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/ceil/test/test.native.js
index 4d98364a7090..69c54d4fb305 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceil/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceil/test/test.native.js
@@ -61,24 +61,24 @@ tape( 'the function returns `NaN` if provided a `NaN`', opts, function test( t )
 
 tape( 'the function returns `-0` if provided `-0`', opts, function test( t ) {
 	var val = ceil( -0.0 );
-	t.strictEqual( isNegativeZero( val ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( val ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+0` if provided `+0`', opts, function test( t ) {
 	var val = ceil( +0.0 );
-	t.strictEqual( isPositiveZero( val ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( val ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+infinity` if provided `+infinity`', opts, function test( t ) {
 	var val = ceil( PINF );
-	t.strictEqual( val, PINF, 'returns +infinity' );
+	t.strictEqual( val, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', opts, function test( t ) {
 	var val = ceil( NINF );
-	t.strictEqual( val, NINF, 'returns -infinity' );
+	t.strictEqual( val, NINF, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ceil10/test/test.js b/lib/node_modules/@stdlib/math/base/special/ceil10/test/test.js
index c9f1ca0ff6e2..aed63842ef25 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceil10/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceil10/test/test.js
@@ -42,17 +42,17 @@ tape( 'the function returns `+0` if provided `+0`', function test( t ) {
 	var v;
 
 	v = ceil10( 0.0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceil10( +0.0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `-0` if provided `-0`', function test( t ) {
 	var v = ceil10( -0.0 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -64,13 +64,13 @@ tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 
 tape( 'the function returns `+infinity` if provided `+infinity`', function test( t ) {
 	var v = ceil10( PINF );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', function test( t ) {
 	var v = ceil10( NINF );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -80,11 +80,11 @@ tape( 'the function overflows if provided a sufficiently large positive value',
 
 	x = pow( 10.0, 308 );
 	v = ceil10( x + (x/2.0) );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	x = pow( 10.0, 308 );
 	v = ceil10( x + (x/3.0) );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -95,11 +95,11 @@ tape( 'the function underflows if provided a sufficiently small negative value',
 
 	x = -pow( 10.0, -323 );
 	v = ceil10( x - (x/2.0) );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	x = -pow( 10.0, -323 );
 	v = ceil10( x - (x/3.0) );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ceil10/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/ceil10/test/test.native.js
index ce1ed9f6eed6..e426ff9b49e7 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceil10/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceil10/test/test.native.js
@@ -51,17 +51,17 @@ tape( 'the function returns `+0` if provided `+0`', opts, function test( t ) {
 	var v;
 
 	v = ceil10( 0.0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceil10( +0.0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `-0` if provided `-0`', opts, function test( t ) {
 	var v = ceil10( -0.0 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -73,13 +73,13 @@ tape( 'the function returns `NaN` if provided a `NaN`', opts, function test( t )
 
 tape( 'the function returns `+infinity` if provided `+infinity`', opts, function test( t ) {
 	var v = ceil10( PINF );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', opts, function test( t ) {
 	var v = ceil10( NINF );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -89,11 +89,11 @@ tape( 'the function overflows if provided a sufficiently large positive value',
 
 	x = pow( 10.0, 308 );
 	v = ceil10( x + (x/2.0) );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	x = pow( 10.0, 308 );
 	v = ceil10( x + (x/3.0) );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	t.end();
 });
@@ -104,11 +104,11 @@ tape( 'the function underflows if provided a sufficiently small negative value',
 
 	x = -pow( 10.0, -323 );
 	v = ceil10( x - (x/2.0) );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	x = -pow( 10.0, -323 );
 	v = ceil10( x - (x/3.0) );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ceil2/test/test.js b/lib/node_modules/@stdlib/math/base/special/ceil2/test/test.js
index 85115c552332..c1f04a4fdb3b 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceil2/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceil2/test/test.js
@@ -44,17 +44,17 @@ tape( 'the function returns `+0` if provided `+0`', function test( t ) {
 	var v;
 
 	v = ceil2( 0.0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceil2( +0.0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `-0` if provided `-0`', function test( t ) {
 	var v = ceil2( -0.0 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -66,13 +66,13 @@ tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 
 tape( 'the function returns `+infinity` if provided `+infinity`', function test( t ) {
 	var v = ceil2( PINF );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', function test( t ) {
 	var v = ceil2( NINF );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -88,11 +88,11 @@ tape( 'the function overflows if provided a sufficiently large positive value',
 
 	x = exp2( 1023 );
 	v = ceil2( x + (x/2.0) );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	x = exp2( 1023 );
 	v = ceil2( x + (x/3.0) );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ceil2/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/ceil2/test/test.native.js
index c510408178be..9b75e6226ac4 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceil2/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceil2/test/test.native.js
@@ -53,17 +53,17 @@ tape( 'the function returns `+0` if provided `+0`', opts, function test( t ) {
 	var v;
 
 	v = ceil2( 0.0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceil2( +0.0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns `-0` if provided `-0`', opts, function test( t ) {
 	var v = ceil2( -0.0 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -75,13 +75,13 @@ tape( 'the function returns `NaN` if provided a `NaN`', opts, function test( t )
 
 tape( 'the function returns `+infinity` if provided `+infinity`', opts, function test( t ) {
 	var v = ceil2( PINF );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', opts, function test( t ) {
 	var v = ceil2( NINF );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -97,11 +97,11 @@ tape( 'the function overflows if provided a sufficiently large positive value',
 
 	x = exp2( 1023 );
 	v = ceil2( x + (x/2.0) );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	x = exp2( 1023 );
 	v = ceil2( x + (x/3.0) );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ceilb/test/test.js b/lib/node_modules/@stdlib/math/base/special/ceilb/test/test.js
index 2bff547f2e67..b216670b859d 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceilb/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceilb/test/test.js
@@ -109,13 +109,13 @@ tape( 'the function returns `NaN` if provided `b <= 0`', function test( t ) {
 
 tape( 'the function returns `+infinity` if provided `+infinity`', function test( t ) {
 	var v = ceilb( PINF, 5, 10 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', function test( t ) {
 	var v = ceilb( NINF, -3, 10 );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -123,13 +123,13 @@ tape( 'the function returns `-0` if provided `-0`', function test( t ) {
 	var v;
 
 	v = ceilb( -0.0, 0, 10 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	v = ceilb( -0.0, -2, 10 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	v = ceilb( -0.0, 2, 10 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -138,13 +138,13 @@ tape( 'the function returns `+0` if provided `+0`', function test( t ) {
 	var v;
 
 	v = ceilb( 0.0, 0, 10 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceilb( +0.0, -2, 10 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceilb( +0.0, 2, 10 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ceilb/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/ceilb/test/test.native.js
index 30cb0f03622f..b07c09a89bda 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceilb/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceilb/test/test.native.js
@@ -75,13 +75,13 @@ tape( 'the function returns `NaN` if provided `b <= 0`', opts, function test( t
 
 tape( 'the function returns `+infinity` if provided `+infinity`', opts, function test( t ) {
 	var v = ceilb( PINF, 5, 10 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', opts, function test( t ) {
 	var v = ceilb( NINF, -3, 10 );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -89,13 +89,13 @@ tape( 'the function returns `-0` if provided `-0`', opts, function test( t ) {
 	var v;
 
 	v = ceilb( -0.0, 0, 10 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	v = ceilb( -0.0, -2, 10 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	v = ceilb( -0.0, 2, 10 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -104,13 +104,13 @@ tape( 'the function returns `+0` if provided `+0`', opts, function test( t ) {
 	var v;
 
 	v = ceilb( 0.0, 0, 10 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceilb( +0.0, -2, 10 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceilb( +0.0, 2, 10 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ceilf/test/test.js b/lib/node_modules/@stdlib/math/base/special/ceilf/test/test.js
index 882348364b1a..82aca07b9608 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceilf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceilf/test/test.js
@@ -52,24 +52,24 @@ tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
 
 tape( 'the function returns `-0` if provided `-0`', function test( t ) {
 	var val = ceilf( -0.0 );
-	t.strictEqual( isNegativeZerof( val ), true, 'returns -0' );
+	t.strictEqual( isNegativeZerof( val ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+0` if provided `+0`', function test( t ) {
 	var val = ceilf( +0.0 );
-	t.strictEqual( isPositiveZerof( val ), true, 'returns +0' );
+	t.strictEqual( isPositiveZerof( val ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+infinity` if provided `+infinity`', function test( t ) {
 	var val = ceilf( PINF );
-	t.strictEqual( val, PINF, 'returns +infinity' );
+	t.strictEqual( val, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', function test( t ) {
 	var val = ceilf( NINF );
-	t.strictEqual( val, NINF, 'returns -infinity' );
+	t.strictEqual( val, NINF, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ceilf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/ceilf/test/test.native.js
index c0f7cd1bb204..cb667ca7f6b8 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceilf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceilf/test/test.native.js
@@ -61,24 +61,24 @@ tape( 'the function returns `NaN` if provided a `NaN`', opts, function test( t )
 
 tape( 'the function returns `-0` if provided `-0`', opts, function test( t ) {
 	var val = ceil( -0.0 );
-	t.strictEqual( isNegativeZerof( val ), true, 'returns -0' );
+	t.strictEqual( isNegativeZerof( val ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+0` if provided `+0`', opts, function test( t ) {
 	var val = ceil( +0.0 );
-	t.strictEqual( isPositiveZerof( val ), true, 'returns +0' );
+	t.strictEqual( isPositiveZerof( val ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `+infinity` if provided `+infinity`', opts, function test( t ) {
 	var val = ceil( PINF );
-	t.strictEqual( val, PINF, 'returns +infinity' );
+	t.strictEqual( val, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', opts, function test( t ) {
 	var val = ceil( NINF );
-	t.strictEqual( val, NINF, 'returns -infinity' );
+	t.strictEqual( val, NINF, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ceiln/test/test.js b/lib/node_modules/@stdlib/math/base/special/ceiln/test/test.js
index b60c19cdcf42..2430ce171fdf 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceiln/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceiln/test/test.js
@@ -72,13 +72,13 @@ tape( 'the function returns `NaN` if provided `n = +-infinity`', function test(
 
 tape( 'the function returns `+infinity` if provided `+infinity`', function test( t ) {
 	var v = ceiln( PINF, 5 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', function test( t ) {
 	var v = ceiln( NINF, -3 );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -86,13 +86,13 @@ tape( 'the function returns `-0` if provided `-0`', function test( t ) {
 	var v;
 
 	v = ceiln( -0.0, 0 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	v = ceiln( -0.0, -2 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	v = ceiln( -0.0, 2 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -101,13 +101,13 @@ tape( 'the function returns `+0` if provided `+0`', function test( t ) {
 	var v;
 
 	v = ceiln( 0.0, 0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceiln( +0.0, -2 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceiln( +0.0, 2 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ceiln/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/ceiln/test/test.native.js
index 48348b08ad69..efa9bbc30da8 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceiln/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceiln/test/test.native.js
@@ -63,13 +63,13 @@ tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 
 tape( 'the function returns `+infinity` if provided `+infinity`', opts, function test( t ) {
 	var v = ceiln( PINF, 5 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', opts, function test( t ) {
 	var v = ceiln( NINF, -3 );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -77,13 +77,13 @@ tape( 'the function returns `-0` if provided `-0`', opts, function test( t ) {
 	var v;
 
 	v = ceiln( -0.0, 0 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	v = ceiln( -0.0, -2 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	v = ceiln( -0.0, 2 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -92,13 +92,13 @@ tape( 'the function returns `+0` if provided `+0`', opts, function test( t ) {
 	var v;
 
 	v = ceiln( 0.0, 0 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceiln( +0.0, -2 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceiln( +0.0, 2 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ceilsd/test/test.js b/lib/node_modules/@stdlib/math/base/special/ceilsd/test/test.js
index cbb15a275114..4f7c3a8e8606 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceilsd/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceilsd/test/test.js
@@ -115,13 +115,13 @@ tape( 'the function returns `NaN` if provided `b <= 0`', function test( t ) {
 
 tape( 'the function returns `+infinity` if provided `+infinity`', function test( t ) {
 	var v = ceilsd( PINF, 5, 10 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', function test( t ) {
 	var v = ceilsd( NINF, 3, 10 );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -129,10 +129,10 @@ tape( 'the function returns `-0` if provided `-0`', function test( t ) {
 	var v;
 
 	v = ceilsd( -0.0, 1, 10 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	v = ceilsd( -0.0, 2, 10 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -141,10 +141,10 @@ tape( 'the function returns `+0` if provided `+0`', function test( t ) {
 	var v;
 
 	v = ceilsd( 0.0, 1, 10 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceilsd( +0.0, 2, 10 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/ceilsd/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/ceilsd/test/test.native.js
index 34a7e1199c55..2708ee41556c 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceilsd/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/ceilsd/test/test.native.js
@@ -81,13 +81,13 @@ tape( 'the function returns `NaN` if provided `b <= 0`', opts, function test( t
 
 tape( 'the function returns `+infinity` if provided `+infinity`', opts, function test( t ) {
 	var v = ceilsd( PINF, 5, 10 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns `-infinity` if provided `-infinity`', opts, function test( t ) {
 	var v = ceilsd( NINF, 3, 10 );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
@@ -95,10 +95,10 @@ tape( 'the function returns `-0` if provided `-0`', opts, function test( t ) {
 	var v;
 
 	v = ceilsd( -0.0, 1, 10 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	v = ceilsd( -0.0, 2, 10 );
-	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -107,10 +107,10 @@ tape( 'the function returns `+0` if provided `+0`', opts, function test( t ) {
 	var v;
 
 	v = ceilsd( 0.0, 1, 10 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	v = ceilsd( +0.0, 2, 10 );
-	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/cexp/test/test.js b/lib/node_modules/@stdlib/math/base/special/cexp/test/test.js
index 926e42f6299b..ad7afefe3312 100644
--- a/lib/node_modules/@stdlib/math/base/special/cexp/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/cexp/test/test.js
@@ -149,8 +149,8 @@ tape( 'if real component is `-Infinity`, the function returns a complex number w
 	var v;
 
 	v = cexp( new Complex128( NINF, 1.0 ) );
-	t.strictEqual( real( v ), 0.0, 'returns 0.0' );
-	t.strictEqual( imag( v ), 0.0, 'returns 0.0' );
+	t.strictEqual( real( v ), 0.0, 'returns expected value' );
+	t.strictEqual( imag( v ), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -158,8 +158,8 @@ tape( 'if real component is `+Infinity` and imaginary component is `0.0`, the fu
 	var v;
 
 	v = cexp( new Complex128( PINF, 0.0 ) );
-	t.strictEqual( real( v ), PINF, 'returns +Infinity' );
-	t.strictEqual( imag( v ), 0.0, 'returns 0.0' );
+	t.strictEqual( real( v ), PINF, 'returns expected value' );
+	t.strictEqual( imag( v ), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -168,7 +168,7 @@ tape( 'if real component is `NaN` and imaginary component is `0.0`, the function
 
 	v = cexp( new Complex128( NaN, 0.0 ) );
 	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
-	t.strictEqual( imag( v ), 0.0, 'returns 0.0' );
+	t.strictEqual( imag( v ), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -237,7 +237,7 @@ tape( 'if real component is `+Infinity` and imaginary component is `+Infinity`,
 	var v;
 
 	v = cexp( new Complex128( PINF, PINF ) );
-	t.strictEqual( real( v ), NINF, 'returns -Infinity' );
+	t.strictEqual( real( v ), NINF, 'returns expected value' );
 	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/cexp/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/cexp/test/test.native.js
index 40e0ae0d6d8e..75101e33b7b7 100644
--- a/lib/node_modules/@stdlib/math/base/special/cexp/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/cexp/test/test.native.js
@@ -158,8 +158,8 @@ tape( 'if real component is `-Infinity`, the function returns a complex number w
 	var v;
 
 	v = cexp( new Complex128( NINF, 1.0 ) );
-	t.strictEqual( real( v ), 0.0, 'returns 0.0' );
-	t.strictEqual( imag( v ), 0.0, 'returns 0.0' );
+	t.strictEqual( real( v ), 0.0, 'returns expected value' );
+	t.strictEqual( imag( v ), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -167,8 +167,8 @@ tape( 'if real component is `+Infinity` and imaginary component is `0.0`, the fu
 	var v;
 
 	v = cexp( new Complex128( PINF, 0.0 ) );
-	t.strictEqual( real( v ), PINF, 'returns +Infinity' );
-	t.strictEqual( imag( v ), 0.0, 'returns 0.0' );
+	t.strictEqual( real( v ), PINF, 'returns expected value' );
+	t.strictEqual( imag( v ), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -177,7 +177,7 @@ tape( 'if real component is `NaN` and imaginary component is `0.0`, the function
 
 	v = cexp( new Complex128( NaN, 0.0 ) );
 	t.strictEqual( isnan( real( v ) ), true, 'returns expected value' );
-	t.strictEqual( imag( v ), 0.0, 'returns 0.0' );
+	t.strictEqual( imag( v ), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -246,7 +246,7 @@ tape( 'if real component is `+Infinity` and imaginary component is `+Infinity`,
 	var v;
 
 	v = cexp( new Complex128( PINF, PINF ) );
-	t.strictEqual( real( v ), NINF, 'returns -Infinity' );
+	t.strictEqual( real( v ), NINF, 'returns expected value' );
 	t.strictEqual( isnan( imag( v ) ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/gamma/test/other/xtest.gamma.js b/lib/node_modules/@stdlib/math/base/special/gamma/test/other/xtest.gamma.js
index c5b5ec60198b..3ed9ac46a625 100644
--- a/lib/node_modules/@stdlib/math/base/special/gamma/test/other/xtest.gamma.js
+++ b/lib/node_modules/@stdlib/math/base/special/gamma/test/other/xtest.gamma.js
@@ -80,13 +80,13 @@ tape( 'if provided `NaN`, the function returns `NaN`', opts, function test( t )
 
 tape( 'if provided `-0`, the function returns negative infinity', opts, function test( t ) {
 	var v = gamma( -0.0 );
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `+0`, the function returns positive infinity', opts, function test( t ) {
 	var v = gamma( 0.0 );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -147,6 +147,6 @@ tape( 'the function evaluates the gamma function (decimal values)', opts, functi
 tape( 'if provided a positive integer, the function returns the factorial of (n-1)', opts, function test( t ) {
 	t.strictEqual( gamma( 4.0 ), 6.0, 'returns 6' );
 	t.strictEqual( gamma( 5.0 ), 24.0, 'returns 24' );
-	t.strictEqual( gamma( 6.0 ), 120.0, 'returns 120' );
+	t.strictEqual( gamma( 6.0 ), 120.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/gamma/test/test.boost.js b/lib/node_modules/@stdlib/math/base/special/gamma/test/test.boost.js
index dfd2182f43e0..98919f47c99c 100644
--- a/lib/node_modules/@stdlib/math/base/special/gamma/test/test.boost.js
+++ b/lib/node_modules/@stdlib/math/base/special/gamma/test/test.boost.js
@@ -168,6 +168,6 @@ tape( 'the function evaluates the gamma function (values near one)', function te
 tape( 'if provided a positive integer, the function returns the factorial of (n-1)', function test( t ) {
 	t.strictEqual( gamma( 4.0 ), 6.0, 'returns 6' );
 	t.strictEqual( gamma( 5.0 ), 24.0, 'returns 24' );
-	t.strictEqual( gamma( 6.0 ), 120.0, 'returns 120' );
+	t.strictEqual( gamma( 6.0 ), 120.0, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/gamma/test/test.js b/lib/node_modules/@stdlib/math/base/special/gamma/test/test.js
index 83c419c05af2..c1f9b53ca04c 100644
--- a/lib/node_modules/@stdlib/math/base/special/gamma/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/gamma/test/test.js
@@ -139,7 +139,7 @@ tape( 'the function evaluates the gamma function (decimal values)', function tes
 tape( 'if provided a positive integer, the function returns the factorial of (n-1)', function test( t ) {
 	t.strictEqual( gamma( 4.0 ), 6.0, 'returns 6' );
 	t.strictEqual( gamma( 5.0 ), 24.0, 'returns 24' );
-	t.strictEqual( gamma( 6.0 ), 120.0, 'returns 120' );
+	t.strictEqual( gamma( 6.0 ), 120.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/gamma/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/gamma/test/test.native.js
index d763bdf70478..a26ba1c11772 100644
--- a/lib/node_modules/@stdlib/math/base/special/gamma/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/gamma/test/test.native.js
@@ -148,7 +148,7 @@ tape( 'the function evaluates the gamma function (decimal values)', opts, functi
 tape( 'if provided a positive integer, the function returns the factorial of (n-1)', opts, function test( t ) {
 	t.strictEqual( gamma( 4.0 ), 6.0, 'returns 6' );
 	t.strictEqual( gamma( 5.0 ), 24.0, 'returns 24' );
-	t.strictEqual( gamma( 6.0 ), 120.0, 'returns 120' );
+	t.strictEqual( gamma( 6.0 ), 120.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/hypot/test/test.js b/lib/node_modules/@stdlib/math/base/special/hypot/test/test.js
index f40cac2b6e61..333a95638dce 100644
--- a/lib/node_modules/@stdlib/math/base/special/hypot/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/hypot/test/test.js
@@ -177,7 +177,7 @@ tape( 'the function avoids underflow', function test( t ) {
 	var h;
 
 	h = sqrt( pow( 1.0e-200, 2 ) + pow( 1e-200, 2 ) );
-	t.strictEqual( h, 0.0, 'returns 0' );
+	t.strictEqual( h, 0.0, 'returns expected value' );
 
 	h = hypot( 1.0e-200, 1.0e-200 );
 	t.strictEqual( h, 1.414213562373095e-200, 'avoids underflow' );
diff --git a/lib/node_modules/@stdlib/math/base/special/hypot/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/hypot/test/test.native.js
index fcdc958e4a94..1df944589124 100644
--- a/lib/node_modules/@stdlib/math/base/special/hypot/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/hypot/test/test.native.js
@@ -186,7 +186,7 @@ tape( 'the function avoids underflow', opts, function test( t ) {
 	var h;
 
 	h = sqrt( pow( 1.0e-200, 2 ) + pow( 1e-200, 2 ) );
-	t.strictEqual( h, 0.0, 'returns 0' );
+	t.strictEqual( h, 0.0, 'returns expected value' );
 
 	h = hypot( 1.0e-200, 1.0e-200 );
 	t.strictEqual( h, 1.414213562373095e-200, 'avoids underflow' );
diff --git a/lib/node_modules/@stdlib/math/base/special/hypotf/test/test.js b/lib/node_modules/@stdlib/math/base/special/hypotf/test/test.js
index ebda0c38fa29..f533ebc6e8c0 100644
--- a/lib/node_modules/@stdlib/math/base/special/hypotf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/hypotf/test/test.js
@@ -166,7 +166,7 @@ tape( 'the function avoids overflow', function test( t ) {
 	var h;
 
 	h = sqrtf( float64ToFloat32( float64ToFloat32( pow( 1.0e38, 2 ) ) + float64ToFloat32( pow( 1.0e38, 2 ) ) ) ); // eslint-disable-line max-len
-	t.strictEqual( h, PINF, 'returns +infinity' );
+	t.strictEqual( h, PINF, 'returns expected value' );
 
 	h = hypotf( 1.0e38, 1.0e38 );
 	t.strictEqual( h, float64ToFloat32( 1.4142135623730951e38 ), 'avoids overflow' );
@@ -178,7 +178,7 @@ tape( 'the function avoids underflow', function test( t ) {
 	var h;
 
 	h = sqrtf( float64ToFloat32( float64ToFloat32( pow( 1.0e-45, 2 ) ) + float64ToFloat32( pow( 1.0e-45, 2 ) ) ) ); // eslint-disable-line max-len
-	t.strictEqual( h, 0.0, 'returns 0' );
+	t.strictEqual( h, 0.0, 'returns expected value' );
 
 	h = hypotf( 1.0e-45, 1.0e-45 );
 	t.strictEqual( h, float64ToFloat32( 1.414213562373095e-45 ), 'avoids underflow' );
diff --git a/lib/node_modules/@stdlib/math/base/special/hypotf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/hypotf/test/test.native.js
index ec55231c142a..30c4318a7f1f 100644
--- a/lib/node_modules/@stdlib/math/base/special/hypotf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/hypotf/test/test.native.js
@@ -180,7 +180,7 @@ tape( 'the function avoids overflow', opts, function test( t ) {
 	var h;
 
 	h = sqrtf( float64ToFloat32( float64ToFloat32( pow( 1.0e38, 2 ) ) + float64ToFloat32( pow( 1.0e38, 2 ) ) ) ); // eslint-disable-line max-len
-	t.strictEqual( h, PINF, 'returns +infinity' );
+	t.strictEqual( h, PINF, 'returns expected value' );
 
 	h = hypotf( 1.0e38, 1.0e38 );
 	t.strictEqual( h, float64ToFloat32( 1.4142135623730951e38 ), 'avoids overflow' );
@@ -192,7 +192,7 @@ tape( 'the function avoids underflow', opts, function test( t ) {
 	var h;
 
 	h = sqrtf( float64ToFloat32( float64ToFloat32( pow( 1.0e-45, 2 ) ) + float64ToFloat32( pow( 1.0e-45, 2 ) ) ) ); // eslint-disable-line max-len
-	t.strictEqual( h, 0.0, 'returns 0' );
+	t.strictEqual( h, 0.0, 'returns expected value' );
 
 	h = hypotf( 1.0e-45, 1.0e-45 );
 	t.strictEqual( h, float64ToFloat32( 1.414213562373095e-45 ), 'avoids underflow' );
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-betainc/test/test.js b/lib/node_modules/@stdlib/math/base/special/kernel-betainc/test/test.js
index aad5d46960d1..90caa18694a9 100644
--- a/lib/node_modules/@stdlib/math/base/special/kernel-betainc/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/kernel-betainc/test/test.js
@@ -115,7 +115,7 @@ tape( 'attached to the function is a method which supports supplying a destinati
 	out = [ 0.0, 0.0 ];
 	v = kernelBetainc.assign( 0.5, 1.0, 1.0, true, true, out, 1, 0 );
 
-	t.strictEqual( isArray( v ), true, 'returns an array' );
+	t.strictEqual( isArray( v ), true, 'returns expected value' );
 	t.strictEqual( v.length, 2, 'returned array has two elements' );
 	t.strictEqual( v, out, 'returns a reference to output array' );
 
diff --git a/lib/node_modules/@stdlib/math/base/special/maxn/test/test.js b/lib/node_modules/@stdlib/math/base/special/maxn/test/test.js
index 046b10702629..9f269a5409d0 100644
--- a/lib/node_modules/@stdlib/math/base/special/maxn/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/maxn/test/test.js
@@ -75,7 +75,7 @@ tape( 'the function returns `+Infinity` if provided `+Infinity`', function test(
 
 tape( 'the function returns `-infinity` if not provided any arguments', function test( t ) {
 	var v = maxn();
-	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.strictEqual( v, NINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/minmaxabsn/test/test.assign.js b/lib/node_modules/@stdlib/math/base/special/minmaxabsn/test/test.assign.js
index 740f016c49ce..80c3a3ab4289 100644
--- a/lib/node_modules/@stdlib/math/base/special/minmaxabsn/test/test.assign.js
+++ b/lib/node_modules/@stdlib/math/base/special/minmaxabsn/test/test.assign.js
@@ -137,7 +137,7 @@ tape( 'the function returns `+Infinity` as the maximum value if provided `+Infin
 	v = minmaxabsn( PINF, out, 1, 0 );
 	t.strictEqual( v, out, 'returns output array' );
 	t.strictEqual( v[ 0 ], PINF, 'returns expected value' );
-	t.strictEqual( v[ 1 ], PINF, 'returns +infinity' );
+	t.strictEqual( v[ 1 ], PINF, 'returns expected value' );
 
 	out = new Float64Array( 2 );
 	v = minmaxabsn( 3.14, 4.2, PINF, out, 1, 0 );
diff --git a/lib/node_modules/@stdlib/math/base/special/minmaxabsn/test/test.main.js b/lib/node_modules/@stdlib/math/base/special/minmaxabsn/test/test.main.js
index 331af6e28af7..8ff7fdbd5b39 100644
--- a/lib/node_modules/@stdlib/math/base/special/minmaxabsn/test/test.main.js
+++ b/lib/node_modules/@stdlib/math/base/special/minmaxabsn/test/test.main.js
@@ -105,7 +105,7 @@ tape( 'the function returns `+Infinity` as the maximum value if provided `+Infin
 
 	v = minmaxabsn( PINF );
 	t.strictEqual( v[ 0 ], PINF, 'returns expected value' );
-	t.strictEqual( v[ 1 ], PINF, 'returns +infinity' );
+	t.strictEqual( v[ 1 ], PINF, 'returns expected value' );
 
 	v = minmaxabsn( 3.14, 4.2, PINF );
 	t.strictEqual( v[ 0 ], 3.14, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/math/base/special/modf/test/test.assign.js b/lib/node_modules/@stdlib/math/base/special/modf/test/test.assign.js
index d5d9f368507a..acc4fb2b3651 100644
--- a/lib/node_modules/@stdlib/math/base/special/modf/test/test.assign.js
+++ b/lib/node_modules/@stdlib/math/base/special/modf/test/test.assign.js
@@ -183,7 +183,7 @@ tape( 'if provided `+infinity`, the function returns `[+infinity,+0]`', function
 	out = [ 0.0, 0.0 ];
 	parts = modf( PINF, out, 1, 0 );
 	t.strictEqual( parts, out, 'returns output array' );
-	t.strictEqual( parts[0], PINF, 'returns +infinity' );
+	t.strictEqual( parts[0], PINF, 'returns expected value' );
 	t.strictEqual( isPositiveZero( parts[1] ), true, 'returns expected value' );
 	t.end();
 });
@@ -195,7 +195,7 @@ tape( 'if provided `-infinity`, the function returns `[-infinity,-0]`', function
 	out = [ 0.0, 0.0 ];
 	parts = modf( NINF, out, 1, 0 );
 	t.strictEqual( parts, out, 'returns output array' );
-	t.strictEqual( parts[0], NINF, 'returns -infinity' );
+	t.strictEqual( parts[0], NINF, 'returns expected value' );
 	t.strictEqual( isNegativeZero( parts[1] ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/modf/test/test.main.js b/lib/node_modules/@stdlib/math/base/special/modf/test/test.main.js
index 56405832084a..ea4d32fca73a 100644
--- a/lib/node_modules/@stdlib/math/base/special/modf/test/test.main.js
+++ b/lib/node_modules/@stdlib/math/base/special/modf/test/test.main.js
@@ -152,14 +152,14 @@ tape( 'if provided `-0`, the function returns `[-0,-0]`', function test( t ) {
 
 tape( 'if provided `+infinity`, the function returns `[+infinity,+0]`', function test( t ) {
 	var parts = modf( PINF );
-	t.strictEqual( parts[0], PINF, 'returns +infinity' );
+	t.strictEqual( parts[0], PINF, 'returns expected value' );
 	t.strictEqual( isPositiveZero( parts[1] ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `[-infinity,-0]`', function test( t ) {
 	var parts = modf( NINF );
-	t.strictEqual( parts[0], NINF, 'returns -infinity' );
+	t.strictEqual( parts[0], NINF, 'returns expected value' );
 	t.strictEqual( isNegativeZero( parts[1] ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/modf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/modf/test/test.native.js
index 39386ee511d3..d7dd3f3ed840 100644
--- a/lib/node_modules/@stdlib/math/base/special/modf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/modf/test/test.native.js
@@ -161,14 +161,14 @@ tape( 'if provided `-0`, the function returns `[-0,-0]`', opts, function test( t
 
 tape( 'if provided `+infinity`, the function returns `[+infinity,+0]`', opts, function test( t ) {
 	var parts = modf( PINF );
-	t.strictEqual( parts[0], PINF, 'returns +infinity' );
+	t.strictEqual( parts[0], PINF, 'returns expected value' );
 	t.strictEqual( isPositiveZero( parts[1] ), true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `[-infinity,-0]`', opts, function test( t ) {
 	var parts = modf( NINF );
-	t.strictEqual( parts[0], NINF, 'returns -infinity' );
+	t.strictEqual( parts[0], NINF, 'returns expected value' );
 	t.strictEqual( isNegativeZero( parts[1] ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/pow/test/test.js b/lib/node_modules/@stdlib/math/base/special/pow/test/test.js
index 054748306c21..8e196a8addf1 100644
--- a/lib/node_modules/@stdlib/math/base/special/pow/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/pow/test/test.js
@@ -765,7 +765,7 @@ tape( 'the function returns `+infinity` if a negative number less than `-1` is r
 
 tape( 'the function returns `+infinity` if `-infinity` is raised to `+infinity`', function test( t ) {
 	var v = pow( NINF, PINF );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -814,7 +814,7 @@ tape( 'the function returns `0` if a positive number greater than `1` is raised
 
 tape( 'the function returns `0` if `+infinity` is raised to `-infinity`', function test( t ) {
 	var v = pow( PINF, NINF );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/pow/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/pow/test/test.native.js
index e6477c58b948..9155b7ffc71d 100644
--- a/lib/node_modules/@stdlib/math/base/special/pow/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/pow/test/test.native.js
@@ -835,7 +835,7 @@ tape( 'the function returns `+infinity` if a negative number less than `-1` is r
 
 tape( 'the function returns `+infinity` if `-infinity` is raised to `+infinity`', opts, function test( t ) {
 	var v = pow( NINF, PINF );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
@@ -884,7 +884,7 @@ tape( 'the function returns `0` if a positive number greater than `1` is raised
 
 tape( 'the function returns `0` if `+infinity` is raised to `-infinity`', opts, function test( t ) {
 	var v = pow( PINF, NINF );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -950,7 +950,7 @@ tape( 'if `y > 2^64` and `x` is greater than `1`, the function overflows', opts,
 	x = 1.0 + EPS; // smallest value greater than 1.0
 	y = 3.6893488147419103e19; // 2.0^65
 	v = pow( x, y );
-	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.strictEqual( v, PINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/powm1/test/test.js b/lib/node_modules/@stdlib/math/base/special/powm1/test/test.js
index 57957534f041..823ee29e29cc 100644
--- a/lib/node_modules/@stdlib/math/base/special/powm1/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/powm1/test/test.js
@@ -52,7 +52,7 @@ tape( 'if provided an exponent.strictEqual to `0`, the function returns `0`', fu
 	var i;
 	for ( i = -100; i < 100; i++ ) {
 		t.strictEqual( powm1( i, 0.0 ), 0.0, 'returns -1' );
-		t.strictEqual( powm1( ( randu()*10.0 ) - 5.0, 0.0 ), 0.0, 'returns 0' );
+		t.strictEqual( powm1( ( randu()*10.0 ) - 5.0, 0.0 ), 0.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -61,7 +61,7 @@ tape( 'if provided a base equal to `0`, the function returns `-1` (except when t
 	var i;
 	for ( i = -100; i < 100; i++ ) {
 		if ( i === 0 ) {
-			t.strictEqual( powm1( 0.0, i ), 0.0, 'returns 0' );
+			t.strictEqual( powm1( 0.0, i ), 0.0, 'returns expected value' );
 			continue;
 		}
 		t.strictEqual( powm1( 0.0, i ), -1.0, 'returns -1' );
diff --git a/lib/node_modules/@stdlib/math/base/special/powm1/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/powm1/test/test.native.js
index 5060862bce2f..32fa85d684a8 100644
--- a/lib/node_modules/@stdlib/math/base/special/powm1/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/powm1/test/test.native.js
@@ -61,7 +61,7 @@ tape( 'if provided an exponent.strictEqual to `0`, the function returns `0`', op
 	var i;
 	for ( i = -100; i < 100; i++ ) {
 		t.strictEqual( powm1( i, 0.0 ), 0.0, 'returns -1' );
-		t.strictEqual( powm1( ( randu()*10.0 ) - 5.0, 0.0 ), 0.0, 'returns 0' );
+		t.strictEqual( powm1( ( randu()*10.0 ) - 5.0, 0.0 ), 0.0, 'returns expected value' );
 	}
 	t.end();
 });
@@ -70,7 +70,7 @@ tape( 'if provided a base equal to `0`, the function returns `-1` (except when t
 	var i;
 	for ( i = -100; i < 100; i++ ) {
 		if ( i === 0 ) {
-			t.strictEqual( powm1( 0.0, i ), 0.0, 'returns 0' );
+			t.strictEqual( powm1( 0.0, i ), 0.0, 'returns expected value' );
 			continue;
 		}
 		t.strictEqual( powm1( 0.0, i ), -1.0, 'returns -1' );
diff --git a/lib/node_modules/@stdlib/math/base/special/sici/test/test.main.js b/lib/node_modules/@stdlib/math/base/special/sici/test/test.main.js
index 99080aae05d8..ae6a28af7c65 100644
--- a/lib/node_modules/@stdlib/math/base/special/sici/test/test.main.js
+++ b/lib/node_modules/@stdlib/math/base/special/sici/test/test.main.js
@@ -241,7 +241,7 @@ tape( 'the function computes the sine and cosine integrals for very large positi
 
 tape( 'the function returns `[0,-Infinity]` if provided `0`', function test( t ) {
 	var val = sici( 0.0 );
-	t.strictEqual( isArray( val ), true, 'returns an array' );
+	t.strictEqual( isArray( val ), true, 'returns expected value' );
 	t.strictEqual( val[ 0 ], 0.0, 'returns expected value' );
 	t.strictEqual( val[ 1 ], NINF, 'returns expected value' );
 	t.end();
@@ -249,7 +249,7 @@ tape( 'the function returns `[0,-Infinity]` if provided `0`', function test( t )
 
 tape( 'the function returns `[-PI/2,NaN]` if provided `-Infinity`', function test( t ) {
 	var val = sici( NINF );
-	t.strictEqual( isArray( val ), true, 'returns an array' );
+	t.strictEqual( isArray( val ), true, 'returns expected value' );
 	t.strictEqual( val[ 0 ], -HALF_PI, 'returns expected value' );
 	t.strictEqual( isnan( val[ 1 ] ), true, 'returns expected value' );
 	t.end();
@@ -257,7 +257,7 @@ tape( 'the function returns `[-PI/2,NaN]` if provided `-Infinity`', function tes
 
 tape( 'the function returns `[PI/2,0]` if provided `+Infinity`', function test( t ) {
 	var val = sici( PINF );
-	t.strictEqual( isArray( val ), true, 'returns an array' );
+	t.strictEqual( isArray( val ), true, 'returns expected value' );
 	t.strictEqual( val[ 0 ], HALF_PI, 'returns expected value' );
 	t.strictEqual( val[ 1 ], 0, 'returns expected value' );
 	t.end();
@@ -265,7 +265,7 @@ tape( 'the function returns `[PI/2,0]` if provided `+Infinity`', function test(
 
 tape( 'the function returns `[NaN,NaN]` if provided `NaN`', function test( t ) {
 	var val = sici( NaN );
-	t.strictEqual( isArray( val ), true, 'returns an array' );
+	t.strictEqual( isArray( val ), true, 'returns expected value' );
 	t.strictEqual( isnan( val[ 0 ] ), true, 'returns expected value' );
 	t.strictEqual( isnan( val[ 1 ] ), true, 'returns expected value' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.js
index b5d07e3f2c99..28658d3b20df 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/even-integers/test/test.js
@@ -118,7 +118,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 			expected = j;
 		}
 		t.strictEqual( actual.value, expected, 'returns expected value' );
-		t.strictEqual( isInteger( actual.value ), true, 'returns an integer' );
+		t.strictEqual( isInteger( actual.value ), true, 'returns expected value' );
 		t.strictEqual( isEven( actual.value ), true, 'returns an even integer' );
 		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.js
index 00bc82bd7f7a..4386342d4557 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/integers/test/test.js
@@ -118,7 +118,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 			expected = j;
 		}
 		t.strictEqual( actual.value, expected, 'returns expected value' );
-		t.strictEqual( isInteger( actual.value ), true, 'returns an integer' );
+		t.strictEqual( isInteger( actual.value ), true, 'returns expected value' );
 		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.js b/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.js
index 876f62cdea9d..a68280ee8b20 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/odd-integers/test/test.js
@@ -117,7 +117,7 @@ tape( 'the function returns an iterator protocol-compliant object which generate
 			expected = -j;
 		}
 		t.strictEqual( actual.value, expected, 'returns expected value' );
-		t.strictEqual( isInteger( actual.value ), true, 'returns an integer' );
+		t.strictEqual( isInteger( actual.value ), true, 'returns expected value' );
 		t.strictEqual( isOdd( actual.value ), true, 'returns an odd integer' );
 		t.strictEqual( actual.done, false, 'returns expected value' );
 	}
diff --git a/lib/node_modules/@stdlib/namespace/test/test.js b/lib/node_modules/@stdlib/namespace/test/test.js
index bc30a8e1be01..2b8c61640e50 100644
--- a/lib/node_modules/@stdlib/namespace/test/test.js
+++ b/lib/node_modules/@stdlib/namespace/test/test.js
@@ -38,10 +38,10 @@ tape( 'the function returns the standard library namespace', function test( t )
 	var ns2;
 
 	ns1 = namespace();
-	t.strictEqual( isPlainObjectArray( ns1 ), true, 'returns an object array' );
+	t.strictEqual( isPlainObjectArray( ns1 ), true, 'returns expected value' );
 
 	ns2 = namespace();
-	t.strictEqual( isPlainObjectArray( ns2 ), true, 'returns an object array' );
+	t.strictEqual( isPlainObjectArray( ns2 ), true, 'returns expected value' );
 
 	t.notEqual( ns1, ns2, 'returns new reference' );
 	t.notEqual( ns1[ 0 ], ns2[ 0 ], 'contains different references' );
diff --git a/lib/node_modules/@stdlib/ndarray/base/ctor/test/test.js b/lib/node_modules/@stdlib/ndarray/base/ctor/test/test.js
index c1d694acd5ef..26831014f0d9 100644
--- a/lib/node_modules/@stdlib/ndarray/base/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/base/ctor/test/test.js
@@ -79,7 +79,7 @@ tape( 'the function is an ndarray constructor', function test( t ) {
 
 	arr = new ndarray( dtype, buffer, shape, strides, offset, order );
 
-	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -101,7 +101,7 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 
 	arr = ndarray( dtype, buffer, shape, strides, offset, order );
 
-	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -123,7 +123,7 @@ tape( 'the function supports creating zero-dimensional ndarrays', function test(
 
 	arr = new ndarray( dtype, buffer, shape, strides, offset, order );
 
-	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/ndarray/base/ind2sub/test/test.js b/lib/node_modules/@stdlib/ndarray/base/ind2sub/test/test.js
index 9cfedd3bc81c..e557506090b4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/ind2sub/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/base/ind2sub/test/test.js
@@ -47,7 +47,7 @@ tape( 'the function converts a linear index to an array of subscripts (0d; order
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [], 'returns expected value' );
 
 	t.end();
@@ -66,7 +66,7 @@ tape( 'the function converts a linear index to an array of subscripts (0d; order
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [], 'returns expected value' );
 
 	t.end();
@@ -85,11 +85,11 @@ tape( 'the function converts a linear index to an array of subscripts (1d; order
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1 ], 'returns expected value' );
 
 	t.end();
@@ -108,11 +108,11 @@ tape( 'the function converts a linear index to an array of subscripts (1d; order
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1 ], 'returns expected value' );
 
 	t.end();
@@ -131,19 +131,19 @@ tape( 'the function converts a linear index to an array of subscripts (2d; order
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -162,19 +162,19 @@ tape( 'the function converts a linear index to an array of subscripts (2d; order
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -193,35 +193,35 @@ tape( 'the function converts a linear index to an array of subscripts (3d; order
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 4, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 5, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 6, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 7, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -240,35 +240,35 @@ tape( 'the function converts a linear index to an array of subscripts (3d; order
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 4, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 5, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 6, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 7, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -287,35 +287,35 @@ tape( 'the function converts a linear index to an array of subscripts (3d; order
 	offset = 2;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 4, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 5, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 6, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 7, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0, 1 ], 'returns expected value' );
 
 	t.end();
@@ -334,19 +334,19 @@ tape( 'the function converts a linear index to an array of subscripts (negative
 	offset = 2;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	t.end();
@@ -365,19 +365,19 @@ tape( 'the function converts a linear index to an array of subscripts (negative
 	offset = 2;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	t.end();
@@ -396,19 +396,19 @@ tape( 'the function converts a linear index to an array of subscripts (negative
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -427,19 +427,19 @@ tape( 'the function converts a linear index to an array of subscripts (negative
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -458,19 +458,19 @@ tape( 'the function converts a linear index to an array of subscripts (negative
 	offset = 1;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	t.end();
@@ -489,19 +489,19 @@ tape( 'the function converts a linear index to an array of subscripts (negative
 	offset = 1;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	t.end();
@@ -520,19 +520,19 @@ tape( 'the function converts a linear index to an array of subscripts (negative
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -551,19 +551,19 @@ tape( 'the function converts a linear index to an array of subscripts (negative
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -582,19 +582,19 @@ tape( 'the function converts a linear index to an array of subscripts (negative
 	offset = 3;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	t.end();
@@ -613,19 +613,19 @@ tape( 'the function converts a linear index to an array of subscripts (negative
 	offset = 3;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	t.end();
@@ -644,19 +644,19 @@ tape( 'the function converts a linear index to an array of subscripts (negative
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -675,19 +675,19 @@ tape( 'the function converts a linear index to an array of subscripts (negative
 	offset = 0;
 
 	out = ind2sub( shape, strides, offset, order, 0, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 1, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 0 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 2, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 0, 1 ], 'returns expected value' );
 
 	out = ind2sub( shape, strides, offset, order, 3, 'throw' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, [ 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -708,25 +708,25 @@ tape( 'attached to the main function is a method which supports providing an out
 
 	out = [ 0, 0 ];
 	actual = ind2sub.assign( shape, strides, offset, order, 0, 'throw', out );
-	t.strictEqual( isArray( actual ), true, 'returns an array' );
+	t.strictEqual( isArray( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, out, 'returns output array' );
 	t.deepEqual( actual, [ 0, 0 ], 'returns expected value' );
 
 	out = [ 0, 0 ];
 	actual = ind2sub.assign( shape, strides, offset, order, 1, 'throw', out );
-	t.strictEqual( isArray( actual ), true, 'returns an array' );
+	t.strictEqual( isArray( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, out, 'returns output array' );
 	t.deepEqual( actual, [ 0, 1 ], 'returns expected value' );
 
 	out = [ 0, 0 ];
 	actual = ind2sub.assign( shape, strides, offset, order, 2, 'throw', out );
-	t.strictEqual( isArray( actual ), true, 'returns an array' );
+	t.strictEqual( isArray( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, out, 'returns output array' );
 	t.deepEqual( actual, [ 1, 0 ], 'returns expected value' );
 
 	out = [ 0, 0 ];
 	actual = ind2sub.assign( shape, strides, offset, order, 3, 'throw', out );
-	t.strictEqual( isArray( actual ), true, 'returns an array' );
+	t.strictEqual( isArray( actual ), true, 'returns expected value' );
 	t.strictEqual( actual, out, 'returns output array' );
 	t.deepEqual( actual, [ 1, 1 ], 'returns expected value' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/base/minmax-view-buffer-index/test/test.js b/lib/node_modules/@stdlib/ndarray/base/minmax-view-buffer-index/test/test.js
index 55d873e09bc9..238c50768c02 100644
--- a/lib/node_modules/@stdlib/ndarray/base/minmax-view-buffer-index/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/base/minmax-view-buffer-index/test/test.js
@@ -44,56 +44,56 @@ tape( 'the function computes the minimum and maximum linear indices in an underl
 	strides = [ 2, 1 ];
 	offset = 0;
 	idx = minmaxViewBufferIndex( shape, strides, offset );
-	t.strictEqual( isArray( idx ), true, 'returns an array' );
+	t.strictEqual( isArray( idx ), true, 'returns expected value' );
 	t.strictEqual( idx[ 0 ], 0, 'returns expected value' );
 	t.strictEqual( idx[ 1 ], 5, 'returns expected value' );
 
 	strides = [ -2, 1 ];
 	offset = 4;
 	idx = minmaxViewBufferIndex( shape, strides, offset );
-	t.strictEqual( isArray( idx ), true, 'returns an array' );
+	t.strictEqual( isArray( idx ), true, 'returns expected value' );
 	t.strictEqual( idx[ 0 ], 0, 'returns expected value' );
 	t.strictEqual( idx[ 1 ], 5, 'returns expected value' );
 
 	strides = [ 2, -1 ];
 	offset = 1;
 	idx = minmaxViewBufferIndex( shape, strides, offset );
-	t.strictEqual( isArray( idx ), true, 'returns an array' );
+	t.strictEqual( isArray( idx ), true, 'returns expected value' );
 	t.strictEqual( idx[ 0 ], 0, 'returns expected value' );
 	t.strictEqual( idx[ 1 ], 5, 'returns expected value' );
 
 	strides = [ -2, -1 ];
 	offset = 5;
 	idx = minmaxViewBufferIndex( shape, strides, offset );
-	t.strictEqual( isArray( idx ), true, 'returns an array' );
+	t.strictEqual( isArray( idx ), true, 'returns expected value' );
 	t.strictEqual( idx[ 0 ], 0, 'returns expected value' );
 	t.strictEqual( idx[ 1 ], 5, 'returns expected value' );
 
 	strides = [ 1, 3 ];
 	offset = 0;
 	idx = minmaxViewBufferIndex( shape, strides, offset );
-	t.strictEqual( isArray( idx ), true, 'returns an array' );
+	t.strictEqual( isArray( idx ), true, 'returns expected value' );
 	t.strictEqual( idx[ 0 ], 0, 'returns expected value' );
 	t.strictEqual( idx[ 1 ], 5, 'returns expected value' );
 
 	strides = [ -1, 3 ];
 	offset = 2;
 	idx = minmaxViewBufferIndex( shape, strides, offset );
-	t.strictEqual( isArray( idx ), true, 'returns an array' );
+	t.strictEqual( isArray( idx ), true, 'returns expected value' );
 	t.strictEqual( idx[ 0 ], 0, 'returns expected value' );
 	t.strictEqual( idx[ 1 ], 5, 'returns expected value' );
 
 	strides = [ 1, -3 ];
 	offset = 3;
 	idx = minmaxViewBufferIndex( shape, strides, offset );
-	t.strictEqual( isArray( idx ), true, 'returns an array' );
+	t.strictEqual( isArray( idx ), true, 'returns expected value' );
 	t.strictEqual( idx[ 0 ], 0, 'returns expected value' );
 	t.strictEqual( idx[ 1 ], 5, 'returns expected value' );
 
 	strides = [ -1, -3 ];
 	offset = 5;
 	idx = minmaxViewBufferIndex( shape, strides, offset );
-	t.strictEqual( isArray( idx ), true, 'returns an array' );
+	t.strictEqual( isArray( idx ), true, 'returns expected value' );
 	t.strictEqual( idx[ 0 ], 0, 'returns expected value' );
 	t.strictEqual( idx[ 1 ], 5, 'returns expected value' );
 
@@ -103,14 +103,14 @@ tape( 'the function computes the minimum and maximum linear indices in an underl
 	strides = [ 30, 10, 1 ];
 	offset = 0;
 	idx = minmaxViewBufferIndex( shape, strides, offset );
-	t.strictEqual( isArray( idx ), true, 'returns an array' );
+	t.strictEqual( isArray( idx ), true, 'returns expected value' );
 	t.strictEqual( idx[ 0 ], 0, 'returns expected value' );
 	t.strictEqual( idx[ 1 ], 59, 'returns expected value' );
 
 	strides = [ 30, -10, 1 ];
 	offset = 20;
 	idx = minmaxViewBufferIndex( shape, strides, offset );
-	t.strictEqual( isArray( idx ), true, 'returns an array' );
+	t.strictEqual( isArray( idx ), true, 'returns expected value' );
 	t.strictEqual( idx[ 0 ], 0, 'returns expected value' );
 	t.strictEqual( idx[ 1 ], 59, 'returns expected value' );
 
@@ -328,7 +328,7 @@ tape( 'the function computes the minimum and maximum linear indices in an underl
 	offset = 10;
 
 	idx = minmaxViewBufferIndex( shape, strides, offset );
-	t.strictEqual( isArray( idx ), true, 'returns an array' );
+	t.strictEqual( isArray( idx ), true, 'returns expected value' );
 	t.strictEqual( idx[ 0 ], 10, 'returns expected value' );
 	t.strictEqual( idx[ 1 ], 10, 'returns expected value' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/base/numel/test/test.js b/lib/node_modules/@stdlib/ndarray/base/numel/test/test.js
index f4ba0410daf5..bd0ca89513ff 100644
--- a/lib/node_modules/@stdlib/ndarray/base/numel/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/base/numel/test/test.js
@@ -33,7 +33,7 @@ tape( 'main export is a function', function test( t ) {
 });
 
 tape( 'if provided an empty array, the function returns 0', function test( t ) {
-	t.strictEqual( numel( [] ), 0, 'returns 0' );
+	t.strictEqual( numel( [] ), 0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/ndarray/base/shape2strides/test/test.js b/lib/node_modules/@stdlib/ndarray/base/shape2strides/test/test.js
index be27cc583631..a5444bd63845 100644
--- a/lib/node_modules/@stdlib/ndarray/base/shape2strides/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/base/shape2strides/test/test.js
@@ -42,7 +42,7 @@ tape( 'the function generates a stride array from an array shape (row-major)', f
 	expected = [ 2, 1 ];
 	actual = shape2strides( shape, 'row-major' );
 
-	t.strictEqual( isArray( actual ), true, 'returns an array' );
+	t.strictEqual( isArray( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.length, shape.length, 'returns expected length' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 
@@ -50,7 +50,7 @@ tape( 'the function generates a stride array from an array shape (row-major)', f
 	expected = [ 10, 10, 1 ];
 	actual = shape2strides( shape, 'row-major' );
 
-	t.strictEqual( isArray( actual ), true, 'returns an array' );
+	t.strictEqual( isArray( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.length, shape.length, 'returns expected length' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 
@@ -66,7 +66,7 @@ tape( 'the function generates a stride array from an array shape (column-major)'
 	expected = [ 1, 3 ];
 	actual = shape2strides( shape, 'column-major' );
 
-	t.strictEqual( isArray( actual ), true, 'returns an array' );
+	t.strictEqual( isArray( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.length, shape.length, 'returns expected length' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 
@@ -74,7 +74,7 @@ tape( 'the function generates a stride array from an array shape (column-major)'
 	expected = [ 1, 2, 2 ];
 	actual = shape2strides( shape, 'column-major' );
 
-	t.strictEqual( isArray( actual ), true, 'returns an array' );
+	t.strictEqual( isArray( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.length, shape.length, 'returns expected length' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 
@@ -90,7 +90,8 @@ tape( 'attached to the main function is a method which supports generating a str
 	shape = [ 3, 2 ];
 	expected = [ 2, 1 ];
 
-	out = new Array( shape.length );
+	out = [];
+	out.length = shape.length;
 	actual = shape2strides.assign( shape, 'row-major', out );
 
 	t.strictEqual( actual, out, 'returns output array' );
@@ -100,7 +101,8 @@ tape( 'attached to the main function is a method which supports generating a str
 	shape = [ 2, 1, 10 ];
 	expected = [ 10, 10, 1 ];
 
-	out = new Array( shape.length );
+	out = [];
+	out.length = shape.length;
 	actual = shape2strides.assign( shape, 'row-major', out );
 
 	t.strictEqual( actual, out, 'returns output array' );
@@ -119,7 +121,8 @@ tape( 'attached to the main function is a method which supports generating a str
 	shape = [ 3, 2 ];
 	expected = [ 1, 3 ];
 
-	out = new Array( shape.length );
+	out = [];
+	out.length = shape.length;
 	actual = shape2strides.assign( shape, 'column-major', out );
 
 	t.strictEqual( actual, out, 'returns output array' );
@@ -129,7 +132,8 @@ tape( 'attached to the main function is a method which supports generating a str
 	shape = [ 2, 1, 10 ];
 	expected = [ 1, 2, 2 ];
 
-	out = new Array( shape.length );
+	out = [];
+	out.length = shape.length;
 	actual = shape2strides.assign( shape, 'column-major', out );
 
 	t.strictEqual( actual, out, 'returns output array' );
diff --git a/lib/node_modules/@stdlib/ndarray/base/to-array/test/test.js b/lib/node_modules/@stdlib/ndarray/base/to-array/test/test.js
index 29fdfe40605b..50400286d0ee 100644
--- a/lib/node_modules/@stdlib/ndarray/base/to-array/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/base/to-array/test/test.js
@@ -38,15 +38,15 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an empty array if provided an empty buffer/shape', function test( t ) {
 	var out = ndarray2array( [], [], [], 0, 'row-major' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
-	t.strictEqual( out.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
+	t.strictEqual( out.length, 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns an empty array if provided a dimension which has zero elements', function test( t ) {
 	var out = ndarray2array( [ 1, 2, 3, 4 ], [ 2, 0 ], [ 0, 0 ], 0, 'row-major' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
-	t.strictEqual( out.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
+	t.strictEqual( out.length, 0, 'returns expected value' );
 	t.end();
 });
 
@@ -68,7 +68,7 @@ tape( 'the function converts an ndarray buffer to a generic array (1d; order=row
 
 	out = ndarray2array( buffer, shape, strides, offset, order );
 	expected = [ 1, 2, 3, 4, 5, 6 ];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	t.end();
@@ -91,7 +91,7 @@ tape( 'the function converts an ndarray buffer to a generic array (1d; order=row
 	offset = 2;
 
 	out = ndarray2array( buffer, shape, strides, offset, order );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 
 	v = out[ 0 ];
 	t.strictEqual( realf( v ), 5.0, 'returns expected value' );
@@ -126,7 +126,7 @@ tape( 'the function converts an ndarray buffer to a generic array (1d; order=col
 
 	out = ndarray2array( buffer, shape, strides, offset, order );
 	expected = [ 6, 5, 4, 3, 2, 1 ];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	t.end();
@@ -149,7 +149,7 @@ tape( 'the function converts an ndarray buffer to a generic array (1d; order=col
 	offset = 0;
 
 	out = ndarray2array( buffer, shape, strides, offset, order );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 
 	v = out[ 0 ];
 	t.strictEqual( realf( v ), 1.0, 'returns expected value' );
@@ -188,7 +188,7 @@ tape( 'the function converts an ndarray buffer to a generic array (2d; order=row
 		[ 3, 4 ],
 		[ 5, 6 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ -2, 1 ];
@@ -200,7 +200,7 @@ tape( 'the function converts an ndarray buffer to a generic array (2d; order=row
 		[ 3, 4 ],
 		[ 1, 2 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ 2, -1 ];
@@ -212,7 +212,7 @@ tape( 'the function converts an ndarray buffer to a generic array (2d; order=row
 		[ 4, 3 ],
 		[ 6, 5 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ -2, -1 ];
@@ -224,7 +224,7 @@ tape( 'the function converts an ndarray buffer to a generic array (2d; order=row
 		[ 4, 3 ],
 		[ 2, 1 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	t.end();
@@ -252,7 +252,7 @@ tape( 'the function converts an ndarray buffer to a generic array (2d; order=col
 		[ 2, 5 ],
 		[ 3, 6 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ -1, 3 ];
@@ -264,7 +264,7 @@ tape( 'the function converts an ndarray buffer to a generic array (2d; order=col
 		[ 2, 5 ],
 		[ 1, 4 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ 1, -3 ];
@@ -276,7 +276,7 @@ tape( 'the function converts an ndarray buffer to a generic array (2d; order=col
 		[ 5, 2 ],
 		[ 6, 3 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ -1, -3 ];
@@ -288,7 +288,7 @@ tape( 'the function converts an ndarray buffer to a generic array (2d; order=col
 		[ 5, 2 ],
 		[ 4, 1 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	t.end();
@@ -315,7 +315,7 @@ tape( 'the function converts an ndarray buffer to a generic array (3d; order=row
 		[ [ 1, 2 ], [ 3, 4 ] ],
 		[ [ 5, 6 ], [ 7, 8 ] ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ -4, -2, -1 ];
@@ -326,7 +326,7 @@ tape( 'the function converts an ndarray buffer to a generic array (3d; order=row
 		[ [ 8, 7 ], [ 6, 5 ] ],
 		[ [ 4, 3 ], [ 2, 1 ] ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	t.end();
@@ -353,7 +353,7 @@ tape( 'the function converts an ndarray buffer to a generic array (3d; order=col
 		[ [ 1, 5 ], [ 3, 7 ] ],
 		[ [ 2, 6 ], [ 4, 8 ] ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ -1, -2, -4 ];
@@ -364,7 +364,7 @@ tape( 'the function converts an ndarray buffer to a generic array (3d; order=col
 		[ [ 8, 4 ], [ 6, 2 ] ],
 		[ [ 7, 3 ], [ 5, 1 ] ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/ndarray/ctor/test/test.copy_array.js b/lib/node_modules/@stdlib/ndarray/ctor/test/test.copy_array.js
index 5efc6fc2b923..8dc47d36abe3 100644
--- a/lib/node_modules/@stdlib/ndarray/ctor/test/test.copy_array.js
+++ b/lib/node_modules/@stdlib/ndarray/ctor/test/test.copy_array.js
@@ -40,7 +40,7 @@ tape( 'the function copies the elements of an array-like input value and returns
 	arr = [ 1.0, 2.0, 3.0 ];
 	out = copy( arr, arr.length );
 
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.notEqual( out, arr, 'returns a new instance' );
 	t.deepEqual( arr, out, 'returns expected value' );
 
@@ -58,7 +58,7 @@ tape( 'the function copies the elements of an array-like input value and returns
 	}
 	out = copy( arr, arr.length );
 
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.notEqual( out, arr, 'returns a new instance' );
 	t.deepEqual( arr, out, 'returns expected value' );
 
diff --git a/lib/node_modules/@stdlib/ndarray/ctor/test/test.js b/lib/node_modules/@stdlib/ndarray/ctor/test/test.js
index 5cfc65ac6648..686ffe83ce97 100644
--- a/lib/node_modules/@stdlib/ndarray/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/ctor/test/test.js
@@ -52,7 +52,7 @@ tape( 'the function is an ndarray constructor', function test( t ) {
 
 	arr = new ndarray( dtype, buffer, shape, strides, offset, order );
 
-	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -74,7 +74,7 @@ tape( 'the function is an ndarray constructor (complex dtype)', function test( t
 
 	arr = new ndarray( dtype, buffer, shape, strides, offset, order );
 
-	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -96,7 +96,7 @@ tape( 'the function is an ndarray constructor (0d)', function test( t ) {
 
 	arr = new ndarray( dtype, buffer, shape, strides, offset, order );
 
-	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -118,7 +118,7 @@ tape( 'the function is an ndarray constructor (0d; complex dtype)', function tes
 
 	arr = new ndarray( dtype, buffer, shape, strides, offset, order );
 
-	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -140,7 +140,7 @@ tape( 'the function is an ndarray constructor (options)', function test( t ) {
 
 	arr = new ndarray( dtype, buffer, shape, strides, offset, order, {} );
 
-	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -162,7 +162,7 @@ tape( 'the function is an ndarray constructor (0d; options)', function test( t )
 
 	arr = new ndarray( dtype, buffer, shape, strides, offset, order, {} );
 
-	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -184,7 +184,7 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 
 	arr = ndarray( dtype, buffer, shape, strides, offset, order );
 
-	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -206,6 +206,6 @@ tape( 'the constructor does not require the `new` keyword (options)', function t
 
 	arr = ndarray( dtype, buffer, shape, strides, offset, order, {} );
 
-	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, ndarray ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/fancy/test/test.js b/lib/node_modules/@stdlib/ndarray/fancy/test/test.js
index 3962ccc757aa..12332dbb5a6e 100644
--- a/lib/node_modules/@stdlib/ndarray/fancy/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/fancy/test/test.js
@@ -52,7 +52,7 @@ tape( 'the function is a constructor', function test( t ) {
 
 	arr = new FancyArray( dtype, buffer, shape, strides, offset, order );
 
-	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -74,7 +74,7 @@ tape( 'the function is a constructor (complex dtype)', function test( t ) {
 
 	arr = new FancyArray( dtype, buffer, shape, strides, offset, order );
 
-	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -96,7 +96,7 @@ tape( 'the function is a constructor (0d)', function test( t ) {
 
 	arr = new FancyArray( dtype, buffer, shape, strides, offset, order );
 
-	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -118,7 +118,7 @@ tape( 'the function is a constructor (0d; complex dtype)', function test( t ) {
 
 	arr = new FancyArray( dtype, buffer, shape, strides, offset, order );
 
-	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -140,7 +140,7 @@ tape( 'the function is a constructor (options)', function test( t ) {
 
 	arr = new FancyArray( dtype, buffer, shape, strides, offset, order, {} );
 
-	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -162,7 +162,7 @@ tape( 'the function is a constructor (0d; options)', function test( t ) {
 
 	arr = new FancyArray( dtype, buffer, shape, strides, offset, order, {} );
 
-	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -186,7 +186,7 @@ tape( 'the constructor does not require the `new` keyword', function test( t ) {
 	ndarray = FancyArray;
 	arr = ndarray( dtype, buffer, shape, strides, offset, order );
 
-	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns expected value' );
 	t.end();
 });
 
@@ -210,6 +210,6 @@ tape( 'the constructor does not require the `new` keyword (options)', function t
 	ndarray = FancyArray;
 	arr = ndarray( dtype, buffer, shape, strides, offset, order, {} );
 
-	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( arr, FancyArray ), true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/ind2sub/test/test.main.js b/lib/node_modules/@stdlib/ndarray/ind2sub/test/test.main.js
index 49f5ad7c1efe..3b391b0e8931 100644
--- a/lib/node_modules/@stdlib/ndarray/ind2sub/test/test.main.js
+++ b/lib/node_modules/@stdlib/ndarray/ind2sub/test/test.main.js
@@ -227,19 +227,19 @@ tape( 'the function converts a linear index to an array of subscripts (2d)', fun
 	shape = [ 2, 2 ];
 
 	s = ind2sub( shape, 0 );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 0, 0 ], 'returns expected value' );
 
 	s = ind2sub( shape, 1 );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 0, 1 ], 'returns expected value' );
 
 	s = ind2sub( shape, 2 );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 1, 0 ], 'returns expected value' );
 
 	s = ind2sub( shape, 3 );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -256,19 +256,19 @@ tape( 'the function converts a linear index to an array of subscripts (2d; order
 	};
 
 	s = ind2sub( shape, 0, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 0, 0 ], 'returns expected value' );
 
 	s = ind2sub( shape, 1, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 0, 1 ], 'returns expected value' );
 
 	s = ind2sub( shape, 2, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 1, 0 ], 'returns expected value' );
 
 	s = ind2sub( shape, 3, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -285,19 +285,19 @@ tape( 'the function converts a linear index to an array of subscripts (2d; order
 	};
 
 	s = ind2sub( shape, 0, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 0, 0 ], 'returns expected value' );
 
 	s = ind2sub( shape, 1, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 1, 0 ], 'returns expected value' );
 
 	s = ind2sub( shape, 2, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 0, 1 ], 'returns expected value' );
 
 	s = ind2sub( shape, 3, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -310,7 +310,7 @@ tape( 'the function converts a linear index to an array of subscripts (3d)', fun
 	shape = [ 3, 3, 3 ];
 
 	s = ind2sub( shape, 17 );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 1, 2, 2 ], 'returns expected value' );
 
 	t.end();
@@ -327,7 +327,7 @@ tape( 'the function converts a linear index to an array of subscripts (3d; order
 	};
 
 	s = ind2sub( shape, 17, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 1, 2, 2 ], 'returns expected value' );
 
 	t.end();
@@ -344,7 +344,7 @@ tape( 'the function converts a linear index to an array of subscripts (3d; order
 	};
 
 	s = ind2sub( shape, 17, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 2, 2, 1 ], 'returns expected value' );
 
 	t.end();
@@ -361,19 +361,19 @@ tape( 'the function converts a linear index to an array of subscripts (order=row
 	};
 
 	s = ind2sub( shape, 0, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 0, 0 ], 'returns expected value' );
 
 	s = ind2sub( shape, 1, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 0, 1 ], 'returns expected value' );
 
 	s = ind2sub( shape, 2, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 1, 0 ], 'returns expected value' );
 
 	s = ind2sub( shape, 3, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 1, 1 ], 'returns expected value' );
 
 	t.end();
@@ -390,19 +390,19 @@ tape( 'the function converts a linear index to an array of subscripts (order=col
 	};
 
 	s = ind2sub( shape, 0, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 0, 0 ], 'returns expected value' );
 
 	s = ind2sub( shape, 1, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 1, 0 ], 'returns expected value' );
 
 	s = ind2sub( shape, 2, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 0, 1 ], 'returns expected value' );
 
 	s = ind2sub( shape, 3, opts );
-	t.strictEqual( isArray( s ), true, 'returns an array' );
+	t.strictEqual( isArray( s ), true, 'returns expected value' );
 	t.deepEqual( s, [ 1, 1 ], 'returns expected value' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/ndarray/to-array/test/test.js b/lib/node_modules/@stdlib/ndarray/to-array/test/test.js
index c657e6d0d6bc..3b38de0cc0ce 100644
--- a/lib/node_modules/@stdlib/ndarray/to-array/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/to-array/test/test.js
@@ -72,8 +72,8 @@ tape( 'the function returns an empty array if provided an ndarray', function tes
 	arr = ndarray( 'generic', [], [], [ 0 ], 0, 'row-major' );
 	out = ndarray2array( arr );
 
-	t.strictEqual( isArray( out ), true, 'returns an array' );
-	t.strictEqual( out.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
+	t.strictEqual( out.length, 0, 'returns expected value' );
 	t.end();
 });
 
@@ -84,8 +84,8 @@ tape( 'the function returns an empty array if provided an ndarray having one or
 	arr = ndarray( 'generic', [ 1, 2, 3, 4 ], [ 2, 0 ], [ 0, 0 ], 0, 'row-major' );
 	out = ndarray2array( arr );
 
-	t.strictEqual( isArray( out ), true, 'returns an array' );
-	t.strictEqual( out.length, 0, 'returns an empty array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
+	t.strictEqual( out.length, 0, 'returns expected value' );
 	t.end();
 });
 
@@ -110,7 +110,7 @@ tape( 'the function converts an ndarray to a generic array (1d; order=row-major)
 	out = ndarray2array( arr );
 
 	expected = [ 1, 2, 3, 4, 5, 6 ];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	t.end();
@@ -136,7 +136,7 @@ tape( 'the function converts an ndarray to a generic array (1d; order=row-major;
 	arr = ndarray( 'complex64', buffer, shape, strides, offset, order );
 	out = ndarray2array( arr );
 
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 
 	v = out[ 0 ];
 	t.strictEqual( realf( v ), 5.0, 'returns expected value' );
@@ -174,7 +174,7 @@ tape( 'the function converts an ndarray to a generic array (1d; order=column-maj
 	out = ndarray2array( arr );
 
 	expected = [ 6, 5, 4, 3, 2, 1 ];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	t.end();
@@ -200,7 +200,7 @@ tape( 'the function converts an ndarray to a generic array (1d; order=column-maj
 	arr = ndarray( 'complex64', buffer, shape, strides, offset, order );
 	out = ndarray2array( arr );
 
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 
 	v = out[ 0 ];
 	t.strictEqual( realf( v ), 1.0, 'returns expected value' );
@@ -242,7 +242,7 @@ tape( 'the function converts an ndarray to a generic array (2d; order=row-major)
 		[ 3, 4 ],
 		[ 5, 6 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ -2, 1 ];
@@ -256,7 +256,7 @@ tape( 'the function converts an ndarray to a generic array (2d; order=row-major)
 		[ 3, 4 ],
 		[ 1, 2 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ 2, -1 ];
@@ -270,7 +270,7 @@ tape( 'the function converts an ndarray to a generic array (2d; order=row-major)
 		[ 4, 3 ],
 		[ 6, 5 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ -2, -1 ];
@@ -284,7 +284,7 @@ tape( 'the function converts an ndarray to a generic array (2d; order=row-major)
 		[ 4, 3 ],
 		[ 2, 1 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	t.end();
@@ -315,7 +315,7 @@ tape( 'the function converts an ndarray to a generic array (2d; order=column-maj
 		[ 2, 5 ],
 		[ 3, 6 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ -1, 3 ];
@@ -329,7 +329,7 @@ tape( 'the function converts an ndarray to a generic array (2d; order=column-maj
 		[ 2, 5 ],
 		[ 1, 4 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ 1, -3 ];
@@ -343,7 +343,7 @@ tape( 'the function converts an ndarray to a generic array (2d; order=column-maj
 		[ 5, 2 ],
 		[ 6, 3 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ -1, -3 ];
@@ -357,7 +357,7 @@ tape( 'the function converts an ndarray to a generic array (2d; order=column-maj
 		[ 5, 2 ],
 		[ 4, 1 ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	t.end();
@@ -387,7 +387,7 @@ tape( 'the function converts an ndarray to a generic array (3d; order=row-major)
 		[ [ 1, 2 ], [ 3, 4 ] ],
 		[ [ 5, 6 ], [ 7, 8 ] ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ -4, -2, -1 ];
@@ -400,7 +400,7 @@ tape( 'the function converts an ndarray to a generic array (3d; order=row-major)
 		[ [ 8, 7 ], [ 6, 5 ] ],
 		[ [ 4, 3 ], [ 2, 1 ] ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	t.end();
@@ -430,7 +430,7 @@ tape( 'the function converts an ndarray to a generic array (3d; order=column-maj
 		[ [ 1, 5 ], [ 3, 7 ] ],
 		[ [ 2, 6 ], [ 4, 8 ] ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	strides = [ -1, -2, -4 ];
@@ -443,7 +443,7 @@ tape( 'the function converts an ndarray to a generic array (3d; order=column-maj
 		[ [ 8, 4 ], [ 6, 2 ] ],
 		[ [ 7, 3 ], [ 5, 1 ] ]
 	];
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.deepEqual( out, expected, 'returns expected value' );
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/nlp/sentencize/test/test.js b/lib/node_modules/@stdlib/nlp/sentencize/test/test.js
index 20d689d5431d..bde0b39e7022 100644
--- a/lib/node_modules/@stdlib/nlp/sentencize/test/test.js
+++ b/lib/node_modules/@stdlib/nlp/sentencize/test/test.js
@@ -313,7 +313,7 @@ tape( 'the function splits a string into an array of sentences (multiple punctua
 
 tape( 'the function returns an empty array if provided an empty string', function test( t ) {
 	var out = sentencize( '' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 0, 'array length is zero' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/nlp/tokenize/test/test.js b/lib/node_modules/@stdlib/nlp/tokenize/test/test.js
index 9bf578e83079..d336c0a5b2a1 100644
--- a/lib/node_modules/@stdlib/nlp/tokenize/test/test.js
+++ b/lib/node_modules/@stdlib/nlp/tokenize/test/test.js
@@ -281,7 +281,7 @@ tape( 'the function tokenizes a string (preserving whitespace)', function test(
 
 tape( 'the function returns an emptry array if provided an empty string', function test( t ) {
 	var out = tokenize( '' );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 0, 'array length is zero' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/ctor/test/test.js b/lib/node_modules/@stdlib/number/ctor/test/test.js
index e9edf3bad712..7cc65b1f8d26 100644
--- a/lib/node_modules/@stdlib/number/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/number/ctor/test/test.js
@@ -42,7 +42,7 @@ tape( 'the main export is an alias for `Number`', function test( t ) {
 
 tape( 'the main export is a constructor', function test( t ) {
 	var v = new Ctor( 10.0 );
-	t.strictEqual( instanceOf( v, Ctor ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( v, Ctor ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.js b/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.js
index 3a77c59c5c63..f8eef45b6f93 100644
--- a/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.js
@@ -75,7 +75,7 @@ tape( 'if provided a word corresponding to `-0`, the function returns `-0`', fun
 
 	x = fromWordf( word );
 
-	t.strictEqual( isNegativeZero( x ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( x ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.native.js b/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.native.js
index 359dfe1d3ca8..ed614485ebc9 100644
--- a/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float32/base/from-word/test/test.native.js
@@ -84,7 +84,7 @@ tape( 'if provided a word corresponding to `-0`, the function returns `-0`', opt
 
 	x = fromWordf( word );
 
-	t.strictEqual( isNegativeZero( x ), true, 'returns -0' );
+	t.strictEqual( isNegativeZero( x ), true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/significand/test/test.js b/lib/node_modules/@stdlib/number/float32/base/significand/test/test.js
index f536f50ea121..f831c53b2dab 100644
--- a/lib/node_modules/@stdlib/number/float32/base/significand/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/significand/test/test.js
@@ -75,18 +75,18 @@ tape( 'the function returns an integer corresponding to the significand of a sin
 });
 
 tape( 'the function returns the significand for `+-0`', function test( t ) {
-	t.strictEqual( significandf( 0.0 ), 0, 'returns 0' );
-	t.strictEqual( significandf( -0.0 ), 0, 'returns 0' );
+	t.strictEqual( significandf( 0.0 ), 0, 'returns expected value' );
+	t.strictEqual( significandf( -0.0 ), 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns the significand for `+infinity`', function test( t ) {
-	t.strictEqual( significandf( PINF ), 0, 'returns 0' );
+	t.strictEqual( significandf( PINF ), 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns the significand for `-infinity`', function test( t ) {
-	t.strictEqual( significandf( NINF ), 0, 'returns 0' );
+	t.strictEqual( significandf( NINF ), 0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/significand/test/test.native.js b/lib/node_modules/@stdlib/number/float32/base/significand/test/test.native.js
index 81fbbe7f31f2..a3ace9b79a7b 100644
--- a/lib/node_modules/@stdlib/number/float32/base/significand/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float32/base/significand/test/test.native.js
@@ -84,18 +84,18 @@ tape( 'the function returns an integer corresponding to the significand of a sin
 });
 
 tape( 'the function returns the significand for `+-0`', opts, function test( t ) {
-	t.strictEqual( significand( 0.0 ), 0, 'returns 0' );
-	t.strictEqual( significand( -0.0 ), 0, 'returns 0' );
+	t.strictEqual( significand( 0.0 ), 0, 'returns expected value' );
+	t.strictEqual( significand( -0.0 ), 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns the significand for `+infinity`', opts, function test( t ) {
-	t.strictEqual( significand( PINF ), 0, 'returns 0' );
+	t.strictEqual( significand( PINF ), 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns the significand for `-infinity`', opts, function test( t ) {
-	t.strictEqual( significand( NINF ), 0, 'returns 0' );
+	t.strictEqual( significand( NINF ), 0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/to-int32/test/test.js b/lib/node_modules/@stdlib/number/float32/base/to-int32/test/test.js
index 0a1e0521ed6f..88b9900ea0e1 100644
--- a/lib/node_modules/@stdlib/number/float32/base/to-int32/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/to-int32/test/test.js
@@ -58,20 +58,20 @@ tape( 'if provided `-0`, the function returns `0`', function test( t ) {
 
 tape( 'if provided `+infinity`, the function returns `0`', function test( t ) {
 	var v = float32ToInt32( PINF );
-	t.strictEqual( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `0`', function test( t ) {
 	var v = float32ToInt32( NINF );
-	t.strictEqual( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `0`', function test( t ) {
 	var v = float32ToInt32( float64ToFloat32( NaN ) );
 	t.strictEqual( isnan( v ), false, 'does not return NaN' );
-	t.strictEqual( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float32/base/to-uint32/test/test.js b/lib/node_modules/@stdlib/number/float32/base/to-uint32/test/test.js
index e8c3667807d4..d03fc69d5b05 100644
--- a/lib/node_modules/@stdlib/number/float32/base/to-uint32/test/test.js
+++ b/lib/node_modules/@stdlib/number/float32/base/to-uint32/test/test.js
@@ -58,20 +58,20 @@ tape( 'if provided `-0`, the function returns `0`', function test( t ) {
 
 tape( 'if provided `+infinity`, the function returns `0`', function test( t ) {
 	var v = float32ToUint32( PINF );
-	t.strictEqual( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `0`', function test( t ) {
 	var v = float32ToUint32( NINF );
-	t.strictEqual( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `0`', function test( t ) {
 	var v = float32ToUint32( float64ToFloat32( NaN ) );
 	t.strictEqual( isnan( v ), false, 'does not return NaN' );
-	t.strictEqual( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.js b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.js
index 2feacf94444a..7c9aabf7c560 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.js
@@ -42,7 +42,7 @@ tape( 'the function returns an integer', function test( t ) {
 	var w = getHighWord( pow( 2.0, 53 ) );
 
 	t.strictEqual( typeof w, 'number', 'returns expected value' );
-	t.strictEqual( w%1, 0, 'returns an integer' );
+	t.strictEqual( w%1, 0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.native.js
index e79add029439..52872484fae3 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-high-word/test/test.native.js
@@ -51,7 +51,7 @@ tape( 'the function returns an integer', opts, function test( t ) {
 	var w = getHighWord( pow( 2.0, 53 ) );
 
 	t.strictEqual( typeof w, 'number', 'returns expected value' );
-	t.strictEqual( w%1, 0, 'returns an integer' );
+	t.strictEqual( w%1, 0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.js b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.js
index a8f8408b3e96..c57f11c215c8 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.js
@@ -41,7 +41,7 @@ tape( 'the function returns an integer', function test( t ) {
 	var w = getLowWord( pow( 2, 53 ) );
 
 	t.strictEqual( typeof w, 'number', 'returns expected value' );
-	t.strictEqual( w%1, 0, 'returns an integer' );
+	t.strictEqual( w%1, 0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.native.js b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.native.js
index cf182a65bf2a..9abf148e0a8c 100644
--- a/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.native.js
+++ b/lib/node_modules/@stdlib/number/float64/base/get-low-word/test/test.native.js
@@ -50,7 +50,7 @@ tape( 'the function returns an integer', opts, function test( t ) {
 	var w = getLowWord( pow( 2, 53 ) );
 
 	t.strictEqual( typeof w, 'number', 'returns expected value' );
-	t.strictEqual( w%1, 0, 'returns an integer' );
+	t.strictEqual( w%1, 0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/number/float64/base/to-int32/test/test.js b/lib/node_modules/@stdlib/number/float64/base/to-int32/test/test.js
index 21a944c32225..7b857d5e45e5 100644
--- a/lib/node_modules/@stdlib/number/float64/base/to-int32/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/to-int32/test/test.js
@@ -57,20 +57,20 @@ tape( 'if provided `-0`, the function returns `0`', function test( t ) {
 
 tape( 'if provided `+infinity`, the function returns `0`', function test( t ) {
 	var v = float64ToInt32( PINF );
-	t.strictEqual( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `0`', function test( t ) {
 	var v = float64ToInt32( NINF );
-	t.strictEqual( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `0`', function test( t ) {
 	var v = float64ToInt32( NaN );
 	t.strictEqual( isnan( v ), false, 'does not return NaN' );
-	t.strictEqual( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/float64/base/to-uint32/test/test.js b/lib/node_modules/@stdlib/number/float64/base/to-uint32/test/test.js
index ee08b5d947a0..890450a41035 100644
--- a/lib/node_modules/@stdlib/number/float64/base/to-uint32/test/test.js
+++ b/lib/node_modules/@stdlib/number/float64/base/to-uint32/test/test.js
@@ -57,20 +57,20 @@ tape( 'if provided `-0`, the function returns `0`', function test( t ) {
 
 tape( 'if provided `+infinity`, the function returns `0`', function test( t ) {
 	var v = float64ToUint32( PINF );
-	t.strictEqual( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `-infinity`, the function returns `0`', function test( t ) {
 	var v = float64ToUint32( NINF );
-	t.strictEqual( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `NaN`, the function returns `0`', function test( t ) {
 	var v = float64ToUint32( NaN );
 	t.strictEqual( isnan( v ), false, 'does not return NaN' );
-	t.strictEqual( v, 0, 'returns 0' );
+	t.strictEqual( v, 0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/uint16/base/from-binary-string/test/test.js b/lib/node_modules/@stdlib/number/uint16/base/from-binary-string/test/test.js
index 125ed592e255..7cd39cb334df 100644
--- a/lib/node_modules/@stdlib/number/uint16/base/from-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint16/base/from-binary-string/test/test.js
@@ -65,7 +65,7 @@ tape( 'if provided a string with a length other than `16`, the function throws a
 });
 
 tape( 'if provided all zeros, the function returns `0`', function test( t ) {
-	t.strictEqual( fromBinaryStringUint16( toBinaryStringUint16( 0 ) ), 0, 'returns 0' );
+	t.strictEqual( fromBinaryStringUint16( toBinaryStringUint16( 0 ) ), 0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/uint32/base/from-binary-string/test/test.js b/lib/node_modules/@stdlib/number/uint32/base/from-binary-string/test/test.js
index 5ab731c59da6..8baa86dc7d02 100644
--- a/lib/node_modules/@stdlib/number/uint32/base/from-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint32/base/from-binary-string/test/test.js
@@ -67,7 +67,7 @@ tape( 'if provided a string with a length other than `32`, the function throws a
 });
 
 tape( 'if provided all zeros, the function returns `0`', function test( t ) {
-	t.strictEqual( fromBinaryStringUint32( toBinaryStringUint32( 0 ) ), 0, 'returns 0' );
+	t.strictEqual( fromBinaryStringUint32( toBinaryStringUint32( 0 ) ), 0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/number/uint8/base/from-binary-string/test/test.js b/lib/node_modules/@stdlib/number/uint8/base/from-binary-string/test/test.js
index fdfb772ae8ee..a7a885c19271 100644
--- a/lib/node_modules/@stdlib/number/uint8/base/from-binary-string/test/test.js
+++ b/lib/node_modules/@stdlib/number/uint8/base/from-binary-string/test/test.js
@@ -65,7 +65,7 @@ tape( 'if provided a string with a length other than `16`, the function throws a
 });
 
 tape( 'if provided all zeros, the function returns `0`', function test( t ) {
-	t.strictEqual( fromBinaryStringUint8( toBinaryStringUint8( 0 ) ), 0, 'returns 0' );
+	t.strictEqual( fromBinaryStringUint8( toBinaryStringUint8( 0 ) ), 0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/os/num-cpus/test/test.browser.js b/lib/node_modules/@stdlib/os/num-cpus/test/test.browser.js
index 7a0ff87f6d1f..1e0257097b80 100644
--- a/lib/node_modules/@stdlib/os/num-cpus/test/test.browser.js
+++ b/lib/node_modules/@stdlib/os/num-cpus/test/test.browser.js
@@ -44,6 +44,6 @@ tape( 'if a web browser does not support hardware concurrency, the exported valu
 		'./navigator.js': {}
 	});
 
-	t.strictEqual( NUM_CPUS, 1, 'returns 1' );
+	t.strictEqual( NUM_CPUS, 1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/chdir/test/test.js b/lib/node_modules/@stdlib/process/chdir/test/test.js
index f146ffe38874..000674cbc118 100644
--- a/lib/node_modules/@stdlib/process/chdir/test/test.js
+++ b/lib/node_modules/@stdlib/process/chdir/test/test.js
@@ -69,7 +69,7 @@ tape( 'the function changes the working directory', opts, function test( t ) {
 tape( 'if the function encounters an error when attempting to change the working directory, the function returns the error', opts, function test( t ) {
 	var err = chdir( 'kjflajflsda/bkadlfjadlfksabldjkfklajsf/dkfaljsf' ); // non-existent directory
 
-	t.strictEqual( err instanceof Error, true, 'returns an error' );
+	t.strictEqual( err instanceof Error, true, 'returns expected value' );
 	t.strictEqual( cwd(), DIR, 'does not change working directory' );
 
 	// Restore current working directory:
diff --git a/lib/node_modules/@stdlib/process/chdir/test/test.polyfill.js b/lib/node_modules/@stdlib/process/chdir/test/test.polyfill.js
index bdc6b11fe77d..5939366b81c3 100644
--- a/lib/node_modules/@stdlib/process/chdir/test/test.polyfill.js
+++ b/lib/node_modules/@stdlib/process/chdir/test/test.polyfill.js
@@ -34,6 +34,6 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns an error', function test( t ) {
 	var err = chdir();
-	t.strictEqual( err instanceof Error, true, 'returns an error' );
+	t.strictEqual( err instanceof Error, true, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/process/read-stdin/test/test.js b/lib/node_modules/@stdlib/process/read-stdin/test/test.js
index df8920bbd2ee..ba922615865d 100644
--- a/lib/node_modules/@stdlib/process/read-stdin/test/test.js
+++ b/lib/node_modules/@stdlib/process/read-stdin/test/test.js
@@ -170,7 +170,7 @@ tape( 'if an error is encountered while reading from `stdin`, the error is retur
 
 	function onRead( error ) {
 		if ( error ) {
-			t.strictEqual( error.message, 'beep', 'returns an error' );
+			t.strictEqual( error.message, 'beep', 'returns expected value' );
 		}
 		t.end();
 	}
@@ -194,7 +194,7 @@ tape( 'if an error is encountered while reading from `stdin`, the error is retur
 
 	function onRead( error ) {
 		if ( error ) {
-			t.strictEqual( error.message, 'beep', 'returns an error' );
+			t.strictEqual( error.message, 'beep', 'returns expected value' );
 		}
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.discrete_uniform.js b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.discrete_uniform.js
index 44fb3b2692d7..a8cca829ecec 100644
--- a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.discrete_uniform.js
+++ b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.discrete_uniform.js
@@ -69,7 +69,7 @@ tape( 'the function returns pseudorandom numbers (smaller range)', function test
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
@@ -91,7 +91,7 @@ tape( 'the function returns pseudorandom numbers (smaller range)', function test
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
@@ -115,7 +115,7 @@ tape( 'the function returns pseudorandom numbers (smaller range)', function test
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
@@ -132,7 +132,7 @@ tape( 'the function returns pseudorandom numbers (smaller range)', function test
 	for ( i = 0; i < 1e3; i++ ) {
 		r = rand( randi, a, b );
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
@@ -149,7 +149,7 @@ tape( 'the function returns pseudorandom numbers (equal range)', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
@@ -169,7 +169,7 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
@@ -194,7 +194,7 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
@@ -219,7 +219,7 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
@@ -239,7 +239,7 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
@@ -260,7 +260,7 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
@@ -285,7 +285,7 @@ tape( 'the function returns pseudorandom numbers (bigger range)', function test(
 	for ( i = 0; i < 1e2; i++ ) {
 		r = rand( randi, a, b );
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.factory.js b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.factory.js
index 5544fdaa00e6..1b27039816a3 100644
--- a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.factory.js
@@ -545,7 +545,7 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	for ( i = 0; i < 100; i++ ) {
 		r = discreteUniform();
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 	}
 
 	// Without binding distribution parameters...
@@ -553,7 +553,7 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	for ( i = 0; i < 100; i++ ) {
 		r = discreteUniform( -100, 100 );
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.js b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.js
index 64716015fde6..2355e285c9f1 100644
--- a/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/discrete-uniform/test/test.js
@@ -90,7 +90,7 @@ tape( 'the function returns pseudorandom numbers', function test( t ) {
 	for ( i = 0; i < 1e2; i++ ) {
 		r = discreteUniform( a, b );
 		t.strictEqual( typeof r, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( r ), true, 'returns an integer' );
+		t.strictEqual( isInteger( r ), true, 'returns expected value' );
 		t.strictEqual( r >= a && r <= b, true, 'within support: '+r );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/randi/test/test.factory.js b/lib/node_modules/@stdlib/random/base/randi/test/test.factory.js
index eade43f5bb5f..8cf97ec14bc9 100644
--- a/lib/node_modules/@stdlib/random/base/randi/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/randi/test/test.factory.js
@@ -196,7 +196,7 @@ tape( 'the function returns a pseudorandom number generator (no seed)', function
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randi();
 		t.strictEqual( typeof v, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( v ), true, 'returns an integer' );
+		t.strictEqual( isInteger( v ), true, 'returns expected value' );
 		t.strictEqual( v >= randi.MIN && v <= randi.MAX, true, 'returns a number between MIN (inclusive) and MAX (inclusive)' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/base/randi/test/test.js b/lib/node_modules/@stdlib/random/base/randi/test/test.js
index 00804b3a51ca..e0999434fe76 100644
--- a/lib/node_modules/@stdlib/random/base/randi/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/randi/test/test.js
@@ -97,7 +97,7 @@ tape( 'the function returns pseudorandom numbers between a minimum (inclusive) a
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randi();
 		t.strictEqual( typeof v, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( v ), true, 'returns an integer' );
+		t.strictEqual( isInteger( v ), true, 'returns expected value' );
 		t.strictEqual( v >= randi.MIN && v <= randi.MAX, true, 'returns a number between MIN (inclusive) and MAX (inclusive)' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/shuffle/test/test.factory.js b/lib/node_modules/@stdlib/random/shuffle/test/test.factory.js
index 807903cd3eac..70076c1ee771 100644
--- a/lib/node_modules/@stdlib/random/shuffle/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/shuffle/test/test.factory.js
@@ -282,7 +282,7 @@ tape( 'the returned function shuffles the elements of a typed array', function t
 	expected = new Int32Array( [ 6, 2, 4, 5, 3, 1 ] );
 	actual = shuffle( arr );
 
-	t.strictEqual( constructorName( actual ), 'Int32Array', 'returns a typed array' );
+	t.strictEqual( constructorName( actual ), 'Int32Array', 'returns expected value' );
 	t.deepEqual( actual, expected, 'deep equal' );
 	t.notEqual( actual, arr, 'returns a copy' );
 	t.end();
@@ -325,7 +325,7 @@ tape( 'the returned function shuffles the elements of a typed array (in-place)',
 		'copy': 'none'
 	});
 
-	t.strictEqual( constructorName( actual ), 'Int32Array', 'returns a typed array' );
+	t.strictEqual( constructorName( actual ), 'Int32Array', 'returns expected value' );
 	t.deepEqual( actual, expected, 'deep equal' );
 	t.strictEqual( arr, actual, 'mutates the input array' );
 	t.end();
diff --git a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.factory.js
index 8424c1858a6a..5ec05033d9fb 100644
--- a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.factory.js
@@ -768,7 +768,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -780,7 +780,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -792,7 +792,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -804,7 +804,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.object_mode.js
index e3425a626403..66cd91a0c045 100644
--- a/lib/node_modules/@stdlib/random/streams/arcsine/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/arcsine/test/test.object_mode.js
@@ -377,13 +377,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.factory.js
index ef1789c51e37..34057c765bf1 100644
--- a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.factory.js
@@ -673,7 +673,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -685,7 +685,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -697,7 +697,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -709,7 +709,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.object_mode.js
index 100397622a07..059c7bc455f2 100644
--- a/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/bernoulli/test/test.object_mode.js
@@ -330,13 +330,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 0.3 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 0.3, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/beta/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/beta/test/test.factory.js
index 24c6a277760a..1814e579a64a 100644
--- a/lib/node_modules/@stdlib/random/streams/beta/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/beta/test/test.factory.js
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/beta/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/beta/test/test.object_mode.js
index 818a3008b1c3..457d92bb888c 100644
--- a/lib/node_modules/@stdlib/random/streams/beta/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/beta/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.factory.js
index 24c6a277760a..1814e579a64a 100644
--- a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.factory.js
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.object_mode.js
index 818a3008b1c3..457d92bb888c 100644
--- a/lib/node_modules/@stdlib/random/streams/betaprime/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/betaprime/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/binomial/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/binomial/test/test.factory.js
index 25a829c8543e..acc325a9af4f 100644
--- a/lib/node_modules/@stdlib/random/streams/binomial/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/binomial/test/test.factory.js
@@ -732,7 +732,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 20, 0.3 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 20, 0.3 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -744,7 +744,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 20, 0.3 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 20, 0.3 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -756,7 +756,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 20, 0.3 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -768,7 +768,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 20, 0.3, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/binomial/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/binomial/test/test.object_mode.js
index b9f3e6a2f0c2..b196fa0dc580 100644
--- a/lib/node_modules/@stdlib/random/streams/binomial/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/binomial/test/test.object_mode.js
@@ -360,13 +360,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 20, 0.3 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 20, 0.3, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.factory.js
index 5f1480a81f6e..4e3e1cef400e 100644
--- a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.factory.js
@@ -324,7 +324,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -336,7 +336,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.object_mode.js
index 5a1cf92647a8..57bda3878d87 100644
--- a/lib/node_modules/@stdlib/random/streams/box-muller/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/box-muller/test/test.object_mode.js
@@ -299,13 +299,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.factory.js
index 5c9ce34602d6..4a3d6cfc8050 100644
--- a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.factory.js
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.object_mode.js
index a6b7c43953f8..c29f1a89f5e0 100644
--- a/lib/node_modules/@stdlib/random/streams/cauchy/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/cauchy/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/chi/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/chi/test/test.factory.js
index be6ca412f81a..6a4486a1dbb1 100644
--- a/lib/node_modules/@stdlib/random/streams/chi/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/chi/test/test.factory.js
@@ -670,7 +670,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -682,7 +682,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -694,7 +694,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -706,7 +706,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/chi/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/chi/test/test.object_mode.js
index b6203a053b66..795143a7699b 100644
--- a/lib/node_modules/@stdlib/random/streams/chi/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/chi/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 1.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 1.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.factory.js
index be6ca412f81a..6a4486a1dbb1 100644
--- a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.factory.js
@@ -670,7 +670,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -682,7 +682,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -694,7 +694,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -706,7 +706,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.object_mode.js
index b6203a053b66..795143a7699b 100644
--- a/lib/node_modules/@stdlib/random/streams/chisquare/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/chisquare/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 1.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 1.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/cosine/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/cosine/test/test.factory.js
index fb6972d82198..f3e25ca0d56b 100644
--- a/lib/node_modules/@stdlib/random/streams/cosine/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/cosine/test/test.factory.js
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/cosine/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/cosine/test/test.object_mode.js
index c4c067adad6c..265316a0bdb0 100644
--- a/lib/node_modules/@stdlib/random/streams/cosine/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/cosine/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.factory.js
index 94b6af9e4d78..eaaa38c425ba 100644
--- a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.factory.js
@@ -772,7 +772,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2, 5 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2, 5 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -784,7 +784,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2, 5 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2, 5 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -796,7 +796,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2, 5 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -808,7 +808,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2, 5, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.object_mode.js
index 6c8882251723..0ea2288787c7 100644
--- a/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/discrete-uniform/test/test.object_mode.js
@@ -379,13 +379,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2, 5 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2, 5, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/erlang/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/erlang/test/test.factory.js
index 31146809cc39..e29a00cbc9f1 100644
--- a/lib/node_modules/@stdlib/random/streams/erlang/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/erlang/test/test.factory.js
@@ -732,7 +732,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -744,7 +744,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -756,7 +756,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -768,7 +768,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/erlang/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/erlang/test/test.object_mode.js
index fd1297811e7f..3dfad35e808d 100644
--- a/lib/node_modules/@stdlib/random/streams/erlang/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/erlang/test/test.object_mode.js
@@ -360,13 +360,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/exponential/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/exponential/test/test.factory.js
index a1487342faf7..258a4d19a0c9 100644
--- a/lib/node_modules/@stdlib/random/streams/exponential/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/exponential/test/test.factory.js
@@ -670,7 +670,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -682,7 +682,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -694,7 +694,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -706,7 +706,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/exponential/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/exponential/test/test.object_mode.js
index 14e728f19773..efec77f5353e 100644
--- a/lib/node_modules/@stdlib/random/streams/exponential/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/exponential/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 1.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 1.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/f/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/f/test/test.factory.js
index c2757fab1dae..2bfc234fb1ef 100644
--- a/lib/node_modules/@stdlib/random/streams/f/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/f/test/test.factory.js
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/f/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/f/test/test.object_mode.js
index a33f739e7c5a..077f5045a349 100644
--- a/lib/node_modules/@stdlib/random/streams/f/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/f/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/frechet/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/frechet/test/test.factory.js
index 120508d26d59..2f2976618035 100644
--- a/lib/node_modules/@stdlib/random/streams/frechet/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/frechet/test/test.factory.js
@@ -788,7 +788,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0, 3.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0, 3.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -800,7 +800,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0, 3.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0, 3.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -812,7 +812,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, 3.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -824,7 +824,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, 3.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/frechet/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/frechet/test/test.object_mode.js
index f73f2e9abfa7..3f426a577d3c 100644
--- a/lib/node_modules/@stdlib/random/streams/frechet/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/frechet/test/test.object_mode.js
@@ -387,13 +387,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0, 3.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, 3.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/gamma/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/gamma/test/test.factory.js
index 0d1c8336fc33..26020107bb03 100644
--- a/lib/node_modules/@stdlib/random/streams/gamma/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/gamma/test/test.factory.js
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/gamma/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/gamma/test/test.object_mode.js
index e5216fb0eccb..7dd627e74584 100644
--- a/lib/node_modules/@stdlib/random/streams/gamma/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/gamma/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/geometric/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/geometric/test/test.factory.js
index ef1789c51e37..34057c765bf1 100644
--- a/lib/node_modules/@stdlib/random/streams/geometric/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/geometric/test/test.factory.js
@@ -673,7 +673,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -685,7 +685,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -697,7 +697,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -709,7 +709,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/geometric/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/geometric/test/test.object_mode.js
index 100397622a07..059c7bc455f2 100644
--- a/lib/node_modules/@stdlib/random/streams/geometric/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/geometric/test/test.object_mode.js
@@ -330,13 +330,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 0.3 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 0.3, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.factory.js
index 83390ef297a3..60ad3cd6f281 100644
--- a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.factory.js
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.object_mode.js
index 085d0c087f1e..f3e8b19bcd2a 100644
--- a/lib/node_modules/@stdlib/random/streams/gumbel/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/gumbel/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.factory.js
index a18a8537196d..d64bd43933ed 100644
--- a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.factory.js
@@ -890,7 +890,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 20, 10, 7 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 20, 10, 7 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -902,7 +902,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 20, 10, 7 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 20, 10, 7 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -914,7 +914,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 20, 10, 7 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -926,7 +926,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 20, 10, 7, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.object_mode.js
index f7510b11ec7e..affb62b67972 100644
--- a/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/hypergeometric/test/test.object_mode.js
@@ -436,13 +436,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 20, 10, 7 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 20, 10, 7, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.factory.js
index 5f1480a81f6e..4e3e1cef400e 100644
--- a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.factory.js
@@ -324,7 +324,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -336,7 +336,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.object_mode.js
index 5a1cf92647a8..57bda3878d87 100644
--- a/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/improved-ziggurat/test/test.object_mode.js
@@ -299,13 +299,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.factory.js
index 5c9cb8737839..a0641af92959 100644
--- a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.factory.js
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.object_mode.js
index 7bf092096ed8..92f66abc0446 100644
--- a/lib/node_modules/@stdlib/random/streams/invgamma/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/invgamma/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.factory.js
index 2cc2fc823753..8c97a840ad98 100644
--- a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.factory.js
@@ -730,7 +730,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -742,7 +742,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -754,7 +754,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -766,7 +766,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.object_mode.js
index 754035543c89..0b61f99bea45 100644
--- a/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/kumaraswamy/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/laplace/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/laplace/test/test.factory.js
index 54370487dd0d..c0a202247984 100644
--- a/lib/node_modules/@stdlib/random/streams/laplace/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/laplace/test/test.factory.js
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/laplace/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/laplace/test/test.object_mode.js
index fb6a8287f44c..c3e03cac04fd 100644
--- a/lib/node_modules/@stdlib/random/streams/laplace/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/laplace/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/levy/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/levy/test/test.factory.js
index f0ee96791fe0..2b02d4033c43 100644
--- a/lib/node_modules/@stdlib/random/streams/levy/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/levy/test/test.factory.js
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/levy/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/levy/test/test.object_mode.js
index e8476849d0b4..ccdc63d66d3b 100644
--- a/lib/node_modules/@stdlib/random/streams/levy/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/levy/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/logistic/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/logistic/test/test.factory.js
index c5cbcf0eebbb..54a3b6a19daf 100644
--- a/lib/node_modules/@stdlib/random/streams/logistic/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/logistic/test/test.factory.js
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/logistic/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/logistic/test/test.object_mode.js
index 676878d668e6..25cbc5ef4f4a 100644
--- a/lib/node_modules/@stdlib/random/streams/logistic/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/logistic/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.factory.js
index 811f66af2f99..42005d7dd1a9 100644
--- a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.factory.js
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.object_mode.js
index eaead34f6c12..deb203a0ad5f 100644
--- a/lib/node_modules/@stdlib/random/streams/lognormal/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/lognormal/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.factory.js
index c9a0c1653e2d..b85cf258dbcc 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.factory.js
@@ -323,7 +323,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -335,7 +335,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.object_mode.js
index 14f71e4fd3ac..15f1dfdfd6d9 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd-shuffle/test/test.object_mode.js
@@ -299,13 +299,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
@@ -329,7 +329,7 @@ tape( 'the function returns a stream which streams integers', function test( t )
 
 	function inspect( v ) {
 		t.strictEqual( typeof v, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( v ), true, 'returns an integer' );
+		t.strictEqual( isInteger( v ), true, 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/minstd/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/minstd/test/test.factory.js
index c9a0c1653e2d..b85cf258dbcc 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd/test/test.factory.js
@@ -323,7 +323,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -335,7 +335,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/minstd/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/minstd/test/test.object_mode.js
index 14f71e4fd3ac..15f1dfdfd6d9 100644
--- a/lib/node_modules/@stdlib/random/streams/minstd/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/minstd/test/test.object_mode.js
@@ -299,13 +299,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
@@ -329,7 +329,7 @@ tape( 'the function returns a stream which streams integers', function test( t )
 
 	function inspect( v ) {
 		t.strictEqual( typeof v, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( v ), true, 'returns an integer' );
+		t.strictEqual( isInteger( v ), true, 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.factory.js
index fe25386049a3..24c24f87808f 100644
--- a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.factory.js
@@ -323,7 +323,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -335,7 +335,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.object_mode.js
index 58a3ab549434..841d2234e42d 100644
--- a/lib/node_modules/@stdlib/random/streams/mt19937/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/mt19937/test/test.object_mode.js
@@ -299,13 +299,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
@@ -329,7 +329,7 @@ tape( 'the function returns a stream which streams integers', function test( t )
 
 	function inspect( v ) {
 		t.strictEqual( typeof v, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( v ), true, 'returns an integer' );
+		t.strictEqual( isInteger( v ), true, 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.factory.js
index 439deb8cece5..9648e2359699 100644
--- a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.factory.js
@@ -730,7 +730,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 20.0, 0.3 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 20.0, 0.3 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -742,7 +742,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 20.0, 0.3 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 20.0, 0.3 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -754,7 +754,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 20.0, 0.3 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -766,7 +766,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 20.0, 0.3, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.object_mode.js
index 6f41ccb1c126..cee6b24025d8 100644
--- a/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/negative-binomial/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 20.0, 0.3 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 20.0, 0.3, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/normal/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/normal/test/test.factory.js
index 09cd99dd4271..404f356f9b03 100644
--- a/lib/node_modules/@stdlib/random/streams/normal/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/normal/test/test.factory.js
@@ -726,7 +726,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -738,7 +738,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -750,7 +750,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -762,7 +762,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/normal/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/normal/test/test.object_mode.js
index 7e6e4fba1e15..807fed4913dc 100644
--- a/lib/node_modules/@stdlib/random/streams/normal/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/normal/test/test.object_mode.js
@@ -357,13 +357,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.factory.js
index 5c9cb8737839..a0641af92959 100644
--- a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.factory.js
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.object_mode.js
index 7bf092096ed8..92f66abc0446 100644
--- a/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/pareto-type1/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/poisson/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/poisson/test/test.factory.js
index 7deaf7d0f036..ac7f5b1ae3ee 100644
--- a/lib/node_modules/@stdlib/random/streams/poisson/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/poisson/test/test.factory.js
@@ -670,7 +670,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -682,7 +682,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -694,7 +694,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -706,7 +706,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/poisson/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/poisson/test/test.object_mode.js
index e493697033da..b71d6532325b 100644
--- a/lib/node_modules/@stdlib/random/streams/poisson/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/poisson/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 1.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 1.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/randi/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/randi/test/test.factory.js
index f678f20664ac..13eb67c6d8dd 100644
--- a/lib/node_modules/@stdlib/random/streams/randi/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/randi/test/test.factory.js
@@ -275,7 +275,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -287,7 +287,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randi/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/randi/test/test.object_mode.js
index 07e8627cedfe..2cc0f9eed5e8 100644
--- a/lib/node_modules/@stdlib/random/streams/randi/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/randi/test/test.object_mode.js
@@ -253,13 +253,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
@@ -283,7 +283,7 @@ tape( 'the function returns a stream which streams integers', function test( t )
 
 	function inspect( v ) {
 		t.strictEqual( typeof v, 'number', 'returns expected value' );
-		t.strictEqual( isInteger( v ), true, 'returns an integer' );
+		t.strictEqual( isInteger( v ), true, 'returns expected value' );
 	}
 
 	function onEnd() {
diff --git a/lib/node_modules/@stdlib/random/streams/randn/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/randn/test/test.factory.js
index 7b63b01a4634..5efe13787407 100644
--- a/lib/node_modules/@stdlib/random/streams/randn/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/randn/test/test.factory.js
@@ -358,7 +358,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -370,7 +370,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randn/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/randn/test/test.object_mode.js
index d8f7b47f2549..8249432e6b11 100644
--- a/lib/node_modules/@stdlib/random/streams/randn/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/randn/test/test.object_mode.js
@@ -332,13 +332,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/randu/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/randu/test/test.factory.js
index f678f20664ac..13eb67c6d8dd 100644
--- a/lib/node_modules/@stdlib/random/streams/randu/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/randu/test/test.factory.js
@@ -275,7 +275,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -287,7 +287,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/randu/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/randu/test/test.object_mode.js
index 4feb66c6168b..a9e07ca43d16 100644
--- a/lib/node_modules/@stdlib/random/streams/randu/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/randu/test/test.object_mode.js
@@ -252,13 +252,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.factory.js
index 0d17ca01d0e7..6a5c3ba2b5fc 100644
--- a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.factory.js
@@ -670,7 +670,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -682,7 +682,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -694,7 +694,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -706,7 +706,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.object_mode.js
index 35fb75f3110a..3b41c0eb0c78 100644
--- a/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/rayleigh/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 1.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 1.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/t/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/t/test/test.factory.js
index f832f5fb501f..161106b8c92d 100644
--- a/lib/node_modules/@stdlib/random/streams/t/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/t/test/test.factory.js
@@ -670,7 +670,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -682,7 +682,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 1.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -694,7 +694,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -706,7 +706,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 1.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/t/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/t/test/test.object_mode.js
index 891841189348..81bab87747a1 100644
--- a/lib/node_modules/@stdlib/random/streams/t/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/t/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 1.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 1.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/triangular/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/triangular/test/test.factory.js
index d5167b44eb1e..2f7d693a07da 100644
--- a/lib/node_modules/@stdlib/random/streams/triangular/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/triangular/test/test.factory.js
@@ -803,7 +803,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0, 4.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0, 4.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -815,7 +815,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0, 4.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0, 4.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -827,7 +827,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, 4.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -839,7 +839,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, 4.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/triangular/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/triangular/test/test.object_mode.js
index ebc07288a753..622c57e08d24 100644
--- a/lib/node_modules/@stdlib/random/streams/triangular/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/triangular/test/test.object_mode.js
@@ -405,13 +405,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0, 4.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, 4.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/uniform/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/uniform/test/test.factory.js
index 8424c1858a6a..5ec05033d9fb 100644
--- a/lib/node_modules/@stdlib/random/streams/uniform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/uniform/test/test.factory.js
@@ -768,7 +768,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -780,7 +780,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -792,7 +792,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -804,7 +804,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/uniform/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/uniform/test/test.object_mode.js
index e3425a626403..66cd91a0c045 100644
--- a/lib/node_modules/@stdlib/random/streams/uniform/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/uniform/test/test.object_mode.js
@@ -377,13 +377,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/random/streams/weibull/test/test.factory.js b/lib/node_modules/@stdlib/random/streams/weibull/test/test.factory.js
index c02e8787e3a0..50356ea2ce77 100644
--- a/lib/node_modules/@stdlib/random/streams/weibull/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/streams/weibull/test/test.factory.js
@@ -728,7 +728,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -740,7 +740,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 2.0, 5.0 ) instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -752,7 +752,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0 );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -764,7 +764,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 2.0, 5.0, {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof RandomStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof RandomStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/random/streams/weibull/test/test.object_mode.js b/lib/node_modules/@stdlib/random/streams/weibull/test/test.object_mode.js
index 96336060d81a..334d0679a174 100644
--- a/lib/node_modules/@stdlib/random/streams/weibull/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/random/streams/weibull/test/test.object_mode.js
@@ -359,13 +359,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 2.0, 5.0 );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 2.0, 5.0, {} );
-	t.strictEqual( s instanceof RandomStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof RandomStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/slice/ctor/test/test.js b/lib/node_modules/@stdlib/slice/ctor/test/test.js
index 667e970b9448..c23c36e3e2ac 100644
--- a/lib/node_modules/@stdlib/slice/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/slice/ctor/test/test.js
@@ -68,79 +68,79 @@ tape( 'the function is a Slice constructor', function test( t ) {
 	var s;
 
 	s = new Slice();
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( 10 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( 0, 10 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( null, 10 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( void 0, 10 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( 0, null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( 0, void 0 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( null, null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( void 0, void 0 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( 0, 10, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( null, 10, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( void 0, 10, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( 0, null, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( 0, void 0, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( 0, 10, null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( 0, 10, void 0 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( null, null, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( void 0, void 0, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( null, 10, null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( void 0, 10, void 0 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( 0, null, null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( 0, void 0, void 0 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( null, null, null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = new Slice( void 0, void 0, void 0 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -152,79 +152,79 @@ tape( 'the function does not require the `new` keyword', function test( t ) {
 	slice = Slice;
 
 	s = slice();
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( 10 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( 0, 10 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( null, 10 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( void 0, 10 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( 0, null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( 0, void 0 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( null, null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( void 0, void 0 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( 0, 10, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( null, 10, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( void 0, 10, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( 0, null, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( 0, void 0, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( 0, 10, null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( 0, 10, void 0 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( null, null, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( void 0, void 0, 1 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( null, 10, null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( void 0, 10, void 0 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( 0, null, null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( 0, void 0, void 0 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( null, null, null );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	s = slice( void 0, void 0, void 0 );
-	t.strictEqual( instanceOf( s, Slice ), true, 'returns an instance' );
+	t.strictEqual( instanceOf( s, Slice ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/arcsine/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/arcsine/ctor/test/test.js
index 9e2e11a74676..16098110f03b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/arcsine/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/arcsine/ctor/test/test.js
@@ -140,24 +140,24 @@ tape( 'if provided arguments, the function requires both `a` and `b`', function
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var arcsine = new Arcsine();
-	t.strictEqual( arcsine instanceof Arcsine, true, 'returns an instance' );
+	t.strictEqual( arcsine instanceof Arcsine, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var arcsine = new Arcsine( 2.0, 4.0 );
-	t.strictEqual( arcsine instanceof Arcsine, true, 'returns an instance' );
+	t.strictEqual( arcsine instanceof Arcsine, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var arcsine = Arcsine();
-	t.strictEqual( arcsine instanceof Arcsine, true, 'returns an instance' );
+	t.strictEqual( arcsine instanceof Arcsine, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	arcsine = Arcsine( 2.0, 4.0 );
-	t.strictEqual( arcsine instanceof Arcsine, true, 'returns an instance' );
+	t.strictEqual( arcsine instanceof Arcsine, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/ctor/test/test.js
index 5bf5ff453572..bd9e1646971d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/bernoulli/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/bernoulli/ctor/test/test.js
@@ -80,24 +80,24 @@ tape( 'the function throws an error if provided a `p` argument which is not a pr
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var bernoulli = new Bernoulli();
-	t.strictEqual( bernoulli instanceof Bernoulli, true, 'returns an instance' );
+	t.strictEqual( bernoulli instanceof Bernoulli, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var bernoulli = new Bernoulli( 0.3 );
-	t.strictEqual( bernoulli instanceof Bernoulli, true, 'returns an instance' );
+	t.strictEqual( bernoulli instanceof Bernoulli, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var bernoulli = Bernoulli();
-	t.strictEqual( bernoulli instanceof Bernoulli, true, 'returns an instance' );
+	t.strictEqual( bernoulli instanceof Bernoulli, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	bernoulli = Bernoulli( 0.3 );
-	t.strictEqual( bernoulli instanceof Bernoulli, true, 'returns an instance' );
+	t.strictEqual( bernoulli instanceof Bernoulli, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/beta/ctor/test/test.js
index 8c6ee4a92f0a..c5a5a7bd8111 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/ctor/test/test.js
@@ -122,24 +122,24 @@ tape( 'if provided arguments, the function requires both `alpha` and `beta`', fu
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var beta = new Beta();
-	t.strictEqual( beta instanceof Beta, true, 'returns an instance' );
+	t.strictEqual( beta instanceof Beta, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var beta = new Beta( 2.0, 4.0 );
-	t.strictEqual( beta instanceof Beta, true, 'returns an instance' );
+	t.strictEqual( beta instanceof Beta, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var beta = Beta();
-	t.strictEqual( beta instanceof Beta, true, 'returns an instance' );
+	t.strictEqual( beta instanceof Beta, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	beta = Beta( 2.0, 4.0 );
-	t.strictEqual( beta instanceof Beta, true, 'returns an instance' );
+	t.strictEqual( beta instanceof Beta, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.pdf.js
index eda8901cb42e..f4c73e64f5b6 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/beta/pdf/test/test.pdf.js
@@ -138,7 +138,7 @@ tape( 'if provided `alpha > 1`, the created function returns `0` for `x` equal t
 
 tape( 'if provided `alpha < 1`, the created function returns `+Infinity` for `x` equal to zero', function test( t ) {
 	var y = pdf( 0.0, 0.5, 2.0 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/ctor/test/test.js
index d18651f6513e..a900d4f7be6d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/ctor/test/test.js
@@ -119,24 +119,24 @@ tape( 'if provided arguments, the function requires both `alpha` and `beta`', fu
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var betaprime = new BetaPrime();
-	t.strictEqual( betaprime instanceof BetaPrime, true, 'returns an instance' );
+	t.strictEqual( betaprime instanceof BetaPrime, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var betaprime = new BetaPrime( 2.0, 4.0 );
-	t.strictEqual( betaprime instanceof BetaPrime, true, 'returns an instance' );
+	t.strictEqual( betaprime instanceof BetaPrime, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var betaprime = BetaPrime();
-	t.strictEqual( betaprime instanceof BetaPrime, true, 'returns an instance' );
+	t.strictEqual( betaprime instanceof BetaPrime, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	betaprime = BetaPrime( 2.0, 4.0 );
-	t.strictEqual( betaprime instanceof BetaPrime, true, 'returns an instance' );
+	t.strictEqual( betaprime instanceof BetaPrime, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.logcdf.js
index 1c1791ecc4f5..941717c5adc0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/betaprime/logcdf/test/test.logcdf.js
@@ -72,7 +72,7 @@ tape( 'if provided a number less than or equal to zero for `x` and a finite `alp
 
 tape( 'if provided `+Infinity` for `x` and a finite `alpha` and `beta`, the function returns `0`', function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/ctor/test/test.js
index 518431f41ddb..6738d10319c8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/ctor/test/test.js
@@ -123,24 +123,24 @@ tape( 'if provided arguments, the function requires both `n` and `p`', function
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var binomial = new Binomial();
-	t.strictEqual( binomial instanceof Binomial, true, 'returns an instance' );
+	t.strictEqual( binomial instanceof Binomial, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var binomial = new Binomial( 4, 0.5 );
-	t.strictEqual( binomial instanceof Binomial, true, 'returns an instance' );
+	t.strictEqual( binomial instanceof Binomial, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var binomial = Binomial();
-	t.strictEqual( binomial instanceof Binomial, true, 'returns an instance' );
+	t.strictEqual( binomial instanceof Binomial, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	binomial = Binomial( 4, 0.5 );
-	t.strictEqual( binomial instanceof Binomial, true, 'returns an instance' );
+	t.strictEqual( binomial instanceof Binomial, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.factory.js b/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.factory.js
index 03db4189fcda..dfd8b15ebe27 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.factory.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/binomial/quantile/test/test.factory.js
@@ -208,7 +208,7 @@ tape( 'given valid parameters, the created function evaluates the 0% and 100% as
 	quantile = factory( 8, 0.5 );
 
 	y = quantile( 0.0 );
-	t.strictEqual( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = quantile( 1.0 );
 	t.strictEqual( y, 8, 'returns 8' );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cauchy/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cauchy/ctor/test/test.js
index 26f89af323f9..5347e5ef121c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cauchy/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cauchy/ctor/test/test.js
@@ -114,24 +114,24 @@ tape( 'if provided arguments, the function requires both `x0` and `gamma`', func
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var cauchy = new Cauchy();
-	t.strictEqual( cauchy instanceof Cauchy, true, 'returns an instance' );
+	t.strictEqual( cauchy instanceof Cauchy, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var cauchy = new Cauchy( 2.0, 4.0 );
-	t.strictEqual( cauchy instanceof Cauchy, true, 'returns an instance' );
+	t.strictEqual( cauchy instanceof Cauchy, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var cauchy = Cauchy();
-	t.strictEqual( cauchy instanceof Cauchy, true, 'returns an instance' );
+	t.strictEqual( cauchy instanceof Cauchy, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	cauchy = Cauchy( 2.0, 4.0 );
-	t.strictEqual( cauchy instanceof Cauchy, true, 'returns an instance' );
+	t.strictEqual( cauchy instanceof Cauchy, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chi/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chi/ctor/test/test.js
index d9e5c8328938..f6e84c40ecd8 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chi/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chi/ctor/test/test.js
@@ -78,24 +78,24 @@ tape( 'the function throws an error if provided a `k` argument which is not a po
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var chi = new Chi();
-	t.strictEqual( chi instanceof Chi, true, 'returns an instance' );
+	t.strictEqual( chi instanceof Chi, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var chi = new Chi( 2.0 );
-	t.strictEqual( chi instanceof Chi, true, 'returns an instance' );
+	t.strictEqual( chi instanceof Chi, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var chi = Chi();
-	t.strictEqual( chi instanceof Chi, true, 'returns an instance' );
+	t.strictEqual( chi instanceof Chi, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	chi = Chi( 2.0, 4.0 );
-	t.strictEqual( chi instanceof Chi, true, 'returns an instance' );
+	t.strictEqual( chi instanceof Chi, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/chisquare/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/chisquare/ctor/test/test.js
index a85900edb8f0..ef2c515756b0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/chisquare/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/chisquare/ctor/test/test.js
@@ -79,24 +79,24 @@ tape( 'the function throws an error if provided a `k` argument which is not a po
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var chisquare = new ChiSquare();
-	t.strictEqual( chisquare instanceof ChiSquare, true, 'returns an instance' );
+	t.strictEqual( chisquare instanceof ChiSquare, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var chisquare = new ChiSquare( 2.0 );
-	t.strictEqual( chisquare instanceof ChiSquare, true, 'returns an instance' );
+	t.strictEqual( chisquare instanceof ChiSquare, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var chisquare = ChiSquare();
-	t.strictEqual( chisquare instanceof ChiSquare, true, 'returns an instance' );
+	t.strictEqual( chisquare instanceof ChiSquare, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	chisquare = ChiSquare( 2.0, 4.0 );
-	t.strictEqual( chisquare instanceof ChiSquare, true, 'returns an instance' );
+	t.strictEqual( chisquare instanceof ChiSquare, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/ctor/test/test.js
index 86f7151529d9..2707c4e4cdfa 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/ctor/test/test.js
@@ -119,24 +119,24 @@ tape( 'if provided arguments, the function requires both `mu` and `s`', function
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var cosine = new Cosine();
-	t.strictEqual( cosine instanceof Cosine, true, 'returns an instance' );
+	t.strictEqual( cosine instanceof Cosine, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var cosine = new Cosine( 2.0, 4.0 );
-	t.strictEqual( cosine instanceof Cosine, true, 'returns an instance' );
+	t.strictEqual( cosine instanceof Cosine, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var cosine = Cosine();
-	t.strictEqual( cosine instanceof Cosine, true, 'returns an instance' );
+	t.strictEqual( cosine instanceof Cosine, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	cosine = Cosine( 2.0, 4.0 );
-	t.strictEqual( cosine instanceof Cosine, true, 'returns an instance' );
+	t.strictEqual( cosine instanceof Cosine, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/degenerate/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/degenerate/ctor/test/test.js
index 79a2ab41ec66..f0dbd20cbac3 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/degenerate/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/degenerate/ctor/test/test.js
@@ -79,24 +79,24 @@ tape( 'the function throws an error if provided a `mu` argument which is not a n
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var degenerate = new Degenerate();
-	t.strictEqual( degenerate instanceof Degenerate, true, 'returns an instance' );
+	t.strictEqual( degenerate instanceof Degenerate, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var degenerate = new Degenerate( 2.3 );
-	t.strictEqual( degenerate instanceof Degenerate, true, 'returns an instance' );
+	t.strictEqual( degenerate instanceof Degenerate, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var degenerate = Degenerate();
-	t.strictEqual( degenerate instanceof Degenerate, true, 'returns an instance' );
+	t.strictEqual( degenerate instanceof Degenerate, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	degenerate = Degenerate( 0.3 );
-	t.strictEqual( degenerate instanceof Degenerate, true, 'returns an instance' );
+	t.strictEqual( degenerate instanceof Degenerate, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/ctor/test/test.js
index bdf9726eb883..31ea6af67c04 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/discrete-uniform/ctor/test/test.js
@@ -142,24 +142,24 @@ tape( 'if provided arguments, the function requires both `a` and `b`', function
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var discreteUniform = new DiscreteUniform();
-	t.strictEqual( discreteUniform instanceof DiscreteUniform, true, 'returns an instance' );
+	t.strictEqual( discreteUniform instanceof DiscreteUniform, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var discreteUniform = new DiscreteUniform( 2, 4 );
-	t.strictEqual( discreteUniform instanceof DiscreteUniform, true, 'returns an instance' );
+	t.strictEqual( discreteUniform instanceof DiscreteUniform, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var discreteUniform = DiscreteUniform();
-	t.strictEqual( discreteUniform instanceof DiscreteUniform, true, 'returns an instance' );
+	t.strictEqual( discreteUniform instanceof DiscreteUniform, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	discreteUniform = DiscreteUniform( 2, 4 );
-	t.strictEqual( discreteUniform instanceof DiscreteUniform, true, 'returns an instance' );
+	t.strictEqual( discreteUniform instanceof DiscreteUniform, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/erlang/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/erlang/ctor/test/test.js
index ce4d9304fb39..dfe9cf59e04a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/erlang/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/erlang/ctor/test/test.js
@@ -121,24 +121,24 @@ tape( 'if provided arguments, the function requires both `k` and `lambda`', func
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var erlang = new Erlang();
-	t.strictEqual( erlang instanceof Erlang, true, 'returns an instance' );
+	t.strictEqual( erlang instanceof Erlang, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var erlang = new Erlang( 2.0, 4.0 );
-	t.strictEqual( erlang instanceof Erlang, true, 'returns an instance' );
+	t.strictEqual( erlang instanceof Erlang, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var erlang = Erlang();
-	t.strictEqual( erlang instanceof Erlang, true, 'returns an instance' );
+	t.strictEqual( erlang instanceof Erlang, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	erlang = Erlang( 2.0, 4.0 );
-	t.strictEqual( erlang instanceof Erlang, true, 'returns an instance' );
+	t.strictEqual( erlang instanceof Erlang, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/exponential/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/exponential/ctor/test/test.js
index 97f324a923ec..26f13ba640ee 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/exponential/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/exponential/ctor/test/test.js
@@ -81,24 +81,24 @@ tape( 'the function throws an error if provided a `lambda` argument which is not
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var exponential = new Exponential();
-	t.strictEqual( exponential instanceof Exponential, true, 'returns an instance' );
+	t.strictEqual( exponential instanceof Exponential, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var exponential = new Exponential( 2.0 );
-	t.strictEqual( exponential instanceof Exponential, true, 'returns an instance' );
+	t.strictEqual( exponential instanceof Exponential, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var exponential = Exponential();
-	t.strictEqual( exponential instanceof Exponential, true, 'returns an instance' );
+	t.strictEqual( exponential instanceof Exponential, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	exponential = Exponential( 2.0, 4.0 );
-	t.strictEqual( exponential instanceof Exponential, true, 'returns an instance' );
+	t.strictEqual( exponential instanceof Exponential, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/f/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/f/ctor/test/test.js
index 63824011d970..680ae0486c0e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/f/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/f/ctor/test/test.js
@@ -118,24 +118,24 @@ tape( 'if provided arguments, the function requires both `d1` and `d2`', functio
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var f = new F();
-	t.strictEqual( f instanceof F, true, 'returns an instance' );
+	t.strictEqual( f instanceof F, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var f = new F( 2.0, 4.0 );
-	t.strictEqual( f instanceof F, true, 'returns an instance' );
+	t.strictEqual( f instanceof F, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var f = F();
-	t.strictEqual( f instanceof F, true, 'returns an instance' );
+	t.strictEqual( f instanceof F, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	f = F( 2.0, 4.0 );
-	t.strictEqual( f instanceof F, true, 'returns an instance' );
+	t.strictEqual( f instanceof F, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/frechet/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/frechet/ctor/test/test.js
index 02018156a99e..0960ad4dd86e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/frechet/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/frechet/ctor/test/test.js
@@ -151,24 +151,24 @@ tape( 'if provided arguments, the function requires `alpha`, `s`, and `m`', func
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var frechet = new Frechet();
-	t.strictEqual( frechet instanceof Frechet, true, 'returns an instance' );
+	t.strictEqual( frechet instanceof Frechet, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var frechet = new Frechet( 2.0, 4.0, 3.0 );
-	t.strictEqual( frechet instanceof Frechet, true, 'returns an instance' );
+	t.strictEqual( frechet instanceof Frechet, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var frechet = Frechet();
-	t.strictEqual( frechet instanceof Frechet, true, 'returns an instance' );
+	t.strictEqual( frechet instanceof Frechet, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	frechet = Frechet( 2.0, 4.0, 3.0 );
-	t.strictEqual( frechet instanceof Frechet, true, 'returns an instance' );
+	t.strictEqual( frechet instanceof Frechet, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/ctor/test/test.js
index 0101f46eb333..5d904e535f5c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/ctor/test/test.js
@@ -121,24 +121,24 @@ tape( 'if provided arguments, the function requires both `alpha` and `beta`', fu
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var gamma = new Gamma();
-	t.strictEqual( gamma instanceof Gamma, true, 'returns an instance' );
+	t.strictEqual( gamma instanceof Gamma, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var gamma = new Gamma( 2.0, 4.0 );
-	t.strictEqual( gamma instanceof Gamma, true, 'returns an instance' );
+	t.strictEqual( gamma instanceof Gamma, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var gamma = Gamma();
-	t.strictEqual( gamma instanceof Gamma, true, 'returns an instance' );
+	t.strictEqual( gamma instanceof Gamma, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	gamma = Gamma( 2.0, 4.0 );
-	t.strictEqual( gamma instanceof Gamma, true, 'returns an instance' );
+	t.strictEqual( gamma instanceof Gamma, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.quantile.js
index 7ab44e2499a0..48bc5dbd98e0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gamma/quantile/test/test.quantile.js
@@ -115,9 +115,9 @@ tape( 'if provided a nonpositive`beta`, the function returns `NaN`', function te
 
 tape( 'if provided `alpha` equal to `0.0`, the function returns `0.0` for  a valid `p`', function test( t ) {
 	var y = quantile( 0.2, 0.0, 2.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	y = quantile( 0.9, 0.0, 2.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = quantile( 1.1, 0.0, 2.0 );
 	t.strictEqual( isnan( y ), true, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/ctor/test/test.js
index 63eea02cf43d..aa70dfbbe1be 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/ctor/test/test.js
@@ -82,24 +82,24 @@ tape( 'the function throws an error if provided a `p` argument which is not a pr
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var geometric = new Geometric();
-	t.strictEqual( geometric instanceof Geometric, true, 'returns an instance' );
+	t.strictEqual( geometric instanceof Geometric, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var geometric = new Geometric( 0.3 );
-	t.strictEqual( geometric instanceof Geometric, true, 'returns an instance' );
+	t.strictEqual( geometric instanceof Geometric, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var geometric = Geometric();
-	t.strictEqual( geometric instanceof Geometric, true, 'returns an instance' );
+	t.strictEqual( geometric instanceof Geometric, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	geometric = Geometric( 0.3 );
-	t.strictEqual( geometric instanceof Geometric, true, 'returns an instance' );
+	t.strictEqual( geometric instanceof Geometric, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.native.js
index e4e3cc7257ef..de6429f23d4a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.native.js
@@ -70,9 +70,9 @@ tape( 'if provided a number outside `[0,1]` for `r` and a valid `p`, the functio
 
 tape( 'if provided `1.0` for `r` and a valid `p`, the function returns `+Infinity`', opts, function test( t ) {
 	var y = quantile( 1.0, 0.5 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	y = quantile( 1.0, 0.5 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.quantile.js
index 7dd206bb8ca8..71099d8fc5a9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/geometric/quantile/test/test.quantile.js
@@ -61,9 +61,9 @@ tape( 'if provided a number outside `[0,1]` for `r` and a valid `p`, the functio
 
 tape( 'if provided `1.0` for `r` and a valid `p`, the function returns `+Infinity`', function test( t ) {
 	var y = quantile( 1.0, 0.5 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	y = quantile( 1.0, 0.5 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/gumbel/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/gumbel/ctor/test/test.js
index d565079ab470..98d28b2cfc42 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/gumbel/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/gumbel/ctor/test/test.js
@@ -120,24 +120,24 @@ tape( 'if provided arguments, the function requires both `mu` and `beta`', funct
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var gumbel = new Gumbel();
-	t.strictEqual( gumbel instanceof Gumbel, true, 'returns an instance' );
+	t.strictEqual( gumbel instanceof Gumbel, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var gumbel = new Gumbel( 2.0, 4.0 );
-	t.strictEqual( gumbel instanceof Gumbel, true, 'returns an instance' );
+	t.strictEqual( gumbel instanceof Gumbel, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var gumbel = Gumbel();
-	t.strictEqual( gumbel instanceof Gumbel, true, 'returns an instance' );
+	t.strictEqual( gumbel instanceof Gumbel, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	gumbel = Gumbel( 2.0, 4.0 );
-	t.strictEqual( gumbel instanceof Gumbel, true, 'returns an instance' );
+	t.strictEqual( gumbel instanceof Gumbel, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/ctor/test/test.js
index e97cb8def5b2..b4d25864c95b 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/ctor/test/test.js
@@ -183,14 +183,14 @@ tape( 'the function throws an error if `n > N`', function test( t ) {
 
 tape( 'the function returns a new distribution instance', function test( t ) {
 	var hypergeometric = new Hypergeometric( 100, 50, 20 );
-	t.strictEqual( hypergeometric instanceof Hypergeometric, true, 'returns an instance' );
+	t.strictEqual( hypergeometric instanceof Hypergeometric, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var hypergeometric = Hypergeometric( 100, 50, 20 );
-	t.strictEqual( hypergeometric instanceof Hypergeometric, true, 'returns an instance' );
+	t.strictEqual( hypergeometric instanceof Hypergeometric, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.quantile.js
index 6e71828b1e95..2228884eec37 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/hypergeometric/quantile/test/test.quantile.js
@@ -134,7 +134,7 @@ tape( 'if provided an `n` which is not a nonnegative integer, the function retur
 
 tape( 'given valid parameters, the function returns `max( 0, n + K - N )` as the 0% quantile', function test( t ) {
 	var y = quantile( 0.0, 20, 10, 5 );
-	t.strictEqual( y, 0, 'returns 0' );
+	t.strictEqual( y, 0, 'returns expected value' );
 
 	y = quantile( 0.0, 20, 10, 15 );
 	t.strictEqual( y, 5, 'returns 5' );
diff --git a/lib/node_modules/@stdlib/stats/base/dists/invgamma/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/invgamma/ctor/test/test.js
index 9c33300fa65e..a3860e06e772 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/invgamma/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/invgamma/ctor/test/test.js
@@ -119,24 +119,24 @@ tape( 'if provided arguments, the function requires both `alpha` and `beta`', fu
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var invgamma = new InvGamma();
-	t.strictEqual( invgamma instanceof InvGamma, true, 'returns an instance' );
+	t.strictEqual( invgamma instanceof InvGamma, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var invgamma = new InvGamma( 2.0, 4.0 );
-	t.strictEqual( invgamma instanceof InvGamma, true, 'returns an instance' );
+	t.strictEqual( invgamma instanceof InvGamma, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var invgamma = InvGamma();
-	t.strictEqual( invgamma instanceof InvGamma, true, 'returns an instance' );
+	t.strictEqual( invgamma instanceof InvGamma, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	invgamma = InvGamma( 2.0, 4.0 );
-	t.strictEqual( invgamma instanceof InvGamma, true, 'returns an instance' );
+	t.strictEqual( invgamma instanceof InvGamma, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.cdf.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.cdf.js
index 91c83c19ed06..a67260194a87 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.cdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.cdf.js
@@ -50,32 +50,32 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `1`', function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 100.0, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 10.0, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 1.0, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -100.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.native.js
index 0ec75dc12d5b..548c18839842 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/cdf/test/test.native.js
@@ -59,32 +59,32 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `1`', opts, function test( t ) {
 	var y = cdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 100.0, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 10.0, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	y = cdf( 1.0, 0.5, 1.0 );
-	t.strictEqual( y, 1.0, 'returns 1' );
+	t.strictEqual( y, 1.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = cdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -100.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( -1.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = cdf( 0.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/ctor/test/test.js
index 28ce72f826aa..473d4a936c94 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/ctor/test/test.js
@@ -119,24 +119,24 @@ tape( 'if provided arguments, the function requires both `a` and `b`', function
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var kumaraswamy = new Kumaraswamy();
-	t.strictEqual( kumaraswamy instanceof Kumaraswamy, true, 'returns an instance' );
+	t.strictEqual( kumaraswamy instanceof Kumaraswamy, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var kumaraswamy = new Kumaraswamy( 2.0, 4.0 );
-	t.strictEqual( kumaraswamy instanceof Kumaraswamy, true, 'returns an instance' );
+	t.strictEqual( kumaraswamy instanceof Kumaraswamy, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var kumaraswamy = Kumaraswamy();
-	t.strictEqual( kumaraswamy instanceof Kumaraswamy, true, 'returns an instance' );
+	t.strictEqual( kumaraswamy instanceof Kumaraswamy, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	kumaraswamy = Kumaraswamy( 2.0, 4.0 );
-	t.strictEqual( kumaraswamy instanceof Kumaraswamy, true, 'returns an instance' );
+	t.strictEqual( kumaraswamy instanceof Kumaraswamy, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.logcdf.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.logcdf.js
index 247b96c5c61c..01c7712b251e 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.logcdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.logcdf.js
@@ -50,32 +50,32 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `1`', function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 100.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 10.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 1.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -100.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -1.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.native.js
index 15f1a7aa925a..0ac6174fb072 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/logcdf/test/test.native.js
@@ -59,32 +59,32 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `1`', opts, function test( t ) {
 	var y = logcdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 100.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 10.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = logcdf( 1.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `0`', opts, function test( t ) {
 	var y = logcdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -100.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( -1.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	y = logcdf( 0.0, 0.5, 1.0 );
-	t.strictEqual( y, NINF, 'returns -infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.pdf.js b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.pdf.js
index f3acae3794b0..2cf92a51c70c 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.pdf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/kumaraswamy/pdf/test/test.pdf.js
@@ -50,32 +50,32 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 
 tape( 'if provided a number greater than or equal to one for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( PINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 100.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 10.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 1.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'if provided a number less than or equal to zero for `x` and a finite `a` and `b`, the function returns `0`', function test( t ) {
 	var y = pdf( NINF, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -100.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( -1.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	y = pdf( 0.0, 0.5, 1.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/laplace/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/laplace/ctor/test/test.js
index 869ebbf015dc..d4d2e24c2a67 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/laplace/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/laplace/ctor/test/test.js
@@ -120,24 +120,24 @@ tape( 'if provided arguments, the function requires both `mu` and `b`', function
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var laplace = new Laplace();
-	t.strictEqual( laplace instanceof Laplace, true, 'returns an instance' );
+	t.strictEqual( laplace instanceof Laplace, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var laplace = new Laplace( 2.0, 4.0 );
-	t.strictEqual( laplace instanceof Laplace, true, 'returns an instance' );
+	t.strictEqual( laplace instanceof Laplace, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var laplace = Laplace();
-	t.strictEqual( laplace instanceof Laplace, true, 'returns an instance' );
+	t.strictEqual( laplace instanceof Laplace, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	laplace = Laplace( 2.0, 4.0 );
-	t.strictEqual( laplace instanceof Laplace, true, 'returns an instance' );
+	t.strictEqual( laplace instanceof Laplace, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/levy/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/levy/ctor/test/test.js
index a72468f9f79b..3935bc3a6f6f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/levy/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/levy/ctor/test/test.js
@@ -117,24 +117,24 @@ tape( 'if provided arguments, the function requires both `mu` and `c`', function
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var levy = new Levy();
-	t.strictEqual( levy instanceof Levy, true, 'returns an instance' );
+	t.strictEqual( levy instanceof Levy, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var levy = new Levy( 2.0, 4.0 );
-	t.strictEqual( levy instanceof Levy, true, 'returns an instance' );
+	t.strictEqual( levy instanceof Levy, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var levy = Levy();
-	t.strictEqual( levy instanceof Levy, true, 'returns an instance' );
+	t.strictEqual( levy instanceof Levy, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	levy = Levy( 2.0, 4.0 );
-	t.strictEqual( levy instanceof Levy, true, 'returns an instance' );
+	t.strictEqual( levy instanceof Levy, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/logistic/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/logistic/ctor/test/test.js
index 41620f8f129b..c965f3f7245a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/logistic/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/logistic/ctor/test/test.js
@@ -120,24 +120,24 @@ tape( 'if provided arguments, the function requires both `mu` and `s`', function
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var logistic = new Logistic();
-	t.strictEqual( logistic instanceof Logistic, true, 'returns an instance' );
+	t.strictEqual( logistic instanceof Logistic, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var logistic = new Logistic( 2.0, 4.0 );
-	t.strictEqual( logistic instanceof Logistic, true, 'returns an instance' );
+	t.strictEqual( logistic instanceof Logistic, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var logistic = Logistic();
-	t.strictEqual( logistic instanceof Logistic, true, 'returns an instance' );
+	t.strictEqual( logistic instanceof Logistic, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	logistic = Logistic( 2.0, 4.0 );
-	t.strictEqual( logistic instanceof Logistic, true, 'returns an instance' );
+	t.strictEqual( logistic instanceof Logistic, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/lognormal/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/lognormal/ctor/test/test.js
index 0fc2685b1209..a97896e1238d 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/lognormal/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/lognormal/ctor/test/test.js
@@ -119,24 +119,24 @@ tape( 'if provided arguments, the function requires both `mu` and `sigma`', func
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var lognormal = new LogNormal();
-	t.strictEqual( lognormal instanceof LogNormal, true, 'returns an instance' );
+	t.strictEqual( lognormal instanceof LogNormal, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var lognormal = new LogNormal( 2.0, 4.0 );
-	t.strictEqual( lognormal instanceof LogNormal, true, 'returns an instance' );
+	t.strictEqual( lognormal instanceof LogNormal, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var lognormal = LogNormal();
-	t.strictEqual( lognormal instanceof LogNormal, true, 'returns an instance' );
+	t.strictEqual( lognormal instanceof LogNormal, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	lognormal = LogNormal( 2.0, 4.0 );
-	t.strictEqual( lognormal instanceof LogNormal, true, 'returns an instance' );
+	t.strictEqual( lognormal instanceof LogNormal, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/ctor/test/test.js
index 490a6b6704da..cb7552b8e0e4 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/ctor/test/test.js
@@ -121,24 +121,24 @@ tape( 'if provided arguments, the function requires both `r` and `p`', function
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var nbinomial = new NegativeBinomial();
-	t.strictEqual( nbinomial instanceof NegativeBinomial, true, 'returns an instance' );
+	t.strictEqual( nbinomial instanceof NegativeBinomial, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var nbinomial = new NegativeBinomial( 4.0, 0.5 );
-	t.strictEqual( nbinomial instanceof NegativeBinomial, true, 'returns an instance' );
+	t.strictEqual( nbinomial instanceof NegativeBinomial, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var nbinomial = NegativeBinomial();
-	t.strictEqual( nbinomial instanceof NegativeBinomial, true, 'returns an instance' );
+	t.strictEqual( nbinomial instanceof NegativeBinomial, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	nbinomial = NegativeBinomial( 4.0, 0.5 );
-	t.strictEqual( nbinomial instanceof NegativeBinomial, true, 'returns an instance' );
+	t.strictEqual( nbinomial instanceof NegativeBinomial, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.quantile.js
index 089e1ad016e6..5f0b89e031d9 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/negative-binomial/quantile/test/test.quantile.js
@@ -98,10 +98,10 @@ tape( 'if provided a valid `r` and `p`, the function accurately computes the 0%
 	var y;
 
 	y = quantile( 1.0, 20, 0.5 );
-	t.strictEqual( y, PINF, 'returns +Infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 
 	y = quantile( 0.0, 20, 0.5 );
-	t.strictEqual( y, 0.0, 'returns 0.0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/normal/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/normal/ctor/test/test.js
index 07dc6f94c810..08fd77853822 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/normal/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/normal/ctor/test/test.js
@@ -120,24 +120,24 @@ tape( 'if provided arguments, the function requires both `mu` and `sigma`', func
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var normal = new Normal();
-	t.strictEqual( normal instanceof Normal, true, 'returns an instance' );
+	t.strictEqual( normal instanceof Normal, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var normal = new Normal( 2.0, 4.0 );
-	t.strictEqual( normal instanceof Normal, true, 'returns an instance' );
+	t.strictEqual( normal instanceof Normal, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var normal = Normal();
-	t.strictEqual( normal instanceof Normal, true, 'returns an instance' );
+	t.strictEqual( normal instanceof Normal, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	normal = Normal( 2.0, 4.0 );
-	t.strictEqual( normal instanceof Normal, true, 'returns an instance' );
+	t.strictEqual( normal instanceof Normal, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/ctor/test/test.js
index 427830936550..184c6b87326a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/pareto-type1/ctor/test/test.js
@@ -120,24 +120,24 @@ tape( 'if provided arguments, the function requires both `alpha` and `beta`', fu
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var pareto1 = new Pareto1();
-	t.strictEqual( pareto1 instanceof Pareto1, true, 'returns an instance' );
+	t.strictEqual( pareto1 instanceof Pareto1, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var pareto1 = new Pareto1( 2.0, 4.0 );
-	t.strictEqual( pareto1 instanceof Pareto1, true, 'returns an instance' );
+	t.strictEqual( pareto1 instanceof Pareto1, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var pareto1 = Pareto1();
-	t.strictEqual( pareto1 instanceof Pareto1, true, 'returns an instance' );
+	t.strictEqual( pareto1 instanceof Pareto1, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	pareto1 = Pareto1( 2.0, 4.0 );
-	t.strictEqual( pareto1 instanceof Pareto1, true, 'returns an instance' );
+	t.strictEqual( pareto1 instanceof Pareto1, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.logpmf.js b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.logpmf.js
index 578ca310e170..47fa6b24597f 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.logpmf.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.logpmf.js
@@ -53,7 +53,7 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', functio
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `-Infinity`', function test( t ) {
 	var y = logpmf( PINF, 0.01 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.native.js b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.native.js
index 3f79ab371804..17497ad92a88 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.native.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/planck/logpmf/test/test.native.js
@@ -62,7 +62,7 @@ tape( 'if provided `NaN` for any parameter, the function returns `NaN`', opts, f
 
 tape( 'if provided `+infinity` for `x` and a valid `lambda`, the function returns `-Infinity`', opts, function test( t ) {
 	var y = logpmf( PINF, 0.01 );
-	t.strictEqual( y, NINF, 'returns -Infinity' );
+	t.strictEqual( y, NINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/ctor/test/test.js
index 2c3083810f0e..26687ecafb55 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/ctor/test/test.js
@@ -80,24 +80,24 @@ tape( 'the function throws an error if provided a `lambda` argument which is not
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var poisson = new Poisson();
-	t.strictEqual( poisson instanceof Poisson, true, 'returns an instance' );
+	t.strictEqual( poisson instanceof Poisson, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var poisson = new Poisson( 2.0 );
-	t.strictEqual( poisson instanceof Poisson, true, 'returns an instance' );
+	t.strictEqual( poisson instanceof Poisson, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var poisson = Poisson();
-	t.strictEqual( poisson instanceof Poisson, true, 'returns an instance' );
+	t.strictEqual( poisson instanceof Poisson, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	poisson = Poisson( 2.0, 4.0 );
-	t.strictEqual( poisson instanceof Poisson, true, 'returns an instance' );
+	t.strictEqual( poisson instanceof Poisson, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.quantile.js b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.quantile.js
index 97be1e7cb849..9b4394e69181 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.quantile.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/poisson/quantile/test/test.quantile.js
@@ -60,17 +60,17 @@ tape( 'if provided a number outside `[0,1]` for `p` and a finite `lambda`, the f
 
 tape( 'if provided `p = 0` and a finite `lambda`, the function returns `0`', function test( t ) {
 	var y = quantile( 0.0, 3.0 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	y = quantile( 0.0, 6.9 );
-	t.strictEqual( y, 0.0, 'returns 0' );
+	t.strictEqual( y, 0.0, 'returns expected value' );
 	t.end();
 });
 
 tape( 'if provided `p = 1` and a finite `lambda`, the function returns `+infinity`', function test( t ) {
 	var y = quantile( 1.0, 3.0 );
-	t.strictEqual( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	y = quantile( 1.0, 6.9 );
-	t.strictEqual( y, PINF, 'returns +infinity' );
+	t.strictEqual( y, PINF, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/ctor/test/test.js
index e2155d4c618d..75987e2124a0 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/rayleigh/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/rayleigh/ctor/test/test.js
@@ -81,24 +81,24 @@ tape( 'the function throws an error if provided a `sigma` argument which is not
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var rayleigh = new Rayleigh();
-	t.strictEqual( rayleigh instanceof Rayleigh, true, 'returns an instance' );
+	t.strictEqual( rayleigh instanceof Rayleigh, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var rayleigh = new Rayleigh( 2.0 );
-	t.strictEqual( rayleigh instanceof Rayleigh, true, 'returns an instance' );
+	t.strictEqual( rayleigh instanceof Rayleigh, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var rayleigh = Rayleigh();
-	t.strictEqual( rayleigh instanceof Rayleigh, true, 'returns an instance' );
+	t.strictEqual( rayleigh instanceof Rayleigh, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	rayleigh = Rayleigh( 2.0, 4.0 );
-	t.strictEqual( rayleigh instanceof Rayleigh, true, 'returns an instance' );
+	t.strictEqual( rayleigh instanceof Rayleigh, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/t/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/t/ctor/test/test.js
index b75992e7b0b6..6ae46c87faba 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/t/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/t/ctor/test/test.js
@@ -80,24 +80,24 @@ tape( 'the function throws an error if provided a `v` argument which is not a po
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var dist = new T();
-	t.strictEqual( dist instanceof T, true, 'returns an instance' );
+	t.strictEqual( dist instanceof T, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var dist = new T( 2.0 );
-	t.strictEqual( dist instanceof T, true, 'returns an instance' );
+	t.strictEqual( dist instanceof T, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var dist = T();
-	t.strictEqual( dist instanceof T, true, 'returns an instance' );
+	t.strictEqual( dist instanceof T, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	dist = T( 2.0, 4.0 );
-	t.strictEqual( dist instanceof T, true, 'returns an instance' );
+	t.strictEqual( dist instanceof T, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/triangular/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/triangular/ctor/test/test.js
index 40c399bf4056..d647905c2c29 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/triangular/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/triangular/ctor/test/test.js
@@ -177,24 +177,24 @@ tape( 'if provided arguments, the function requires `a`, `b`, and `c`', function
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var triangular = new Triangular();
-	t.strictEqual( triangular instanceof Triangular, true, 'returns an instance' );
+	t.strictEqual( triangular instanceof Triangular, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var triangular = new Triangular( 2.0, 4.0, 3.0 );
-	t.strictEqual( triangular instanceof Triangular, true, 'returns an instance' );
+	t.strictEqual( triangular instanceof Triangular, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var triangular = Triangular();
-	t.strictEqual( triangular instanceof Triangular, true, 'returns an instance' );
+	t.strictEqual( triangular instanceof Triangular, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	triangular = Triangular( 2.0, 4.0, 3.0 );
-	t.strictEqual( triangular instanceof Triangular, true, 'returns an instance' );
+	t.strictEqual( triangular instanceof Triangular, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/uniform/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/uniform/ctor/test/test.js
index 4cc5dd1ae3f5..ae725d212562 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/uniform/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/uniform/ctor/test/test.js
@@ -140,24 +140,24 @@ tape( 'if provided arguments, the function requires both `a` and `b`', function
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var uniform = new Uniform();
-	t.strictEqual( uniform instanceof Uniform, true, 'returns an instance' );
+	t.strictEqual( uniform instanceof Uniform, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var uniform = new Uniform( 2.0, 4.0 );
-	t.strictEqual( uniform instanceof Uniform, true, 'returns an instance' );
+	t.strictEqual( uniform instanceof Uniform, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var uniform = Uniform();
-	t.strictEqual( uniform instanceof Uniform, true, 'returns an instance' );
+	t.strictEqual( uniform instanceof Uniform, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	uniform = Uniform( 2.0, 4.0 );
-	t.strictEqual( uniform instanceof Uniform, true, 'returns an instance' );
+	t.strictEqual( uniform instanceof Uniform, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/ctor/test/test.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/ctor/test/test.js
index 5f4a33fcf135..658be2d447c2 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/ctor/test/test.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/ctor/test/test.js
@@ -121,24 +121,24 @@ tape( 'if provided arguments, the function requires both `k` and `lambda`', func
 
 tape( 'the function returns a new distribution instance (default parameters)', function test( t ) {
 	var weibull = new Weibull();
-	t.strictEqual( weibull instanceof Weibull, true, 'returns an instance' );
+	t.strictEqual( weibull instanceof Weibull, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a new distribution instance (custom parameters)', function test( t ) {
 	var weibull = new Weibull( 2.0, 4.0 );
-	t.strictEqual( weibull instanceof Weibull, true, 'returns an instance' );
+	t.strictEqual( weibull instanceof Weibull, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function can be invoked without the new operator', function test( t ) {
 	// eslint-disable-next-line new-cap
 	var weibull = Weibull();
-	t.strictEqual( weibull instanceof Weibull, true, 'returns an instance' );
+	t.strictEqual( weibull instanceof Weibull, true, 'returns expected value' );
 
 	// eslint-disable-next-line new-cap
 	weibull = Weibull( 2.0, 4.0 );
-	t.strictEqual( weibull instanceof Weibull, true, 'returns an instance' );
+	t.strictEqual( weibull instanceof Weibull, true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/apcorr/test/test.js b/lib/node_modules/@stdlib/stats/incr/apcorr/test/test.js
index e569e0e6aa3c..c021d767f8f4 100644
--- a/lib/node_modules/@stdlib/stats/incr/apcorr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/apcorr/test/test.js
@@ -250,10 +250,10 @@ tape( 'the sample absolute correlation coefficient is `0` until at least 2 datum
 	acc = incrapcorr();
 
 	v = acc( 2.0, 10.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = acc();
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, 0.0, 'does not return 0' );
diff --git a/lib/node_modules/@stdlib/stats/incr/covariance/test/test.js b/lib/node_modules/@stdlib/stats/incr/covariance/test/test.js
index 6a7c56b0caf1..91d30b73bd26 100644
--- a/lib/node_modules/@stdlib/stats/incr/covariance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/covariance/test/test.js
@@ -250,10 +250,10 @@ tape( 'the sample covariance is `0` until at least 2 datums have been provided (
 	acc = incrcovariance();
 
 	v = acc( 2.0, 10.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = acc();
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, 0.0, 'does not return 0' );
diff --git a/lib/node_modules/@stdlib/stats/incr/cv/test/test.js b/lib/node_modules/@stdlib/stats/incr/cv/test/test.js
index 6d7d534166cf..45d678a7b5aa 100644
--- a/lib/node_modules/@stdlib/stats/incr/cv/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/cv/test/test.js
@@ -200,10 +200,10 @@ tape( 'the accumulated value is `0` until at least 2 datums have been provided (
 	acc = incrcv();
 
 	cv = acc( 2.0 );
-	t.strictEqual( cv, 0.0, 'returns 0' );
+	t.strictEqual( cv, 0.0, 'returns expected value' );
 
 	cv = acc();
-	t.strictEqual( cv, 0.0, 'returns 0' );
+	t.strictEqual( cv, 0.0, 'returns expected value' );
 
 	cv = acc( 3.0 );
 	t.notEqual( cv, 0.0, 'does not return 0' );
diff --git a/lib/node_modules/@stdlib/stats/incr/mapcorr/test/test.js b/lib/node_modules/@stdlib/stats/incr/mapcorr/test/test.js
index 9e082a2db32e..118da31bfa13 100644
--- a/lib/node_modules/@stdlib/stats/incr/mapcorr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mapcorr/test/test.js
@@ -530,7 +530,7 @@ tape( 'if data has yet to be provided, the accumulator function returns `null` (
 tape( 'if only one datum has been provided and the means are unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmapcorr( 3 );
 	acc( 2.0, 3.14 );
-	t.strictEqual( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -549,7 +549,7 @@ tape( 'if the window size is `1` and the means are unknown, the accumulator func
 	acc = incrmapcorr( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		r = acc( randu()*100.0, randu()*100.0 );
-		t.strictEqual( r, 0.0, 'returns 0' );
+		t.strictEqual( r, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mcovariance/test/test.js b/lib/node_modules/@stdlib/stats/incr/mcovariance/test/test.js
index 4c9e94d726a1..dbf225c4f9c4 100644
--- a/lib/node_modules/@stdlib/stats/incr/mcovariance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mcovariance/test/test.js
@@ -464,7 +464,7 @@ tape( 'if data has yet to be provided, the accumulator function returns `null` (
 tape( 'if only one datum has been provided and the means are unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmcovariance( 3 );
 	acc( 2.0, 3.14 );
-	t.strictEqual( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -483,7 +483,7 @@ tape( 'if the window size is `1` and the means are unknown, the accumulator func
 	acc = incrmcovariance( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		cov = acc( randu()*100.0, randu()*100.0 );
-		t.strictEqual( cov, 0.0, 'returns 0' );
+		t.strictEqual( cov, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mcv/test/test.js b/lib/node_modules/@stdlib/stats/incr/mcv/test/test.js
index 8d12f12eed63..d5450c8c7c08 100644
--- a/lib/node_modules/@stdlib/stats/incr/mcv/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mcv/test/test.js
@@ -263,7 +263,7 @@ tape( 'if data has yet to be provided, the accumulator function returns `null` (
 tape( 'if only one datum has been provided and the mean is unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmcv( 3 );
 	acc( 2.0 );
-	t.strictEqual( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -282,7 +282,7 @@ tape( 'if the window size is `1` and the mean is unknown, the accumulator functi
 	acc = incrmcv( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		cv = acc( randu() * 100.0 );
-		t.strictEqual( cv, 0.0, 'returns 0' );
+		t.strictEqual( cv, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mpcorr/test/test.js b/lib/node_modules/@stdlib/stats/incr/mpcorr/test/test.js
index 3db8bd9b8913..cbf436ff57dc 100644
--- a/lib/node_modules/@stdlib/stats/incr/mpcorr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mpcorr/test/test.js
@@ -530,7 +530,7 @@ tape( 'if data has yet to be provided, the accumulator function returns `null` (
 tape( 'if only one datum has been provided and the means are unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmpcorr( 3 );
 	acc( 2.0, 3.14 );
-	t.strictEqual( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -549,7 +549,7 @@ tape( 'if the window size is `1` and the means are unknown, the accumulator func
 	acc = incrmpcorr( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		r = acc( randu()*100.0, randu()*100.0 );
-		t.strictEqual( r, 0.0, 'returns 0' );
+		t.strictEqual( r, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mpcorr2/test/test.js b/lib/node_modules/@stdlib/stats/incr/mpcorr2/test/test.js
index fb163d154924..1f41f512726b 100644
--- a/lib/node_modules/@stdlib/stats/incr/mpcorr2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mpcorr2/test/test.js
@@ -532,7 +532,7 @@ tape( 'if data has yet to be provided, the accumulator function returns `null` (
 tape( 'if only one datum has been provided and the means are unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmpcorr2( 3 );
 	acc( 2.0, 3.14 );
-	t.strictEqual( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -551,7 +551,7 @@ tape( 'if the window size is `1` and the means are unknown, the accumulator func
 	acc = incrmpcorr2( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		r = acc( randu()*100.0, randu()*100.0 );
-		t.strictEqual( r, 0.0, 'returns 0' );
+		t.strictEqual( r, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mpcorrdist/test/test.js b/lib/node_modules/@stdlib/stats/incr/mpcorrdist/test/test.js
index 853e3f6aae42..73700752d7eb 100644
--- a/lib/node_modules/@stdlib/stats/incr/mpcorrdist/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mpcorrdist/test/test.js
@@ -549,7 +549,7 @@ tape( 'if data has yet to be provided, the accumulator function returns `null` (
 tape( 'if only one datum has been provided and the means are unknown, the accumulator function returns `1`', function test( t ) {
 	var acc = incrmpcorrdist( 3 );
 	acc( 2.0, 3.14 );
-	t.strictEqual( acc(), 1.0, 'returns 1' );
+	t.strictEqual( acc(), 1.0, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/stats/incr/mstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/mstdev/test/test.js
index ab38efd567c0..23342c69c8cc 100644
--- a/lib/node_modules/@stdlib/stats/incr/mstdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mstdev/test/test.js
@@ -263,7 +263,7 @@ tape( 'if data has yet to be provided, the accumulator function returns `null` (
 tape( 'if only one datum has been provided and the mean is unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmstdev( 3 );
 	acc( 2.0 );
-	t.strictEqual( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -282,7 +282,7 @@ tape( 'if the window size is `1` and the mean is unknown, the accumulator functi
 	acc = incrmstdev( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		s = acc( randu() * 100.0 );
-		t.strictEqual( s, 0.0, 'returns 0' );
+		t.strictEqual( s, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mvariance/test/test.js b/lib/node_modules/@stdlib/stats/incr/mvariance/test/test.js
index 74227b949d0d..49e0b9636976 100644
--- a/lib/node_modules/@stdlib/stats/incr/mvariance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mvariance/test/test.js
@@ -256,7 +256,7 @@ tape( 'if data has yet to be provided, the accumulator function returns `null` (
 tape( 'if only one datum has been provided and the mean is unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmvariance( 3 );
 	acc( 2.0 );
-	t.strictEqual( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -275,7 +275,7 @@ tape( 'if the window size is `1` and the mean is unknown, the accumulator functi
 	acc = incrmvariance( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		s2 = acc( randu() * 100.0 );
-		t.strictEqual( s2, 0.0, 'returns 0' );
+		t.strictEqual( s2, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/mvmr/test/test.js b/lib/node_modules/@stdlib/stats/incr/mvmr/test/test.js
index bddc3f4a7b63..4bad49acf09e 100644
--- a/lib/node_modules/@stdlib/stats/incr/mvmr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/mvmr/test/test.js
@@ -262,7 +262,7 @@ tape( 'if data has yet to be provided, the accumulator function returns `null` (
 tape( 'if only one datum has been provided and the mean is unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrmvmr( 3 );
 	acc( 2.0 );
-	t.strictEqual( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -281,7 +281,7 @@ tape( 'if the window size is `1` and the mean is unknown, the accumulator functi
 	acc = incrmvmr( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		F = acc( randu() * 100.0 );
-		t.strictEqual( F, 0.0, 'returns 0' );
+		t.strictEqual( F, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/nanmstdev/test/test.js b/lib/node_modules/@stdlib/stats/incr/nanmstdev/test/test.js
index 09e15762c4fc..38a7fad61df3 100644
--- a/lib/node_modules/@stdlib/stats/incr/nanmstdev/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/nanmstdev/test/test.js
@@ -262,7 +262,7 @@ tape( 'if data has yet to be provided, the accumulator function returns `null` (
 tape( 'if only one datum has been provided and the mean is unknown, the accumulator function returns `0`', function test( t ) {
 	var acc = incrnanmstdev( 3 );
 	acc( 2.0 );
-	t.strictEqual( acc(), 0.0, 'returns 0' );
+	t.strictEqual( acc(), 0.0, 'returns expected value' );
 	t.end();
 });
 
@@ -281,7 +281,7 @@ tape( 'if the window size is `1` and the mean is unknown, the accumulator functi
 	acc = incrnanmstdev( 1 );
 	for ( i = 0; i < 100; i++ ) {
 		s = acc( randu() * 100.0 );
-		t.strictEqual( s, 0.0, 'returns 0' );
+		t.strictEqual( s, 0.0, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/stats/incr/pcorr/test/test.js b/lib/node_modules/@stdlib/stats/incr/pcorr/test/test.js
index e967ad519d57..5366dbbbd73f 100644
--- a/lib/node_modules/@stdlib/stats/incr/pcorr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/pcorr/test/test.js
@@ -250,10 +250,10 @@ tape( 'the sample correlation coefficient is `0` until at least 2 datums have be
 	acc = incrpcorr();
 
 	v = acc( 2.0, 10.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = acc();
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, 0.0, 'does not return 0' );
diff --git a/lib/node_modules/@stdlib/stats/incr/pcorr2/test/test.js b/lib/node_modules/@stdlib/stats/incr/pcorr2/test/test.js
index 694b6f3e4206..f86d7473b2d1 100644
--- a/lib/node_modules/@stdlib/stats/incr/pcorr2/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/pcorr2/test/test.js
@@ -250,10 +250,10 @@ tape( 'the squared sample correlation coefficient is `0` until at least 2 datums
 	acc = incrpcorr2();
 
 	v = acc( 2.0, 10.0 );
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = acc();
-	t.strictEqual( v, 0.0, 'returns 0' );
+	t.strictEqual( v, 0.0, 'returns expected value' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, 0.0, 'does not return 0' );
diff --git a/lib/node_modules/@stdlib/stats/incr/pcorrdist/test/test.js b/lib/node_modules/@stdlib/stats/incr/pcorrdist/test/test.js
index 5304db137ae2..a1f8ee4caaa4 100644
--- a/lib/node_modules/@stdlib/stats/incr/pcorrdist/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/pcorrdist/test/test.js
@@ -244,7 +244,7 @@ tape( 'the sample correlation distance is `1` until at least 2 datums have been
 	acc = incrpcorrdist();
 
 	v = acc( 2.0, 10.0 );
-	t.strictEqual( v, 1.0, 'returns 1' );
+	t.strictEqual( v, 1.0, 'returns expected value' );
 
 	v = acc( 3.0, -3.14 );
 	t.notEqual( v, 1.0, 'does not return 1' );
diff --git a/lib/node_modules/@stdlib/stats/incr/variance/test/test.js b/lib/node_modules/@stdlib/stats/incr/variance/test/test.js
index 91a28cf57af8..707ebacfb4c0 100644
--- a/lib/node_modules/@stdlib/stats/incr/variance/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/variance/test/test.js
@@ -199,10 +199,10 @@ tape( 'the sample variance is `0` until at least 2 datums have been provided (un
 	acc = incrvariance();
 
 	s2 = acc( 2.0 );
-	t.strictEqual( s2, 0.0, 'returns 0' );
+	t.strictEqual( s2, 0.0, 'returns expected value' );
 
 	s2 = acc();
-	t.strictEqual( s2, 0.0, 'returns 0' );
+	t.strictEqual( s2, 0.0, 'returns expected value' );
 
 	s2 = acc( 3.0 );
 	t.notEqual( s2, 0.0, 'does not return 0' );
diff --git a/lib/node_modules/@stdlib/stats/incr/vmr/test/test.js b/lib/node_modules/@stdlib/stats/incr/vmr/test/test.js
index 3c36edcce7d1..ce59c03a40d5 100644
--- a/lib/node_modules/@stdlib/stats/incr/vmr/test/test.js
+++ b/lib/node_modules/@stdlib/stats/incr/vmr/test/test.js
@@ -199,10 +199,10 @@ tape( 'the accumulated value is `0` until at least 2 datums have been provided (
 	acc = incrvmr();
 
 	D = acc( 2.0 );
-	t.strictEqual( D, 0.0, 'returns 0' );
+	t.strictEqual( D, 0.0, 'returns expected value' );
 
 	D = acc();
-	t.strictEqual( D, 0.0, 'returns 0' );
+	t.strictEqual( D, 0.0, 'returns expected value' );
 
 	D = acc( 3.0 );
 	t.notEqual( D, 0.0, 'does not return 0' );
diff --git a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js
index f5ceb9960b75..b8fd77892f34 100644
--- a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js
@@ -139,7 +139,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	});
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 'beep', noop ) instanceof DebugSinkStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 'beep', noop ) instanceof DebugSinkStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.object_mode.js
index f83034b8642c..8a0f1a4cd67b 100644
--- a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.object_mode.js
@@ -144,7 +144,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode();
-	t.strictEqual( stream instanceof DebugSinkStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof DebugSinkStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js
index 20038ce6d7be..ec99f9eec97b 100644
--- a/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js
@@ -140,7 +140,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	});
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 'beep', noop ) instanceof DebugStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 'beep', noop ) instanceof DebugStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/debug/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/debug/test/test.object_mode.js
index 2aba6d882db3..e13ecc697713 100644
--- a/lib/node_modules/@stdlib/streams/node/debug/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/debug/test/test.object_mode.js
@@ -142,7 +142,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode();
-	t.strictEqual( stream instanceof DebugStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof DebugStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/empty/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/empty/test/test.factory.js
index cb8984a69190..eb62dd451505 100644
--- a/lib/node_modules/@stdlib/streams/node/empty/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/empty/test/test.factory.js
@@ -110,7 +110,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof EmptyStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof EmptyStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -122,7 +122,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	createStream = factory( {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof EmptyStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof EmptyStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/empty/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/empty/test/test.object_mode.js
index d5c39083166e..da3347dc518b 100644
--- a/lib/node_modules/@stdlib/streams/node/empty/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/empty/test/test.object_mode.js
@@ -36,7 +36,7 @@ tape( 'main export is a function', function test( t ) {
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode();
-	t.strictEqual( s instanceof EmptyStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof EmptyStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-array/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-array/test/test.factory.js
index fea7a34d8983..ab44eb32fc74 100644
--- a/lib/node_modules/@stdlib/streams/node/from-array/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-array/test/test.factory.js
@@ -172,7 +172,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	arr = [ 1, 2, 3 ];
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( arr ) instanceof ArrayStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( arr ) instanceof ArrayStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -186,7 +186,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	arr = [ 1, 2, 3 ];
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( arr ) instanceof ArrayStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( arr ) instanceof ArrayStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-array/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/from-array/test/test.object_mode.js
index 11ecfe553a71..53b0e3c228fc 100644
--- a/lib/node_modules/@stdlib/streams/node/from-array/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/from-array/test/test.object_mode.js
@@ -122,13 +122,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( [ 1, 2, 3 ] );
-	t.strictEqual( s instanceof ArrayStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof ArrayStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( [ 1, 2, 3 ], {} );
-	t.strictEqual( s instanceof ArrayStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof ArrayStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.factory.js
index 06fb9f0c30c2..f0b592d38904 100644
--- a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.factory.js
@@ -172,7 +172,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	arr = [ 1, 2, 3 ];
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( arr ) instanceof CircularArrayStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( arr ) instanceof CircularArrayStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -186,7 +186,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	arr = [ 1, 2, 3 ];
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( arr ) instanceof CircularArrayStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( arr ) instanceof CircularArrayStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.object_mode.js
index 2f46b1a4a8b3..31ac5d0c4854 100644
--- a/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/from-circular-array/test/test.object_mode.js
@@ -122,13 +122,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( [ 1, 2, 3 ] );
-	t.strictEqual( s instanceof CircularArrayStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof CircularArrayStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( [ 1, 2, 3 ], {} );
-	t.strictEqual( s instanceof CircularArrayStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof CircularArrayStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.factory.js
index ea39b70bcb2f..5841926cd2fb 100644
--- a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.factory.js
@@ -283,7 +283,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 'beep' ) instanceof ConstantStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 'beep' ) instanceof ConstantStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -297,7 +297,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	});
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( 'beep' ) instanceof ConstantStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( 'beep' ) instanceof ConstantStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -309,7 +309,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 'beep' );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof ConstantStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof ConstantStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -321,7 +321,7 @@ tape( 'the function returns a factory function which creates stream instances (p
 	createStream = factory( 'beep', {} );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof ConstantStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof ConstantStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.object_mode.js
index 7eac5a4d6835..ce74d77bc26e 100644
--- a/lib/node_modules/@stdlib/streams/node/from-constant/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/from-constant/test/test.object_mode.js
@@ -126,13 +126,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 'beep' );
-	t.strictEqual( s instanceof ConstantStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof ConstantStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 'beep', {} );
-	t.strictEqual( s instanceof ConstantStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof ConstantStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.factory.js
index e3e0fe7e9082..3c0e6049d951 100644
--- a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.factory.js
@@ -173,7 +173,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	it = array2iterator( [ 1, 2, 3 ] );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( it ) instanceof IteratorStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( it ) instanceof IteratorStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -187,7 +187,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	it = array2iterator( [ 1, 2, 3 ] );
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( it ) instanceof IteratorStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( it ) instanceof IteratorStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.object_mode.js
index 22e1cdb68b8c..5bc453761561 100644
--- a/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/from-iterator/test/test.object_mode.js
@@ -124,13 +124,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( array2iterator( [ 1, 2, 3 ] ) );
-	t.strictEqual( s instanceof IteratorStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof IteratorStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( array2iterator( [ 1, 2, 3 ] ), {} );
-	t.strictEqual( s instanceof IteratorStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof IteratorStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.factory.js
index 82a07ee16350..5eadcd1d78ef 100644
--- a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.factory.js
@@ -356,7 +356,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	arr = [ 1, 2, 3 ];
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( arr.length, arr, 1, 0 ) instanceof StridedArrayStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( arr.length, arr, 1, 0 ) instanceof StridedArrayStream, true, 'returns expected value' );
 	}
 	t.end();
 });
@@ -370,7 +370,7 @@ tape( 'the function returns a factory function which creates stream instances (o
 	arr = [ 1, 2, 3 ];
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( arr.length, arr, 1, 0 ) instanceof StridedArrayStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( arr.length, arr, 1, 0 ) instanceof StridedArrayStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.object_mode.js
index 1a04a0adaf77..5893435827fc 100644
--- a/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/from-strided-array/test/test.object_mode.js
@@ -211,13 +211,13 @@ tape( 'if provided an invalid readable stream option, the function throws an err
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var s = objectMode( 3, [ 1, 2, 3 ], 1, 0 );
-	t.strictEqual( s instanceof StridedArrayStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof StridedArrayStream, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function returns a stream instance (options)', function test( t ) {
 	var s = objectMode( 3, [ 1, 2, 3 ], 1, 0, {} );
-	t.strictEqual( s instanceof StridedArrayStream, true, 'returns a stream instance' );
+	t.strictEqual( s instanceof StridedArrayStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.factory.js
index 72d0706a19e7..8b315c640416 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.factory.js
@@ -112,7 +112,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( noop ) instanceof InspectSinkStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( noop ) instanceof InspectSinkStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.object_mode.js
index 427f85065cc4..59438e9f7565 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect-sink/test/test.object_mode.js
@@ -119,7 +119,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode( noop );
-	t.strictEqual( stream instanceof InspectSinkStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof InspectSinkStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/inspect/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/inspect/test/test.factory.js
index cc5908111684..147e58ab5da2 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect/test/test.factory.js
@@ -112,7 +112,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( noop ) instanceof InspectStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( noop ) instanceof InspectStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/inspect/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/inspect/test/test.object_mode.js
index e6085e038868..74e286b96818 100644
--- a/lib/node_modules/@stdlib/streams/node/inspect/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/inspect/test/test.object_mode.js
@@ -119,7 +119,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode( noop );
-	t.strictEqual( stream instanceof InspectStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof InspectStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/join/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/join/test/test.factory.js
index c7f712a3d09c..fd65715fb780 100644
--- a/lib/node_modules/@stdlib/streams/node/join/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/join/test/test.factory.js
@@ -81,7 +81,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof JoinStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof JoinStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/join/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/join/test/test.object_mode.js
index 960fb7901daf..bbd828aec63a 100644
--- a/lib/node_modules/@stdlib/streams/node/join/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/join/test/test.object_mode.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode();
-	t.strictEqual( stream instanceof JoinStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof JoinStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/split/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/split/test/test.factory.js
index 58dc45856dfb..503abf2d064a 100644
--- a/lib/node_modules/@stdlib/streams/node/split/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/split/test/test.factory.js
@@ -81,7 +81,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream() instanceof SplitStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream() instanceof SplitStream, true, 'returns expected value' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/split/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/split/test/test.object_mode.js
index 2564cbad7867..94261a47ef7e 100644
--- a/lib/node_modules/@stdlib/streams/node/split/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/split/test/test.object_mode.js
@@ -64,7 +64,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode();
-	t.strictEqual( stream instanceof SplitStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof SplitStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/streams/node/transform/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/transform/test/test.factory.js
index bf4616ed0085..533dbad635e1 100644
--- a/lib/node_modules/@stdlib/streams/node/transform/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/transform/test/test.factory.js
@@ -140,11 +140,11 @@ tape( 'the function returns a factory function which creates stream instances',
 
 	// Provide just a transform function...
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( noop ) instanceof TransformStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( noop ) instanceof TransformStream, true, 'returns expected value' );
 	}
 	// Provide both transform and flush functions...
 	for ( i = 0; i < 10; i++ ) {
-		t.strictEqual( createStream( noop, noop ) instanceof TransformStream, true, 'returns a stream instance' );
+		t.strictEqual( createStream( noop, noop ) instanceof TransformStream, true, 'returns expected value' );
 	}
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/streams/node/transform/test/test.object_mode.js b/lib/node_modules/@stdlib/streams/node/transform/test/test.object_mode.js
index 2955bddfbaa0..4c9638c42d41 100644
--- a/lib/node_modules/@stdlib/streams/node/transform/test/test.object_mode.js
+++ b/lib/node_modules/@stdlib/streams/node/transform/test/test.object_mode.js
@@ -63,7 +63,7 @@ tape( 'the function throws an error if provided an options argument which is not
 
 tape( 'the function returns a stream instance', function test( t ) {
 	var stream = objectMode();
-	t.strictEqual( stream instanceof TransformStream, true, 'returns a stream instance' );
+	t.strictEqual( stream instanceof TransformStream, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/string/split-grapheme-clusters/test/test.js b/lib/node_modules/@stdlib/string/split-grapheme-clusters/test/test.js
index ec04dda63730..28910b57c40f 100644
--- a/lib/node_modules/@stdlib/string/split-grapheme-clusters/test/test.js
+++ b/lib/node_modules/@stdlib/string/split-grapheme-clusters/test/test.js
@@ -61,7 +61,7 @@ tape( 'the function throws an error if not provided a string', function test( t
 });
 
 tape( 'the function returns an empty array if provided an empty string', function test( t ) {
-	t.deepEqual( splitGraphemeClusters( '' ), [], 'returns an empty array' );
+	t.deepEqual( splitGraphemeClusters( '' ), [], 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/async/bifurcate-by/test/test.main.js b/lib/node_modules/@stdlib/utils/async/bifurcate-by/test/test.main.js
index 23ec33b549df..63980219bdbe 100644
--- a/lib/node_modules/@stdlib/utils/async/bifurcate-by/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/async/bifurcate-by/test/test.main.js
@@ -950,7 +950,7 @@ tape( 'if provided an empty collection, the function never invokes a predicate f
 		} else {
 			t.pass( 'did not return an error' );
 		}
-		t.deepEqual( result, [], 'returns an empty array' );
+		t.deepEqual( result, [], 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.factory.js b/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.factory.js
index 24f5e05d7e2b..cbf812f0655a 100644
--- a/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.factory.js
+++ b/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.factory.js
@@ -138,7 +138,7 @@ tape( 'the function returns a function which immediately returns an error to a p
 		next();
 	}
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( error.message, 'boop', 'equal message' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.main.js b/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.main.js
index e9372c19d65c..be409a590996 100644
--- a/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/async/series-waterfall/test/test.main.js
@@ -129,7 +129,7 @@ tape( 'the function immediately returns an error to a provided callback', functi
 		next();
 	}
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( error.message, 'boop', 'equal message' );
 		t.end();
 	}
diff --git a/lib/node_modules/@stdlib/utils/deep-pluck/test/test.js b/lib/node_modules/@stdlib/utils/deep-pluck/test/test.js
index 830eb09aac55..e890a88f9c20 100644
--- a/lib/node_modules/@stdlib/utils/deep-pluck/test/test.js
+++ b/lib/node_modules/@stdlib/utils/deep-pluck/test/test.js
@@ -77,7 +77,7 @@ tape( 'the function returns an empty array if provided an empty array', function
 	var out;
 
 	out = deepPluck( [], 'a.b.c' );
-	t.deepEqual( out, [], 'returns an empty array' );
+	t.deepEqual( out, [], 'returns expected value' );
 
 	out = deepPluck( [], ['a', 'b', 'c'], {
 		'copy': false
diff --git a/lib/node_modules/@stdlib/utils/from-entries/test/test.js b/lib/node_modules/@stdlib/utils/from-entries/test/test.js
index 3a774d7a89c7..1dffc937d213 100644
--- a/lib/node_modules/@stdlib/utils/from-entries/test/test.js
+++ b/lib/node_modules/@stdlib/utils/from-entries/test/test.js
@@ -84,7 +84,7 @@ tape( 'the function returns an object created from key-value pairs', function te
 
 	actual = objectFromEntries( entries );
 
-	t.strictEqual( isPlainObject( actual ), true, 'returns a plain object' );
+	t.strictEqual( isPlainObject( actual ), true, 'returns expected value' );
 	t.notEqual( actual, expected, 'different object references' );
 	t.strictEqual( actual.a, expected.a, 'same object references' );
 	t.strictEqual( actual.foo, expected.foo, 'same object references' );
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.main.js b/lib/node_modules/@stdlib/utils/parallel/test/test.main.js
index 97581bcab884..195d871e9def 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.main.js
@@ -250,7 +250,7 @@ tape( 'the function returns an error to the provided callback if an error is enc
 
 	function done( error ) {
 		if ( error ) {
-			t.ok( true, 'returns an error' );
+			t.ok( true, 'returns expected value' );
 		} else {
 			t.ok( false, 'failed to return an error' );
 		}
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.node.exec.js b/lib/node_modules/@stdlib/utils/parallel/test/test.node.exec.js
index d44011380f4e..1f0256973fb7 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.node.exec.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.node.exec.js
@@ -186,7 +186,7 @@ tape( 'the function returns the first encountered error to a provided callback',
 	}
 
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( error.message, 'error: 3', 'expected error message' );
 		t.end();
 	}
@@ -226,7 +226,7 @@ tape( 'the function returns an error to a provided callback if a worker exits wi
 	}
 
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( error.code, 1, 'sets exit code' );
 		t.strictEqual( error.signal, null, 'sets signal' );
 		t.end();
@@ -267,7 +267,7 @@ tape( 'the function returns an error to a provided callback if a worker exits du
 	}
 
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( error.code, null, 'sets exit code' );
 		t.strictEqual( error.signal, 'SIGINT', 'sets signal' );
 		t.end();
@@ -308,7 +308,7 @@ tape( 'the function returns an error to a provided callback if a worker closes w
 	}
 
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( error.code, 1, 'sets exit code' );
 		t.strictEqual( error.signal, null, 'sets signal' );
 		t.end();
@@ -349,7 +349,7 @@ tape( 'the function returns an error to a provided callback if a worker closes d
 	}
 
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( error.code, null, 'sets exit code' );
 		t.strictEqual( error.signal, 'SIGINT', 'sets signal' );
 		t.end();
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.exec.js b/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.exec.js
index aea40c8926ec..66008cd17115 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.exec.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.exec.js
@@ -130,7 +130,7 @@ tape( 'the function calls a callback with an error if an error is encountered wh
 	}
 
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
diff --git a/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.spawn.js b/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.spawn.js
index 5a81bf73bfb6..c4fb6390e4e3 100644
--- a/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.spawn.js
+++ b/lib/node_modules/@stdlib/utils/parallel/test/test.node.worker.spawn.js
@@ -117,7 +117,7 @@ tape( 'the function calls a callback with an error if an error is encountered wh
 	}
 
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.end();
 	}
 });
@@ -144,7 +144,7 @@ tape( 'the function calls a callback with an error if the process exits with a n
 	}
 
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( error.code, 1, 'sets `code` property' );
 		t.strictEqual( error.signal, null, 'sets `signal` property' );
 		t.end();
@@ -173,7 +173,7 @@ tape( 'the function calls a callback with an error if the process exits due to a
 	}
 
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( error.code, null, 'sets `code` property' );
 		t.strictEqual( error.signal, 'SIGINT', 'sets `signal` property' );
 		t.end();
@@ -201,7 +201,7 @@ tape( 'the function calls a callback with an error if the process closes with a
 	}
 
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( error.code, 2, 'sets `code` property' );
 		t.strictEqual( error.signal, null, 'sets `signal` property' );
 		t.end();
@@ -229,7 +229,7 @@ tape( 'the function calls a callback with an error if the process closes due to
 	}
 
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( error.code, null, 'sets `code` property' );
 		t.strictEqual( error.signal, 'SIGINT', 'sets `signal` property' );
 		t.end();
@@ -258,7 +258,7 @@ tape( 'the function calls a callback with an error if the process exits/closes w
 	}
 
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( error.code, 1, 'sets `code` property' );
 		t.strictEqual( error.signal, null, 'sets `signal` property' );
 		t.end();
@@ -287,7 +287,7 @@ tape( 'the function calls a callback with an error if the process exits/closes d
 	}
 
 	function done( error ) {
-		t.ok( error, 'returns an error' );
+		t.ok( error, 'returns expected value' );
 		t.strictEqual( error.code, null, 'sets `code` property' );
 		t.strictEqual( error.signal, 'SIGINT', 'sets `signal` property' );
 		t.end();
diff --git a/lib/node_modules/@stdlib/utils/parse-json/test/test.js b/lib/node_modules/@stdlib/utils/parse-json/test/test.js
index 14b6bc6cf52b..adff80c542f4 100644
--- a/lib/node_modules/@stdlib/utils/parse-json/test/test.js
+++ b/lib/node_modules/@stdlib/utils/parse-json/test/test.js
@@ -141,7 +141,7 @@ tape( 'the function returns a JSON value if provided valid JSON', function test(
 
 tape( 'the function returns an error if provided invalid JSON', function test( t ) {
 	var out = parseJSON( '{"beep":"boop}' );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/parse-ndjson/test/test.js b/lib/node_modules/@stdlib/utils/parse-ndjson/test/test.js
index d146e59e2cf1..1c2bfe7de43a 100644
--- a/lib/node_modules/@stdlib/utils/parse-ndjson/test/test.js
+++ b/lib/node_modules/@stdlib/utils/parse-ndjson/test/test.js
@@ -135,14 +135,14 @@ tape( 'the function returns an array of parsed values if provided valid NDJSON',
 	expected = [];
 	actual = parseNDJSON('');
 
-	t.deepEqual( actual, expected, 'returns an empty array' );
+	t.deepEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function returns an error if provided invalid NDJSON', function test( t ) {
 	var out = parseNDJSON( '{"beep":"boop"' );
-	t.strictEqual( out instanceof SyntaxError, true, 'returns an error' );
+	t.strictEqual( out instanceof SyntaxError, true, 'returns expected value' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/pluck/test/test.js b/lib/node_modules/@stdlib/utils/pluck/test/test.js
index 532be110ee41..854072a0dda0 100644
--- a/lib/node_modules/@stdlib/utils/pluck/test/test.js
+++ b/lib/node_modules/@stdlib/utils/pluck/test/test.js
@@ -75,7 +75,7 @@ tape( 'the function returns an empty array if provided an empty array', function
 	var out;
 
 	out = pluck( [], 'a' );
-	t.deepEqual( out, [], 'returns an empty array' );
+	t.deepEqual( out, [], 'returns expected value' );
 
 	out = pluck( [], 'a', {
 		'copy': false
diff --git a/lib/node_modules/@stdlib/utils/pop/test/test.js b/lib/node_modules/@stdlib/utils/pop/test/test.js
index 07f0be3b8b72..bd0a8d21022d 100644
--- a/lib/node_modules/@stdlib/utils/pop/test/test.js
+++ b/lib/node_modules/@stdlib/utils/pop/test/test.js
@@ -77,12 +77,12 @@ tape( 'the function returns a two-element array', function test( t ) {
 
 	arr = [ 1.0, 2.0, 3.0 ];
 	out = pop( arr );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 2, 'output array has length 2' );
 
 	arr = new Float32Array( [ 1.0, 2.0, 3.0 ] );
 	out = pop( arr );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 2, 'output array has length 2' );
 
 	arr = {
@@ -92,7 +92,7 @@ tape( 'the function returns a two-element array', function test( t ) {
 		'2': 3.0
 	};
 	out = pop( arr );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 2, 'output array has length 2' );
 
 	t.end();
@@ -104,13 +104,13 @@ tape( 'if provided an empty collection, the element value is `undefined`', funct
 
 	arr = [];
 	out = pop( arr );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 2, 'output array has length 2' );
 	t.strictEqual( out[ 1 ], void 0, 'element is `undefined`' );
 
 	arr = new Float32Array();
 	out = pop( arr );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 2, 'output array has length 2' );
 	t.strictEqual( out[ 1 ], void 0, 'element is `undefined`' );
 
@@ -118,7 +118,7 @@ tape( 'if provided an empty collection, the element value is `undefined`', funct
 		'length': 0
 	};
 	out = pop( arr );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 2, 'output array has length 2' );
 	t.strictEqual( out[ 1 ], void 0, 'element is `undefined`' );
 
diff --git a/lib/node_modules/@stdlib/utils/shift/test/test.js b/lib/node_modules/@stdlib/utils/shift/test/test.js
index eb3ae5f76eb9..2a32c033a6fe 100644
--- a/lib/node_modules/@stdlib/utils/shift/test/test.js
+++ b/lib/node_modules/@stdlib/utils/shift/test/test.js
@@ -77,12 +77,12 @@ tape( 'the function returns a two-element array', function test( t ) {
 
 	arr = [ 1.0, 2.0, 3.0 ];
 	out = shift( arr );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 2, 'output array has length 2' );
 
 	arr = new Float32Array( [ 1.0, 2.0, 3.0 ] );
 	out = shift( arr );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 2, 'output array has length 2' );
 
 	arr = {
@@ -92,7 +92,7 @@ tape( 'the function returns a two-element array', function test( t ) {
 		'2': 3.0
 	};
 	out = shift( arr );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 2, 'output array has length 2' );
 
 	t.end();
@@ -104,13 +104,13 @@ tape( 'if provided an empty collection, the element value is `undefined`', funct
 
 	arr = [];
 	out = shift( arr );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 2, 'output array has length 2' );
 	t.strictEqual( out[ 1 ], void 0, 'element is `undefined`' );
 
 	arr = new Float32Array();
 	out = shift( arr );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 2, 'output array has length 2' );
 	t.strictEqual( out[ 1 ], void 0, 'element is `undefined`' );
 
@@ -118,7 +118,7 @@ tape( 'if provided an empty collection, the element value is `undefined`', funct
 		'length': 0
 	};
 	out = shift( arr );
-	t.strictEqual( isArray( out ), true, 'returns an array' );
+	t.strictEqual( isArray( out ), true, 'returns expected value' );
 	t.strictEqual( out.length, 2, 'output array has length 2' );
 	t.strictEqual( out[ 1 ], void 0, 'element is `undefined`' );
 
diff --git a/lib/node_modules/@stdlib/utils/timeit/test/test.main.js b/lib/node_modules/@stdlib/utils/timeit/test/test.main.js
index 8c5af85e5df4..80527fe15089 100644
--- a/lib/node_modules/@stdlib/utils/timeit/test/test.main.js
+++ b/lib/node_modules/@stdlib/utils/timeit/test/test.main.js
@@ -210,7 +210,7 @@ tape( 'the function returns an error to a provided callback if a snippet errors'
 
 	function done( error ) {
 		if ( error ) {
-			t.ok( true, 'returns an error' );
+			t.ok( true, 'returns expected value' );
 		} else {
 			t.ok( false, 'did not return an error' );
 		}
@@ -224,7 +224,7 @@ tape( 'the function returns an error to a provided callback if a snippet errors'
 
 	function done( error ) {
 		if ( error ) {
-			t.ok( true, 'returns an error' );
+			t.ok( true, 'returns expected value' );
 		} else {
 			t.ok( false, 'did not return an error' );
 		}
@@ -237,7 +237,7 @@ tape( 'the function returns an error to a provided callback if a snippet early r
 
 	function done( error ) {
 		if ( error ) {
-			t.ok( true, 'returns an error' );
+			t.ok( true, 'returns expected value' );
 		} else {
 			t.ok( false, 'did not return an error' );
 		}
@@ -258,7 +258,7 @@ tape( 'the function returns an error to a provided callback if an asynchronous s
 
 	function done( error ) {
 		if ( error ) {
-			t.ok( true, 'returns an error' );
+			t.ok( true, 'returns expected value' );
 		} else {
 			t.ok( false, 'did not return an error' );
 		}
@@ -279,7 +279,7 @@ tape( 'the function returns an error to a provided callback if an asynchronous c
 
 	function done( error ) {
 		if ( error ) {
-			t.ok( true, 'returns an error' );
+			t.ok( true, 'returns expected value' );
 		} else {
 			t.ok( false, 'did not return an error' );
 		}
@@ -295,7 +295,7 @@ tape( 'the function returns an error to a provided callback if an asynchronous c
 
 	function done( error ) {
 		if ( error ) {
-			t.ok( true, 'returns an error' );
+			t.ok( true, 'returns expected value' );
 		} else {
 			t.ok( false, 'did not return an error' );
 		}
@@ -318,7 +318,7 @@ tape( 'the function returns an error to a provided callback if timing results ar
 
 	function done( error ) {
 		if ( error ) {
-			t.ok( true, 'returns an error' );
+			t.ok( true, 'returns expected value' );
 		} else {
 			t.ok( false, 'did not return an error' );
 		}
@@ -341,7 +341,7 @@ tape( 'the function returns an error to a provided callback if the timing result
 
 	function done( error ) {
 		if ( error ) {
-			t.ok( true, 'returns an error' );
+			t.ok( true, 'returns expected value' );
 		} else {
 			t.ok( false, 'did not return an error' );
 		}
@@ -374,7 +374,7 @@ tape( 'the function returns an error to a provided callback if an error is retur
 
 	function done( error ) {
 		if ( error ) {
-			t.ok( true, 'returns an error' );
+			t.ok( true, 'returns expected value' );
 		} else {
 			t.ok( false, 'did not return an error' );
 		}
@@ -408,7 +408,7 @@ tape( 'the function returns an error to a provided callback if an error is retur
 
 	function done( error ) {
 		if ( error ) {
-			t.ok( true, 'returns an error' );
+			t.ok( true, 'returns expected value' );
 		} else {
 			t.ok( false, 'did not return an error' );
 		}
diff --git a/lib/node_modules/@stdlib/utils/try-require/test/test.js b/lib/node_modules/@stdlib/utils/try-require/test/test.js
index 07ef01ed8560..55f43a2d2611 100644
--- a/lib/node_modules/@stdlib/utils/try-require/test/test.js
+++ b/lib/node_modules/@stdlib/utils/try-require/test/test.js
@@ -48,34 +48,34 @@ tape( 'the function returns a resolved module', function test( t ) {
 
 tape( 'the function returns an error if unable to resolve a module', function test( t ) {
 	var out = tryRequire( '_abcdefghijklmnopqrstuvwxyz12345678999999999999_' );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.end();
 });
 
 tape( 'the function handles the throwing of literals (string)', function test( t ) {
 	var out = tryRequire( join( __dirname, './fixtures/string.js' ) );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.strictEqual( out.message, 'beep', 'sets error message' );
 	t.end();
 });
 
 tape( 'the function handles the throwing of literals (number)', function test( t ) {
 	var out = tryRequire( join( __dirname, './fixtures/number.js' ) );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.strictEqual( out.message, '3.14', 'sets error message' );
 	t.end();
 });
 
 tape( 'the function handles the throwing of literals (boolean)', function test( t ) {
 	var out = tryRequire( join( __dirname, './fixtures/boolean.js' ) );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.strictEqual( out.message, 'false', 'sets error message' );
 	t.end();
 });
 
 tape( 'the function handles the throwing of literals (object)', function test( t ) {
 	var out = tryRequire( join( __dirname, './fixtures/object.js' ) );
-	t.strictEqual( out instanceof Error, true, 'returns an error' );
+	t.strictEqual( out instanceof Error, true, 'returns expected value' );
 	t.strictEqual( out.message, '{"beep":"boop"}', 'sets error message' );
 	t.end();
 });

From 97f0e11fad5ac045777328c45d2ff595f568a5e0 Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Thu, 14 Aug 2025 18:58:00 -0500
Subject: [PATCH 18/32] chore: use canonical format for JSDoc union types

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../_tools/repl-txt/rules/resolvable-aliases/lib/main.js    | 2 +-
 .../test-validate-js/test/fixtures/validate.js_3.txt        | 2 +-
 .../@stdlib/fs/resolve-parent-paths/lib/sync.js             | 4 ++--
 .../@stdlib/utils/library-manifest/lib/validate.js          | 2 +-
 lib/node_modules/@stdlib/utils/parse-ndjson/lib/main.js     | 2 +-
 lib/node_modules/@stdlib/utils/try-function/lib/main.js     | 6 +++---
 lib/node_modules/@stdlib/utils/try-require/lib/main.js      | 2 +-
 7 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/lib/node_modules/@stdlib/_tools/repl-txt/rules/resolvable-aliases/lib/main.js b/lib/node_modules/@stdlib/_tools/repl-txt/rules/resolvable-aliases/lib/main.js
index 3dc4a1051a54..cfcf108b33fb 100644
--- a/lib/node_modules/@stdlib/_tools/repl-txt/rules/resolvable-aliases/lib/main.js
+++ b/lib/node_modules/@stdlib/_tools/repl-txt/rules/resolvable-aliases/lib/main.js
@@ -49,7 +49,7 @@ function countLines( str ) {
 *
 * @private
 * @param {string} pkg - package path
-* @returns {string|null} package alias
+* @returns {(string|null)} package alias
 */
 function pkg2alias( pkg ) {
 	var i;
diff --git a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/validate.js_3.txt b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/validate.js_3.txt
index 53c6e7379c92..976ebf083d91 100644
--- a/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/validate.js_3.txt
+++ b/lib/node_modules/@stdlib/_tools/scaffold/test-validate-js/test/fixtures/validate.js_3.txt
@@ -39,7 +39,7 @@ var format = require( '@stdlib/string/format' );
 * @param {(Buffer|string)} [options.html] - HTML content to serve
 * @param {(Buffer|string)} [options.javascript] - JavaScript script to serve
 * @param {boolean} [options.open] - indicates whether to launch a web browser
-* @returns {Error|null} error or null
+* @returns {(Error|null)} error or null
 *
 * @example
 * var options = {
diff --git a/lib/node_modules/@stdlib/fs/resolve-parent-paths/lib/sync.js b/lib/node_modules/@stdlib/fs/resolve-parent-paths/lib/sync.js
index 252fd4d34558..a195cd9ad15a 100644
--- a/lib/node_modules/@stdlib/fs/resolve-parent-paths/lib/sync.js
+++ b/lib/node_modules/@stdlib/fs/resolve-parent-paths/lib/sync.js
@@ -143,7 +143,7 @@ function all( paths, dir ) {
 * @private
 * @param {Array<string>} paths - paths to resolve
 * @param {string} dir - base directory
-* @returns {Array<string|null>} resolved paths
+* @returns {Array<(string|null)>} resolved paths
 */
 function each( paths, dir ) {
 	var count;
@@ -189,7 +189,7 @@ function each( paths, dir ) {
 * @throws {TypeError} first argument must be an array of strings
 * @throws {TypeError} options argument must be an object
 * @throws {TypeError} must provide valid options
-* @returns {Array<string|null>} resolved paths
+* @returns {Array<(string|null)>} resolved paths
 *
 * @example
 * var paths = resolveParentPaths( [ 'package.json', 'package-lock.json' ] );
diff --git a/lib/node_modules/@stdlib/utils/library-manifest/lib/validate.js b/lib/node_modules/@stdlib/utils/library-manifest/lib/validate.js
index f78daea38729..1ec488efc17e 100644
--- a/lib/node_modules/@stdlib/utils/library-manifest/lib/validate.js
+++ b/lib/node_modules/@stdlib/utils/library-manifest/lib/validate.js
@@ -39,7 +39,7 @@ var hasOwnProp = Object.prototype.hasOwnProperty;
 * @param {Options} options - function options
 * @param {string} [options.basedir] - base search directory
 * @param {string} [options.paths] - path convention
-* @returns {Error|null} error or null
+* @returns {(Error|null)} error or null
 *
 * @example
 * var options = {
diff --git a/lib/node_modules/@stdlib/utils/parse-ndjson/lib/main.js b/lib/node_modules/@stdlib/utils/parse-ndjson/lib/main.js
index 59554ed9d215..ae0de0987d49 100644
--- a/lib/node_modules/@stdlib/utils/parse-ndjson/lib/main.js
+++ b/lib/node_modules/@stdlib/utils/parse-ndjson/lib/main.js
@@ -37,7 +37,7 @@ var reEOL = require( '@stdlib/regexp/eol' );
 * @param {Function} [reviver] - transformation function applied to each line
 * @throws {TypeError} first argument must be a string
 * @throws {TypeError} reviver must be a function
-* @returns {Array|Error} array of parsed values or an error
+* @returns {(Array|Error)} array of parsed values or an error
 *
 * @example
 * var out = parseNDJSON( '{"name":"John"}\n{"name":"Doe"}' );
diff --git a/lib/node_modules/@stdlib/utils/try-function/lib/main.js b/lib/node_modules/@stdlib/utils/try-function/lib/main.js
index 2d1a19accd63..7c3a43a8c193 100644
--- a/lib/node_modules/@stdlib/utils/try-function/lib/main.js
+++ b/lib/node_modules/@stdlib/utils/try-function/lib/main.js
@@ -65,7 +65,7 @@ function wrap( fcn, thisArg ) {
 	*
 	* @private
 	* @param {...*} [args] - function arguments
-	* @returns {*|Error} returned value or an error object
+	* @returns {(*|Error)} returned value or an error object
 	*/
 	function wrapped() {
 		var args;
@@ -73,9 +73,9 @@ function wrap( fcn, thisArg ) {
 		var i;
 
 		len = arguments.length;
-		args = new Array( len );
+		args = [];
 		for ( i = 0; i < len; i++ ) {
-			args[ i ] = arguments[ i ];
+			args.push( arguments[ i ] );
 		}
 		try {
 			return fcn.apply( ctx, args );
diff --git a/lib/node_modules/@stdlib/utils/try-require/lib/main.js b/lib/node_modules/@stdlib/utils/try-require/lib/main.js
index 0660a69c9c18..1ef7fff01573 100644
--- a/lib/node_modules/@stdlib/utils/try-require/lib/main.js
+++ b/lib/node_modules/@stdlib/utils/try-require/lib/main.js
@@ -29,7 +29,7 @@ var isError = require( '@stdlib/assert/is-error' );
 * Wraps `require` in a try/catch block.
 *
 * @param {string} id - module id
-* @returns {*|Error} `module.exports` of the resolved module or an error
+* @returns {(*|Error)} `module.exports` of the resolved module or an error
 *
 * @example
 * var out = tryRequire( 'beepboop' );

From 4754d60576057a62db0c9c99bfa2b886676b4530 Mon Sep 17 00:00:00 2001
From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com>
Date: Thu, 14 Aug 2025 22:03:58 -0500
Subject: [PATCH 19/32] docs: update REPL namespace documentation

PR-URL: https://github.com/stdlib-js/stdlib/pull/7879

Reviewed-by: Philipp Burckhardt <pburckhardt@outlook.com>
Signed-off-by: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com>
---
 lib/node_modules/@stdlib/repl/data/contributor.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/node_modules/@stdlib/repl/data/contributor.json b/lib/node_modules/@stdlib/repl/data/contributor.json
index 8e061d7d16b6..4f1419acc62a 100644
--- a/lib/node_modules/@stdlib/repl/data/contributor.json
+++ b/lib/node_modules/@stdlib/repl/data/contributor.json
@@ -1 +1 @@
-["Aadish Jain","Aarya Balwadkar","Aayush Khanna","Abdelrahman Samir","Abdul Kaium","Abhay Punia","Abhijit Raut","Abhishek G","Abhishek Jain","Adarsh Palaskar","Aditya Sapra","Aditya Singh","Ahmed Atwa","Ahmed Kashkoush","Ahmed Khaled","Aksshay Balasubramanian","Aleksandr","Ali Salesi","AlyAbdelmoneim","Aman Bhansali","AmanBhadkariya","Amisha Chhajed","Amit Jimiwal","Anmol Sah","Annamalai Prabu","Anshu Kumar","Anshu Kumar","Anudeep Sanapala","Arihant Pal","Aryan Bhirud","AryanJ18","Athan Reines","Atharva Patil","Ayaka","Bhavishy Agrawal","Brendan Graetz","Bruno Fenzl","Bryan Elee","Chinmay Joshi","Christopher Dambamuromo","Dan Rose","Daniel Hernandez Gomez","Daniel Killenberger","Daniel Yu","Debashis Maharana","Deep Trivedi","Deepak Singh","Deepak Singh","Desh Deepak Kant","Dev Goel","Dhanyabad behera","Dhruv Arvind Singh","Dhruvil Mehta","Dipjyoti Das","Divyansh Seth","Dominic Lim","Dominik Moritz","Dorrin Sotoudeh","EuniceSim142","Frank Kovacs","GK Bishnoi","GURU PRASAD SHARMA","Gaurav","Gautam Kaushik","Gautam sharma","GeoDaoyu","Girish Garg","Golden Kumar","Gunj Joshi","Gururaj Gurram","Harishchandra Reddy","Haroon Rasheed","Harsh","HarshaNP","Harshita Kalani","Hemang Choudhary","Hemant M Mehta","Hridyanshu","Jaimin Godhani","Jaison D Souza","Jalaj Kumar","James Gelok","Jay Soni","Jaysukh Makvana","Jenish Thapa","Jithin KS","Joel Mathew Koshy","Joey Reed","Jordan Gallivan","Joris Labie","Justin Dennison","Justyn Shelby","Karan Anand","Karan Vasudevamurthy","Karan Yadav","Karthik Prakash","Kaushikgtm","Kavyansh-Bagdi","Kohantika Nath","Krishnam Agarwal","Krishnendu Das","Kshitij-Dale","Lalit Narayan Yadav","Lokesh Ranjan","Lovelin Dhoni J B","MANI","Mahfuza Humayra Mohona","Manik Sharma","Manvith M","Marcus Fantham","Matt Cochrane","Mihir Pandit","Milan Raj","Mohammad Bin Aftab","Mohammad Kaif","Momtchil Momtchev","Muhammad Haris","Muhammad Taaha Tariq","Muhmmad Saad","NEEKUorAAYUSH","Nakul Krishnakumar","Naresh Jagadeesan","Naveen Kumar","Neeraj Pathak","NirvedMishra","Nishant Shinde","Nishant singh","Nishchay Rajput","Nithin Katta","Nourhan Hasan","Ognjen Jevremović","Oneday12323","Ori Miles","Philipp Burckhardt","Pierre Forstmann","Pradyumn Prasad","Prajjwal Bajpai","Prajwal Kulkarni","Pranav Goswami","Pranjal Jha","Prashant Kumar Yadav","PrathamBhamare","Pratik Singh","Pratyush Kumar Chouhan","Pravesh Kunwar","Priyansh Prajapati","Priyanshu Agarwal","Pulkit Gupta","Pushpendra Chandravanshi","Rahul Kumar","Raunak Kumar Gupta","Rejoan Sardar","Ricky Reusser","Ridam Garg","Rishav","Rishav Tarway","Robert Gislason","Roman Stetsyk","Rupa","Rutam Kathale","Ruthwik Chikoti","Ryan Seal","Rylan Yang","SAHIL KUMAR","SHIVAM YADAV","Sachin Raj","Sahil Goyal","Sai Avinash","Sai Srikar Dumpeti","Sanchay Ketan Sinha","Sarthak Paandey","Satyajeet Chavan","Saurabh Singh","Seyyed Parsa Neshaei","Shabareesh Shetty","Shashank Shekhar Singh","Shivam Ahir","Shivansh","Shraddheya Shendre","Shubh Mehta","Shubham Mishra","Siddhesh waje","Sivam Das","Snehil Shah","Soumajit Chatterjee","Spandan Barve","Stephannie Jiménez Gacha","Suhaib Ilahi","Suraj Kumar","Swapnil Hajare","Tanishq Ahuja","Tirtadwipa Manunggal","Tudor Pagu","Tufailahmed Bargir","Tushar Bhardwaj","Uday Kakade","Ujjwal Kirti","Utkarsh","Utkarsh Raj","UtkershBasnet","Vaibhav Patel","Vansh Choudhary","Vara Rahul Rajana","Varad Gupta","Vinit Pandit","Vivek Maurya","Wendy Yuchen Sun","Xiaochuan Ye","Yaswanth Kosuru","Yernar Yergaziyev","Yugal Kaushik","Yuvi Mittal","deepak427","devshree-bhati","ditsu","ekambains","fadiothman22","iraandrushko","jsai28","lohithganni","olenkabilonizhka","pranav-1720","rahulrangers","rainn","rei2hu","zhanggy"]
+["Aadish Jain","Aarya Balwadkar","Aayush Khanna","Abdelrahman Samir","Abdul Kaium","Abhay Punia","Abhijit Raut","Abhishek G","Abhishek Jain","Adarsh Palaskar","Aditya Sapra","Aditya Singh","Ahmed Atwa","Ahmed Kashkoush","Ahmed Khaled","Aksshay Balasubramanian","Aleksandr","Ali Salesi","AlyAbdelmoneim","Aman Bhansali","AmanBhadkariya","Amisha Chhajed","Amit Jimiwal","Anmol Sah","Annamalai Prabu","Anshu Kumar","Anshu Kumar","Anudeep Sanapala","Arihant Pal","Aryan Bhirud","AryanJ18","Athan Reines","Atharva Patil","Ayaka","Bhavishy Agrawal","Brendan Graetz","Bruno Fenzl","Bryan Elee","Chinmay Joshi","Christopher Dambamuromo","Dan Rose","Daniel Hernandez Gomez","Daniel Killenberger","Daniel Yu","Debashis Maharana","Deep Trivedi","Deepak Singh","Deepak Singh","Desh Deepak Kant","Dev Goel","Dhanyabad behera","Dhruv Arvind Singh","Dhruvil Mehta","Dipjyoti Das","Divyansh Seth","Dominic Lim","Dominik Moritz","Dorrin Sotoudeh","EuniceSim142","Frank Kovacs","GK Bishnoi","GURU PRASAD SHARMA","Gaurav","Gautam Kaushik","Gautam sharma","GeoDaoyu","Girish Garg","Golden Kumar","Gunj Joshi","Gururaj Gurram","Harishchandra Reddy","Haroon Rasheed","Harsh","HarshaNP","Harshita Kalani","Hemang Choudhary","Hemant M Mehta","Hridyanshu","Jaimin Godhani","Jaison D Souza","Jalaj Kumar","James Gelok","Jay Soni","Jaysukh Makvana","Jenish Thapa","Jithin KS","Joel Mathew Koshy","Joey Reed","Jordan Gallivan","Joris Labie","Justin Dennison","Justyn Shelby","Karan Anand","Karan Vasudevamurthy","Karan Yadav","Karthik Prakash","Kaushikgtm","Kavyansh-Bagdi","Kohantika Nath","Krishnam Agarwal","Krishnendu Das","Kshitij-Dale","Lalit Narayan Yadav","Lokesh Ranjan","Lovelin Dhoni J B","MANI","Mahfuza Humayra Mohona","Manik Sharma","Manvith M","Marcus Fantham","Matt Cochrane","Mihir Pandit","Milan Raj","Mohammad Bin Aftab","Mohammad Kaif","Momtchil Momtchev","Muhammad Haris","Muhammad Taaha Tariq","Muhmmad Saad","NEEKUorAAYUSH","Nakul Krishnakumar","Naresh Jagadeesan","Naveen Kumar","Neeraj Pathak","NirvedMishra","Nishant Shinde","Nishant singh","Nishchay Rajput","Nithin Katta","Nourhan Hasan","Ognjen Jevremović","Oneday12323","Ori Miles","Philipp Burckhardt","Pierre Forstmann","Pradyumn Prasad","Prajjwal Bajpai","Prajwal Kulkarni","Pranav Goswami","Pranjal Jha","Prashant Kumar Yadav","PrathamBhamare","Pratik Singh","Pratyush Kumar Chouhan","Pravesh Kunwar","Priyansh Prajapati","Priyanshu Agarwal","Pulkit Gupta","Pushpendra Chandravanshi","Rahul Kumar","Raunak Kumar Gupta","Rejoan Sardar","Ricky Reusser","Ridam Garg","Rishav","Rishav Tarway","Robert Gislason","Roman Stetsyk","Rupa","Rutam Kathale","Ruthwik Chikoti","Ryan Seal","Rylan Yang","SAHIL KUMAR","SAUJANYA MAGARDE","SHIVAM YADAV","Sachin Raj","Sahil Goyal","Sai Avinash","Sai Srikar Dumpeti","Sanchay Ketan Sinha","Sarthak Paandey","Satyajeet Chavan","Saurabh Singh","Seyyed Parsa Neshaei","Shabareesh Shetty","Shashank Shekhar Singh","Shivam Ahir","Shivansh","Shraddheya Shendre","Shubh Mehta","Shubham Mishra","Siddhesh waje","Sivam Das","Snehil Shah","Soumajit Chatterjee","Spandan Barve","Stephannie Jiménez Gacha","Suhaib Ilahi","Suraj Kumar","Swapnil Hajare","Tanishq Ahuja","Tirtadwipa Manunggal","Tudor Pagu","Tufailahmed Bargir","Tushar Bhardwaj","Uday Kakade","Ujjwal Kirti","Utkarsh","Utkarsh Raj","UtkershBasnet","Vaibhav Patel","Vansh Choudhary","Vara Rahul Rajana","Varad Gupta","Vinit Pandit","Vivek Maurya","Wendy Yuchen Sun","Xiaochuan Ye","Yaswanth Kosuru","Yernar Yergaziyev","Yugal Kaushik","Yuvi Mittal","deepak427","devshree-bhati","ditsu","ekambains","fadiothman22","iraandrushko","jsai28","lohithganni","olenkabilonizhka","pranav-1720","rahulrangers","rainn","rei2hu","zhanggy"]

From c6df9e8b5a6349b8c877902ef44564f7c3196de6 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Fri, 15 Aug 2025 02:13:53 -0700
Subject: [PATCH 20/32] refactor: add support for built-in server options and
 rename functions

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: passed
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: passed
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/net/http-server/README.md         |  48 ++++---
 .../@stdlib/net/http-server/docs/repl.txt     |  17 +--
 .../net/http-server/docs/types/index.d.ts     |  16 +--
 .../net/http-server/docs/types/test.ts        | 118 +++++++++---------
 .../@stdlib/net/http-server/examples/index.js |   6 +-
 .../@stdlib/net/http-server/lib/index.js      |  18 +--
 .../@stdlib/net/http-server/lib/main.js       |  58 ++++++---
 .../@stdlib/net/http-server/test/test.js      |  30 ++---
 8 files changed, 174 insertions(+), 137 deletions(-)

diff --git a/lib/node_modules/@stdlib/net/http-server/README.md b/lib/node_modules/@stdlib/net/http-server/README.md
index c286d4f1d656..03ebc64f1927 100644
--- a/lib/node_modules/@stdlib/net/http-server/README.md
+++ b/lib/node_modules/@stdlib/net/http-server/README.md
@@ -20,24 +20,29 @@ limitations under the License.
 
 # HTTP Server
 
-> [HTTP][http] server.
+> [HTTP][nodejs-http] server.
 
 <section class="usage">
 
 ## Usage
 
 ```javascript
-var httpServer = require( '@stdlib/net/http-server' );
+var httpServerFactory = require( '@stdlib/net/http-server' );
 ```
 
-#### httpServer( \[options,] \[ requestListener] )
+#### httpServerFactory( \[options,] \[ requestListener] )
 
-Returns a function to create an [HTTP][http] server.
+Returns a function to create an [HTTP][nodejs-http] server.
 
 ```javascript
-var createServer = httpServer();
+var httpServer = httpServerFactory();
 ```
 
+The function supports the following parameters:
+
+-   **options**: options.
+-   **requestListener**: callback to invoke upon receiving an HTTP request.
+
 To bind a request callback to a server, provide a `requestListener`.
 
 ```javascript
@@ -46,17 +51,17 @@ function requestListener( request, response ) {
     response.end( 'OK' );
 }
 
-var createServer = httpServer( requestListener );
+var httpServer = httpServerFactory( requestListener );
 ```
 
-The function accepts the following `options`:
+The function accepts the following options:
 
 -   **port**: server port. Default: `0` (i.e., randomly assigned).
 -   **maxport**: max server port when port hunting. Default: `maxport=port`.
 -   **hostname**: server hostname.
 -   **address**: server address. Default: `127.0.0.1`.
 
-To specify server options, provide an `options` object.
+To specify server options, provide an options object.
 
 ```javascript
 var opts = {
@@ -64,7 +69,7 @@ var opts = {
     'address': '0.0.0.0'
 };
 
-var createServer = httpServer( opts );
+var httpServer = httpServerFactory( opts );
 ```
 
 To specify a range of permissible ports, set the `maxport` option.
@@ -74,14 +79,14 @@ var opts = {
     'maxport': 9999
 };
 
-var createServer = httpServer( opts );
+var httpServer = httpServerFactory( opts );
 ```
 
 When provided a `maxport` option, a created server will search for the first available `port` on which to listen, starting from `port`.
 
-#### createServer( done )
+#### httpServer( \[options,] done )
 
-Creates an [HTTP][http] server.
+Creates an [HTTP][nodejs-http] server.
 
 ```javascript
 function done( error, server ) {
@@ -92,11 +97,16 @@ function done( error, server ) {
     server.close();
 }
 
-var createServer = httpServer();
+var httpServer = httpServerFactory();
 
-createServer( done );
+httpServer( done );
 ```
 
+The function supports the following parameters:
+
+-   **options**: server options which are passed directly to [`http.createServer`][nodejs-http-create-server]. Which options are supported depends on the Node.js version. Older Node.js versions (e.g., <= v8.12.0) do not support an options object, and, for those versions, a provided options object is ignored.
+-   **done**: callback to invoke once a server is listening and ready to handle requests.
+
 </section>
 
 <!-- /.usage -->
@@ -122,7 +132,7 @@ createServer( done );
 ```javascript
 var proc = require( 'process' );
 var http = require( 'http' );
-var httpServer = require( '@stdlib/net/http-server' );
+var httpServerFactory = require( '@stdlib/net/http-server' );
 
 function done( error, server ) {
     if ( error ) {
@@ -149,10 +159,10 @@ var opts = {
 };
 
 // Create a function for creating an HTTP server...
-var createServer = httpServer( opts, onRequest );
+var httpServer = httpServerFactory( opts, onRequest );
 
 // Create a server:
-createServer( done );
+httpServer( done );
 ```
 
 </section>
@@ -171,7 +181,9 @@ createServer( done );
 
 <section class="links">
 
-[http]: https://nodejs.org/api/http.html
+[nodejs-http]: https://nodejs.org/api/http.html
+
+[nodejs-http-create-server]: https://nodejs.org/api/http.html#httpcreateserveroptions-requestlistener
 
 </section>
 
diff --git a/lib/node_modules/@stdlib/net/http-server/docs/repl.txt b/lib/node_modules/@stdlib/net/http-server/docs/repl.txt
index f4ae513c401d..18ddc072613a 100644
--- a/lib/node_modules/@stdlib/net/http-server/docs/repl.txt
+++ b/lib/node_modules/@stdlib/net/http-server/docs/repl.txt
@@ -24,13 +24,13 @@
 
     Returns
     -------
-    createServer: Function
+    httpServer: Function
         Function to create an HTTP server.
 
     Examples
     --------
     // Basic usage:
-    > var createServer = {{alias}}()
+    > var httpServer = {{alias}}()
     <Function>
 
     // Provide a request callback:
@@ -38,20 +38,23 @@
     ...    console.log( request.url );
     ...    response.end( 'OK' );
     ... };
-    > createServer = {{alias}}( onRequest )
+    > httpServer = {{alias}}( onRequest )
     <Function>
 
     // Specify a specific port:
     > var opts = { 'port': 7331 };
-    > createServer = {{alias}}( opts )
+    > httpServer = {{alias}}( opts )
     <Function>
 
 
-createServer( done )
+httpServer( [options,] done )
     Creates an HTTP server.
 
     Parameters
     ----------
+    options: Object (optional)
+        Server options which are passed directly to `http.createServer`.
+
     done: Function
         Callback to invoke after creating a server.
 
@@ -64,8 +67,8 @@ createServer( done )
     ...    console.log( 'Success!' );
     ...    server.close();
     ... };
-    > var createServer = {{alias}}();
-    > createServer( done );
+    > var httpServer = {{alias}}();
+    > httpServer( done );
 
     See Also
     --------
diff --git a/lib/node_modules/@stdlib/net/http-server/docs/types/index.d.ts b/lib/node_modules/@stdlib/net/http-server/docs/types/index.d.ts
index 9cc0a06d57bd..b44d2451cfd1 100644
--- a/lib/node_modules/@stdlib/net/http-server/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/net/http-server/docs/types/index.d.ts
@@ -104,7 +104,7 @@ type Callback = Nullary | Unary | Binary;
 *
 * @param done - callback to invoke after creating the server
 */
-type createServer = ( done: Callback ) => void;
+type httpServer = ( done: Callback ) => void; // FIXME: need to allow for an `options` argument with support for built-in server options
 
 /**
 * Returns a function which creates an HTTP server.
@@ -113,16 +113,16 @@ type createServer = ( done: Callback ) => void;
 * @returns function which creates an HTTP server
 *
 * @example
-* var createServer = httpServer();
+* var httpServer = factory();
 *
 * @example
 * function onRequest( request, response ) {
 *     console.log( request.url );
 *     response.end( 'OK' );
 * }
-* var createServer = httpServer( onRequest );
+* var httpServer = factory( onRequest );
 */
-declare function httpServer( requestListener?: RequestListener ): createServer;
+declare function factory( requestListener?: RequestListener ): httpServer;
 
 /**
 * Returns a function which creates an HTTP server.
@@ -141,7 +141,7 @@ declare function httpServer( requestListener?: RequestListener ): createServer;
 *     'port': 7331,
 *     'address': '0.0.0.0'
 * };
-* var createServer = httpServer( opts );
+* var httpServer = factory( opts );
 *
 * @example
 * var opts = {
@@ -152,11 +152,11 @@ declare function httpServer( requestListener?: RequestListener ): createServer;
 *     console.log( request.url );
 *     response.end( 'OK' );
 * }
-* var createServer = httpServer( opts, onRequest );
+* var httpServer = factory( opts, onRequest );
 */
-declare function httpServer( options: Options, requestListener?: RequestListener ): createServer;
+declare function factory( options: Options, requestListener?: RequestListener ): httpServer;
 
 
 // EXPORTS //
 
-export = httpServer;
+export = factory;
diff --git a/lib/node_modules/@stdlib/net/http-server/docs/types/test.ts b/lib/node_modules/@stdlib/net/http-server/docs/types/test.ts
index 5fb5849ebf64..7c7decd02db4 100644
--- a/lib/node_modules/@stdlib/net/http-server/docs/types/test.ts
+++ b/lib/node_modules/@stdlib/net/http-server/docs/types/test.ts
@@ -18,7 +18,7 @@
 
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 
-import httpServer = require( './index' );
+import httpServerFactory = require( './index' );
 
 /**
 * Request callback.
@@ -51,99 +51,99 @@ function done( error: Error | null, server: any ) {
 
 // The function returns a function to create a server...
 {
-	httpServer(); // $ExpectType createServer
-	httpServer( requestListener ); // $ExpectType createServer
-	httpServer( { 'port': 80 }, requestListener ); // $ExpectType createServer
+	httpServerFactory(); // $ExpectType httpServer
+	httpServerFactory( requestListener ); // $ExpectType httpServer
+	httpServerFactory( { 'port': 80 }, requestListener ); // $ExpectType httpServer
 
-	const createServer = httpServer(); // $ExpectType createServer
-	createServer( done ); // $ExpectType void
+	const httpServer = httpServerFactory(); // $ExpectType httpServer
+	httpServer( done ); // $ExpectType void
 }
 
 // The compiler throws an error if the function is provided a first argument which is not an options object or callback function...
 {
-	httpServer( 'abc' ); // $ExpectError
-	httpServer( true ); // $ExpectError
-	httpServer( false ); // $ExpectError
-	httpServer( 5 ); // $ExpectError
-	httpServer( [] ); // $ExpectError
+	httpServerFactory( 'abc' ); // $ExpectError
+	httpServerFactory( true ); // $ExpectError
+	httpServerFactory( false ); // $ExpectError
+	httpServerFactory( 5 ); // $ExpectError
+	httpServerFactory( [] ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a second argument which is not a callback function...
 {
-	httpServer( {}, false ); // $ExpectError
-	httpServer( {}, true ); // $ExpectError
-	httpServer( {}, 123 ); // $ExpectError
-	httpServer( {}, null ); // $ExpectError
-	httpServer( {}, 'abc' ); // $ExpectError
-	httpServer( {}, [] ); // $ExpectError
-	httpServer( {}, {} ); // $ExpectError
+	httpServerFactory( {}, false ); // $ExpectError
+	httpServerFactory( {}, true ); // $ExpectError
+	httpServerFactory( {}, 123 ); // $ExpectError
+	httpServerFactory( {}, null ); // $ExpectError
+	httpServerFactory( {}, 'abc' ); // $ExpectError
+	httpServerFactory( {}, [] ); // $ExpectError
+	httpServerFactory( {}, {} ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a `port` option which is not a number...
 {
-	httpServer( { 'port': 'abc' }, requestListener ); // $ExpectError
-	httpServer( { 'port': true }, requestListener ); // $ExpectError
-	httpServer( { 'port': false }, requestListener ); // $ExpectError
-	httpServer( { 'port': null }, requestListener ); // $ExpectError
-	httpServer( { 'port': [] }, requestListener ); // $ExpectError
-	httpServer( { 'port': {} }, requestListener ); // $ExpectError
-	httpServer( { 'port': ( x: number ): number => x }, requestListener ); // $ExpectError
+	httpServerFactory( { 'port': 'abc' }, requestListener ); // $ExpectError
+	httpServerFactory( { 'port': true }, requestListener ); // $ExpectError
+	httpServerFactory( { 'port': false }, requestListener ); // $ExpectError
+	httpServerFactory( { 'port': null }, requestListener ); // $ExpectError
+	httpServerFactory( { 'port': [] }, requestListener ); // $ExpectError
+	httpServerFactory( { 'port': {} }, requestListener ); // $ExpectError
+	httpServerFactory( { 'port': ( x: number ): number => x }, requestListener ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a `maxPort` option which is not a number...
 {
-	httpServer( { 'maxPort': 'abc' }, requestListener ); // $ExpectError
-	httpServer( { 'maxPort': true }, requestListener ); // $ExpectError
-	httpServer( { 'maxPort': false }, requestListener ); // $ExpectError
-	httpServer( { 'maxPort': null }, requestListener ); // $ExpectError
-	httpServer( { 'maxPort': [] }, requestListener ); // $ExpectError
-	httpServer( { 'maxPort': {} }, requestListener ); // $ExpectError
-	httpServer( { 'maxPort': ( x: number ): number => x }, requestListener ); // $ExpectError
+	httpServerFactory( { 'maxPort': 'abc' }, requestListener ); // $ExpectError
+	httpServerFactory( { 'maxPort': true }, requestListener ); // $ExpectError
+	httpServerFactory( { 'maxPort': false }, requestListener ); // $ExpectError
+	httpServerFactory( { 'maxPort': null }, requestListener ); // $ExpectError
+	httpServerFactory( { 'maxPort': [] }, requestListener ); // $ExpectError
+	httpServerFactory( { 'maxPort': {} }, requestListener ); // $ExpectError
+	httpServerFactory( { 'maxPort': ( x: number ): number => x }, requestListener ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a `hostname` option which is not a string...
 {
-	httpServer( { 'hostname': 123 }, requestListener ); // $ExpectError
-	httpServer( { 'hostname': true }, requestListener ); // $ExpectError
-	httpServer( { 'hostname': false }, requestListener ); // $ExpectError
-	httpServer( { 'hostname': null }, requestListener ); // $ExpectError
-	httpServer( { 'hostname': [] }, requestListener ); // $ExpectError
-	httpServer( { 'hostname': {} }, requestListener ); // $ExpectError
-	httpServer( { 'hostname': ( x: number ): number => x }, requestListener ); // $ExpectError
+	httpServerFactory( { 'hostname': 123 }, requestListener ); // $ExpectError
+	httpServerFactory( { 'hostname': true }, requestListener ); // $ExpectError
+	httpServerFactory( { 'hostname': false }, requestListener ); // $ExpectError
+	httpServerFactory( { 'hostname': null }, requestListener ); // $ExpectError
+	httpServerFactory( { 'hostname': [] }, requestListener ); // $ExpectError
+	httpServerFactory( { 'hostname': {} }, requestListener ); // $ExpectError
+	httpServerFactory( { 'hostname': ( x: number ): number => x }, requestListener ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided an `address` option which is not a string...
 {
-	httpServer( { 'address': 123 }, requestListener ); // $ExpectError
-	httpServer( { 'address': true }, requestListener ); // $ExpectError
-	httpServer( { 'address': false }, requestListener ); // $ExpectError
-	httpServer( { 'address': null }, requestListener ); // $ExpectError
-	httpServer( { 'address': [] }, requestListener ); // $ExpectError
-	httpServer( { 'address': {} }, requestListener ); // $ExpectError
-	httpServer( { 'address': ( x: number ): number => x }, requestListener ); // $ExpectError
+	httpServerFactory( { 'address': 123 }, requestListener ); // $ExpectError
+	httpServerFactory( { 'address': true }, requestListener ); // $ExpectError
+	httpServerFactory( { 'address': false }, requestListener ); // $ExpectError
+	httpServerFactory( { 'address': null }, requestListener ); // $ExpectError
+	httpServerFactory( { 'address': [] }, requestListener ); // $ExpectError
+	httpServerFactory( { 'address': {} }, requestListener ); // $ExpectError
+	httpServerFactory( { 'address': ( x: number ): number => x }, requestListener ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided an invalid number of arguments...
 {
-	httpServer( {}, requestListener, {} ); // $ExpectError
+	httpServerFactory( {}, requestListener, {} ); // $ExpectError
 }
 
 // The compiler throws an error if the returned function is invoked with an argument that is not a callback function...
 {
-	const createServer = httpServer();
-	createServer( 'abc' ); // $ExpectError
-	createServer( 123 ); // $ExpectError
-	createServer( true ); // $ExpectError
-	createServer( false ); // $ExpectError
-	createServer( null ); // $ExpectError
-	createServer( [] ); // $ExpectError
-	createServer( {} ); // $ExpectError
-	createServer( ( x: number ): number => x ); // $ExpectError
+	const httpServer = httpServerFactory();
+	httpServer( 'abc' ); // $ExpectError
+	httpServer( 123 ); // $ExpectError
+	httpServer( true ); // $ExpectError
+	httpServer( false ); // $ExpectError
+	httpServer( null ); // $ExpectError
+	httpServer( [] ); // $ExpectError
+	httpServer( {} ); // $ExpectError
+	httpServer( ( x: number ): number => x ); // $ExpectError
 }
 
 // The compiler throws an error if the returned function is invoked with an invalid number of arguments...
 {
-	const createServer = httpServer();
-	createServer(); // $ExpectError
-	createServer( done, {} ); // $ExpectError
+	const httpServer = httpServerFactory();
+	httpServer(); // $ExpectError
+	httpServer( done, {} ); // $ExpectError
 }
diff --git a/lib/node_modules/@stdlib/net/http-server/examples/index.js b/lib/node_modules/@stdlib/net/http-server/examples/index.js
index fc61965a2576..074311f69e21 100644
--- a/lib/node_modules/@stdlib/net/http-server/examples/index.js
+++ b/lib/node_modules/@stdlib/net/http-server/examples/index.js
@@ -20,7 +20,7 @@
 
 var proc = require( 'process' );
 var http = require( 'http' );
-var httpServer = require( './../lib' );
+var httpServerFactory = require( './../lib' );
 
 /**
 * Callback invoked once a server is ready to receive HTTP requests.
@@ -66,7 +66,7 @@ var opts = {
 };
 
 // Create a function for creating an HTTP server...
-var createServer = httpServer( opts, onRequest );
+var httpServer = httpServerFactory( opts, onRequest );
 
 // Create a server:
-createServer( done );
+httpServer( done );
diff --git a/lib/node_modules/@stdlib/net/http-server/lib/index.js b/lib/node_modules/@stdlib/net/http-server/lib/index.js
index d97009b563f8..59c8868a6dc2 100644
--- a/lib/node_modules/@stdlib/net/http-server/lib/index.js
+++ b/lib/node_modules/@stdlib/net/http-server/lib/index.js
@@ -24,21 +24,21 @@
 * @module @stdlib/net/http-server
 *
 * @example
-* var httpServer = require( '@stdlib/net/http-server' );
+* var httpServerFactory = require( '@stdlib/net/http-server' );
 *
 * var opts = {
 *     'port': 7331,
-*    'address': '0.0.0.0'
+*     'address': '0.0.0.0'
 * };
 * function done( error, server ) {
-*    if ( error ) {
-*        throw error;
-*    }
-*    console.log( 'Success!' );
-*    server.close();
+*     if ( error ) {
+*         throw error;
+*     }
+*     console.log( 'Success!' );
+*     server.close();
 * }
-* var createServer = httpServer( opts );
-* createServer( done );
+* var httpServer = httpServerFactory( opts );
+* httpServer( done );
 */
 
 // MODULES //
diff --git a/lib/node_modules/@stdlib/net/http-server/lib/main.js b/lib/node_modules/@stdlib/net/http-server/lib/main.js
index d1390745dcf0..65d6c4331743 100644
--- a/lib/node_modules/@stdlib/net/http-server/lib/main.js
+++ b/lib/node_modules/@stdlib/net/http-server/lib/main.js
@@ -23,6 +23,8 @@
 var http = require( 'http' );
 var logger = require( 'debug' );
 var isFunction = require( '@stdlib/assert/is-function' );
+var isObject = require( '@stdlib/assert/is-object' );
+var NODE_VERSION = require( '@stdlib/process/node-version' );
 var format = require( '@stdlib/string/format' );
 var validate = require( './validate.js' );
 var DEFAULTS = require( './defaults.json' );
@@ -31,6 +33,7 @@ var DEFAULTS = require( './defaults.json' );
 // VARIABLES //
 
 var debug = logger( '@stdlib/net/http-server' );
+var SUPPORTS_OPTIONS = ( parseInt( NODE_VERSION.split( '.' )[ 0 ], 10 ) >= 8 ); // TODO: this is an imperfect test, as options only added in v8.12.0/v9.6.0
 
 
 // MAIN //
@@ -49,14 +52,14 @@ var debug = logger( '@stdlib/net/http-server' );
 * @returns {Function} function which creates an HTTP server
 *
 * @example
-* var createServer = httpServer();
+* var httpServer = factory();
 *
 * @example
 * var opts = {
 *     'port': 7331,
 *     'address': '0.0.0.0'
 * };
-* var createServer = httpServer( opts );
+* var httpServer = factory( opts );
 *
 * @example
 * var opts = {
@@ -67,9 +70,9 @@ var debug = logger( '@stdlib/net/http-server' );
 *     console.log( request.url );
 *     response.end( 'OK' );
 * }
-* var createServer = httpServer( opts, onRequest );
+* var httpServer = factory( opts, onRequest );
 */
-function httpServer() {
+function factory() {
 	var requestListener;
 	var hostname;
 	var options;
@@ -88,8 +91,7 @@ function httpServer() {
 			options = arguments[ 0 ];
 			err = validate( opts, options );
 		}
-	}
-	else if ( nargs > 1 ) {
+	} else if ( nargs > 1 ) {
 		options = arguments[ 0 ];
 		requestListener = arguments[ 1 ];
 		if ( !isFunction( requestListener ) ) {
@@ -116,21 +118,20 @@ function httpServer() {
 
 	if ( opts.hostname ) {
 		hostname = opts.hostname;
-	}
-	else if ( opts.address ) {
+	} else if ( opts.address ) {
 		hostname = opts.address;
-	}
-	else {
+	} else {
 		hostname = DEFAULTS.address;
 	}
 	debug( 'Server hostname: %s', hostname );
 
-	return createServer;
+	return httpServer;
 
 	/**
 	* Creates an HTTP server.
 	*
 	* @private
+	* @param {Options} [options] - server options
 	* @param {Callback} done - function to invoke after creating a server
 	* @throws {TypeError} must provide a function
 	*
@@ -142,15 +143,36 @@ function httpServer() {
 	*     console.log( 'Success!' );
 	*     server.close();
 	* }
-	* createServer( done );
+	* httpServer( done );
 	*/
-	function createServer( done ) {
+	function httpServer( options, done ) {
 		var server;
-		if ( !isFunction( done ) ) {
-			throw new TypeError( format( 'invalid argument. Callback argument must be a function. Value: `%s`.', done ) );
+		var nargs;
+		var opts;
+		var cb;
+
+		nargs = arguments.length;
+		if ( nargs < 2 ) {
+			opts = {};
+			cb = options;
+		} else {
+			opts = options;
+			if ( !isObject( opts ) ) {
+				throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', opts ) );
+			}
+			cb = done;
+		}
+		if ( !isFunction( cb ) ) {
+			throw new TypeError( format( 'invalid argument. Callback argument must be a function. Value: `%s`.', cb ) );
 		}
 		if ( requestListener ) {
-			server = http.createServer( requestListener );
+			if ( SUPPORTS_OPTIONS ) {
+				server = http.createServer( opts, requestListener );
+			} else {
+				server = http.createServer( requestListener );
+			}
+		} else if ( SUPPORTS_OPTIONS ) {
+			server = http.createServer( opts );
 		} else {
 			server = http.createServer();
 		}
@@ -188,7 +210,7 @@ function httpServer() {
 		function onListen() {
 			var addr = server.address();
 			debug( 'HTTP server initialized. Server is listening for requests on %s:%d.', addr.address, addr.port );
-			done( null, server );
+			cb( null, server );
 		}
 	}
 }
@@ -196,4 +218,4 @@ function httpServer() {
 
 // EXPORTS //
 
-module.exports = httpServer;
+module.exports = factory;
diff --git a/lib/node_modules/@stdlib/net/http-server/test/test.js b/lib/node_modules/@stdlib/net/http-server/test/test.js
index cb9fcf58a41f..36f8e86f0cc4 100644
--- a/lib/node_modules/@stdlib/net/http-server/test/test.js
+++ b/lib/node_modules/@stdlib/net/http-server/test/test.js
@@ -25,14 +25,14 @@ var tape = require( 'tape' );
 var objectKeys = require( '@stdlib/utils/keys' );
 var noop = require( '@stdlib/utils/noop' );
 var createServer = require( './fixtures/server.js' );
-var httpServer = require( './../lib' );
+var factory = require( './../lib' );
 
 
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.strictEqual( typeof httpServer, 'function', 'main export is a function' );
+	t.strictEqual( typeof factory, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -41,12 +41,12 @@ tape( 'the function will throw an error if provided an invalid option', function
 	t.throws( bar, Error, 'throws error' );
 	t.end();
 	function foo() {
-		httpServer({
+		factory({
 			'port': 3.14
 		});
 	}
 	function bar() {
-		httpServer({
+		factory({
 			'maxport': 3.14
 		}, noop );
 	}
@@ -73,13 +73,13 @@ tape( 'the function will throw an error if provided a request listener which is
 	t.end();
 	function badValue( value ) {
 		return function badValue() {
-			httpServer( {}, value );
+			factory( {}, value );
 		};
 	}
 });
 
 tape( 'the function returns a function', function test( t ) {
-	t.equal( typeof httpServer(), 'function', 'returns a function' );
+	t.equal( typeof factory(), 'function', 'returns a function' );
 	t.end();
 });
 
@@ -99,7 +99,7 @@ tape( 'the returned function will throw an error if provided a callback argument
 		{}
 	];
 
-	create = httpServer( {} );
+	create = factory( {} );
 
 	for ( i = 0; i < values.length; i++ ) {
 		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided '+values[i] );
@@ -119,7 +119,7 @@ tape( 'the created server listens on a specified port', function test( t ) {
 	opts = {};
 	opts.port = 7331;
 
-	create = httpServer( opts );
+	create = factory( opts );
 	create( onServer );
 
 	function onServer( error, server ) {
@@ -141,7 +141,7 @@ tape( 'the returned function will throw if the server encounters an error', func
 	opts = {};
 	opts.port = 1337;
 
-	create = httpServer( opts );
+	create = factory( opts );
 	create( next );
 
 	function next( error, s ) {
@@ -168,7 +168,7 @@ tape( 'the returned function will throw if unable to listen on a specified port
 	opts = {};
 	opts.port = 10000;
 
-	create = httpServer( opts );
+	create = factory( opts );
 	create( next );
 
 	function next( error, s ) {
@@ -199,7 +199,7 @@ tape( 'the returned function will port hunt', function test( t ) {
 	opts.port = 8080;
 	opts.maxport = 9999;
 
-	create = httpServer( opts );
+	create = factory( opts );
 	eServer = createServer( opts.port, next );
 
 	function next() {
@@ -234,7 +234,7 @@ tape( 'the server will listen on a specified hostname', function test( t ) {
 	opts = {};
 	opts.hostname = 'localhost';
 
-	create = httpServer( opts );
+	create = factory( opts );
 	create( onServer );
 
 	function onServer( error, server ) {
@@ -258,7 +258,7 @@ tape( 'the server will listen on a specified address', function test( t ) {
 	opts = {};
 	opts.address = '127.0.0.1';
 
-	create = httpServer( opts );
+	create = factory( opts );
 	create( onServer );
 
 	function onServer( error, server ) {
@@ -279,7 +279,7 @@ tape( 'the server will use a provided request listener (no options)', function t
 
 	connections = {};
 
-	create = httpServer( onRequest );
+	create = factory( onRequest );
 	create( onServer );
 
 	function onRequest( request, response ) {
@@ -341,7 +341,7 @@ tape( 'the server will use a provided request listener (options)', function test
 
 	connections = {};
 
-	create = httpServer( opts, onRequest );
+	create = factory( opts, onRequest );
 	create( onServer );
 
 	function onRequest( request, response ) {

From 1913191dea38c0f42f7143747c121db38f1ebc35 Mon Sep 17 00:00:00 2001
From: GeoDaoyu <geodaoyu@foxmail.com>
Date: Fri, 15 Aug 2025 17:47:02 +0800
Subject: [PATCH 21/32] chore: fix C lint errors

PR-URL: https://github.com/stdlib-js/stdlib/pull/7878
Closes: https://github.com/stdlib-js/stdlib/issues/7877
Reviewed-by: Athan Reines <kgryte@gmail.com>
---
 .../blas/ext/base/dnansum/benchmark/c/benchmark.length.c        | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnansum/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/ext/base/dnansum/benchmark/c/benchmark.length.c
index 2bbca41d511c..06eae04cd1c7 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnansum/benchmark/c/benchmark.length.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnansum/benchmark/c/benchmark.length.c
@@ -111,6 +111,7 @@ static double benchmark1( int iterations, int len ) {
 	v = 0.0;
 	t = tic();
 	for ( i = 0; i < iterations; i++ ) {
+		// cppcheck-suppress uninitvar
 		v = stdlib_strided_dnansum( len, x, 1 );
 		if ( v != v ) {
 			printf( "should not return NaN\n" );
@@ -148,6 +149,7 @@ static double benchmark2( int iterations, int len ) {
 	v = 0.0;
 	t = tic();
 	for ( i = 0; i < iterations; i++ ) {
+		// cppcheck-suppress uninitvar
 		v = stdlib_strided_dnansum_ndarray( len, x, 1, 0 );
 		if ( v != v ) {
 			printf( "should not return NaN\n" );

From 2996658b99f63d5f4505f76d6393f6f75c1aec13 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Fri, 15 Aug 2025 03:13:49 -0700
Subject: [PATCH 22/32] fix: move server options into factory function

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/net/http-server/README.md         | 10 ++--
 .../@stdlib/net/http-server/docs/repl.txt     | 11 ++--
 .../net/http-server/docs/types/index.d.ts     |  8 ++-
 .../@stdlib/net/http-server/lib/main.js       | 51 ++++++++++---------
 4 files changed, 46 insertions(+), 34 deletions(-)

diff --git a/lib/node_modules/@stdlib/net/http-server/README.md b/lib/node_modules/@stdlib/net/http-server/README.md
index 03ebc64f1927..01649f4ebcf2 100644
--- a/lib/node_modules/@stdlib/net/http-server/README.md
+++ b/lib/node_modules/@stdlib/net/http-server/README.md
@@ -40,8 +40,8 @@ var httpServer = httpServerFactory();
 
 The function supports the following parameters:
 
--   **options**: options.
--   **requestListener**: callback to invoke upon receiving an HTTP request.
+-   **options**: options (_optional_).
+-   **requestListener**: callback to invoke upon receiving an HTTP request (_optional_).
 
 To bind a request callback to a server, provide a `requestListener`.
 
@@ -54,7 +54,7 @@ function requestListener( request, response ) {
 var httpServer = httpServerFactory( requestListener );
 ```
 
-The function accepts the following options:
+In addition to the options supported by [`http.createServer`][nodejs-http-create-server], the function accepts the following options:
 
 -   **port**: server port. Default: `0` (i.e., randomly assigned).
 -   **maxport**: max server port when port hunting. Default: `maxport=port`.
@@ -84,7 +84,7 @@ var httpServer = httpServerFactory( opts );
 
 When provided a `maxport` option, a created server will search for the first available `port` on which to listen, starting from `port`.
 
-#### httpServer( \[options,] done )
+#### httpServer( done )
 
 Creates an [HTTP][nodejs-http] server.
 
@@ -104,7 +104,6 @@ httpServer( done );
 
 The function supports the following parameters:
 
--   **options**: server options which are passed directly to [`http.createServer`][nodejs-http-create-server]. Which options are supported depends on the Node.js version. Older Node.js versions (e.g., <= v8.12.0) do not support an options object, and, for those versions, a provided options object is ignored.
 -   **done**: callback to invoke once a server is listening and ready to handle requests.
 
 </section>
@@ -115,6 +114,7 @@ The function supports the following parameters:
 
 ## Notes
 
+-   Which server options are supported depends on the Node.js version. Older Node.js versions (e.g., <= v8.12.0) do not support an options object when calling [`http.createServer`][nodejs-http-create-server], and, for those versions, any options specific to Node.js are ignored.
 -   Port hunting can be useful in a microservice deployment. When a `port` is randomly assigned (`options.port=0`), if a server fails and is restarted, the server is unlikely to bind to its previous `port`. By allowing a constrained search, assuming no lower `ports` within a specified range have freed up in the meantime, the likelihood of listening on the same `port` is increased. A server can typically restart and bind to the same `port` faster than binding to a new `port` and re-registering with a microservice registry, thus minimizing possible service interruption and downtime.
 
 </section>
diff --git a/lib/node_modules/@stdlib/net/http-server/docs/repl.txt b/lib/node_modules/@stdlib/net/http-server/docs/repl.txt
index 18ddc072613a..31e1a307adec 100644
--- a/lib/node_modules/@stdlib/net/http-server/docs/repl.txt
+++ b/lib/node_modules/@stdlib/net/http-server/docs/repl.txt
@@ -2,6 +2,12 @@
 {{alias}}( [options,] [requestListener] )
     Returns a function to create an HTTP server.
 
+    In addition to options documented below, the function supports any options
+    supported by `http.createServer`. Which server options are supported depends
+    on the Node.js version. Older Node.js versions (e.g., <= v8.12.0) do not
+    support an options object when calling `http.createServer`, and, for those
+    versions, any options specific to Node.js are ignored.
+
     Parameters
     ----------
     options: Object (optional)
@@ -47,14 +53,11 @@
     <Function>
 
 
-httpServer( [options,] done )
+httpServer( done )
     Creates an HTTP server.
 
     Parameters
     ----------
-    options: Object (optional)
-        Server options which are passed directly to `http.createServer`.
-
     done: Function
         Callback to invoke after creating a server.
 
diff --git a/lib/node_modules/@stdlib/net/http-server/docs/types/index.d.ts b/lib/node_modules/@stdlib/net/http-server/docs/types/index.d.ts
index b44d2451cfd1..6e05e2b55f82 100644
--- a/lib/node_modules/@stdlib/net/http-server/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/net/http-server/docs/types/index.d.ts
@@ -104,7 +104,7 @@ type Callback = Nullary | Unary | Binary;
 *
 * @param done - callback to invoke after creating the server
 */
-type httpServer = ( done: Callback ) => void; // FIXME: need to allow for an `options` argument with support for built-in server options
+type httpServer = ( done: Callback ) => void;
 
 /**
 * Returns a function which creates an HTTP server.
@@ -127,6 +127,10 @@ declare function factory( requestListener?: RequestListener ): httpServer;
 /**
 * Returns a function which creates an HTTP server.
 *
+* ## Notes
+*
+* -   In addition to options documented below, the function supports any options supported by `http.createServer`. Which server options are supported depends on the Node.js version. Older Node.js versions (e.g., <= v8.12.0) do not support an options object when calling `http.createServer`, and, for those versions, any options specific to Node.js are ignored.
+*
 * @param options - server options
 * @param options.port - server port (default: 0)
 * @param options.maxport - max server port
@@ -154,7 +158,7 @@ declare function factory( requestListener?: RequestListener ): httpServer;
 * }
 * var httpServer = factory( opts, onRequest );
 */
-declare function factory( options: Options, requestListener?: RequestListener ): httpServer;
+declare function factory<T extends Options>( options: T, requestListener?: RequestListener ): httpServer;
 
 
 // EXPORTS //
diff --git a/lib/node_modules/@stdlib/net/http-server/lib/main.js b/lib/node_modules/@stdlib/net/http-server/lib/main.js
index 65d6c4331743..314cba486e98 100644
--- a/lib/node_modules/@stdlib/net/http-server/lib/main.js
+++ b/lib/node_modules/@stdlib/net/http-server/lib/main.js
@@ -23,8 +23,8 @@
 var http = require( 'http' );
 var logger = require( 'debug' );
 var isFunction = require( '@stdlib/assert/is-function' );
-var isObject = require( '@stdlib/assert/is-object' );
 var NODE_VERSION = require( '@stdlib/process/node-version' );
+var omit = require( '@stdlib/utils/omit' );
 var format = require( '@stdlib/string/format' );
 var validate = require( './validate.js' );
 var DEFAULTS = require( './defaults.json' );
@@ -35,12 +35,23 @@ var DEFAULTS = require( './defaults.json' );
 var debug = logger( '@stdlib/net/http-server' );
 var SUPPORTS_OPTIONS = ( parseInt( NODE_VERSION.split( '.' )[ 0 ], 10 ) >= 8 ); // TODO: this is an imperfect test, as options only added in v8.12.0/v9.6.0
 
+var EXCLUDE_OPTIONS = [
+	'port',
+	'maxport',
+	'hostname',
+	'address'
+];
+
 
 // MAIN //
 
 /**
 * Returns a function which creates an HTTP server.
 *
+* ## Notes
+*
+* -   In addition to options documented below, the function supports any options supported by `http.createServer`. Which server options are supported depends on the Node.js version. Older Node.js versions (e.g., <= v8.12.0) do not support an options object when calling `http.createServer`, and, for those versions, any options specific to Node.js are ignored.
+*
 * @param {Options} [options] - server options
 * @param {NonNegativeInteger} [options.port=0] - server port
 * @param {NonNegativeInteger} [options.maxport] - max server port
@@ -77,12 +88,15 @@ function factory() {
 	var hostname;
 	var options;
 	var nargs;
+	var sopts;
 	var opts;
 	var port;
 	var max;
 	var err;
+	var flg;
 
 	nargs = arguments.length;
+	sopts = {};
 	opts = {};
 	if ( nargs === 1 ) {
 		if ( isFunction( arguments[0] ) ) {
@@ -90,6 +104,7 @@ function factory() {
 		} else {
 			options = arguments[ 0 ];
 			err = validate( opts, options );
+			flg = true;
 		}
 	} else if ( nargs > 1 ) {
 		options = arguments[ 0 ];
@@ -98,10 +113,15 @@ function factory() {
 			throw new TypeError( format( 'invalid argument. Request listener must be a function. Value: `%s`.', requestListener ) );
 		}
 		err = validate( opts, options );
+		flg = true;
 	}
 	if ( err ) {
 		throw err;
 	}
+	if ( flg ) {
+		// Resolve any server-specific options which should be passed to `http.createServer`:
+		sopts = omit( options, EXCLUDE_OPTIONS );
+	}
 	if ( opts.port === void 0 ) {
 		port = DEFAULTS.port;
 	} else {
@@ -131,7 +151,6 @@ function factory() {
 	* Creates an HTTP server.
 	*
 	* @private
-	* @param {Options} [options] - server options
 	* @param {Callback} done - function to invoke after creating a server
 	* @throws {TypeError} must provide a function
 	*
@@ -145,34 +164,20 @@ function factory() {
 	* }
 	* httpServer( done );
 	*/
-	function httpServer( options, done ) {
+	function httpServer( done ) {
 		var server;
-		var nargs;
-		var opts;
-		var cb;
-
-		nargs = arguments.length;
-		if ( nargs < 2 ) {
-			opts = {};
-			cb = options;
-		} else {
-			opts = options;
-			if ( !isObject( opts ) ) {
-				throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', opts ) );
-			}
-			cb = done;
-		}
-		if ( !isFunction( cb ) ) {
-			throw new TypeError( format( 'invalid argument. Callback argument must be a function. Value: `%s`.', cb ) );
+
+		if ( !isFunction( done ) ) {
+			throw new TypeError( format( 'invalid argument. Callback argument must be a function. Value: `%s`.', done ) );
 		}
 		if ( requestListener ) {
 			if ( SUPPORTS_OPTIONS ) {
-				server = http.createServer( opts, requestListener );
+				server = http.createServer( sopts, requestListener );
 			} else {
 				server = http.createServer( requestListener );
 			}
 		} else if ( SUPPORTS_OPTIONS ) {
-			server = http.createServer( opts );
+			server = http.createServer( sopts );
 		} else {
 			server = http.createServer();
 		}
@@ -210,7 +215,7 @@ function factory() {
 		function onListen() {
 			var addr = server.address();
 			debug( 'HTTP server initialized. Server is listening for requests on %s:%d.', addr.address, addr.port );
-			cb( null, server );
+			done( null, server );
 		}
 	}
 }

From 7e695d4145153f2c44af922aad5e4f6e9a131b90 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Fri, 15 Aug 2025 03:21:14 -0700
Subject: [PATCH 23/32] style: remove space

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 lib/node_modules/@stdlib/net/http-server/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/node_modules/@stdlib/net/http-server/README.md b/lib/node_modules/@stdlib/net/http-server/README.md
index 01649f4ebcf2..f0dd6fabcbc2 100644
--- a/lib/node_modules/@stdlib/net/http-server/README.md
+++ b/lib/node_modules/@stdlib/net/http-server/README.md
@@ -30,7 +30,7 @@ limitations under the License.
 var httpServerFactory = require( '@stdlib/net/http-server' );
 ```
 
-#### httpServerFactory( \[options,] \[ requestListener] )
+#### httpServerFactory( \[options,] \[requestListener] )
 
 Returns a function to create an [HTTP][nodejs-http] server.
 

From d02db19483a002759417943f0a6c8521fdfe1a4c Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Fri, 15 Aug 2025 03:24:12 -0700
Subject: [PATCH 24/32] docs: update note

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 lib/node_modules/@stdlib/net/http-server/README.md             | 2 +-
 lib/node_modules/@stdlib/net/http-server/docs/repl.txt         | 3 ++-
 lib/node_modules/@stdlib/net/http-server/docs/types/index.d.ts | 2 +-
 lib/node_modules/@stdlib/net/http-server/lib/main.js           | 2 +-
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/node_modules/@stdlib/net/http-server/README.md b/lib/node_modules/@stdlib/net/http-server/README.md
index f0dd6fabcbc2..f4741d89227e 100644
--- a/lib/node_modules/@stdlib/net/http-server/README.md
+++ b/lib/node_modules/@stdlib/net/http-server/README.md
@@ -114,7 +114,7 @@ The function supports the following parameters:
 
 ## Notes
 
--   Which server options are supported depends on the Node.js version. Older Node.js versions (e.g., <= v8.12.0) do not support an options object when calling [`http.createServer`][nodejs-http-create-server], and, for those versions, any options specific to Node.js are ignored.
+-   Which server options are supported depends on the Node.js version. Older Node.js versions (e.g., <= v8.12.0) do not support an options object when calling [`http.createServer`][nodejs-http-create-server], and, for those versions, any options supported by [`http.createServer`][nodejs-http-create-server] in later Node.js versions are ignored.
 -   Port hunting can be useful in a microservice deployment. When a `port` is randomly assigned (`options.port=0`), if a server fails and is restarted, the server is unlikely to bind to its previous `port`. By allowing a constrained search, assuming no lower `ports` within a specified range have freed up in the meantime, the likelihood of listening on the same `port` is increased. A server can typically restart and bind to the same `port` faster than binding to a new `port` and re-registering with a microservice registry, thus minimizing possible service interruption and downtime.
 
 </section>
diff --git a/lib/node_modules/@stdlib/net/http-server/docs/repl.txt b/lib/node_modules/@stdlib/net/http-server/docs/repl.txt
index 31e1a307adec..3db86c4c8273 100644
--- a/lib/node_modules/@stdlib/net/http-server/docs/repl.txt
+++ b/lib/node_modules/@stdlib/net/http-server/docs/repl.txt
@@ -6,7 +6,8 @@
     supported by `http.createServer`. Which server options are supported depends
     on the Node.js version. Older Node.js versions (e.g., <= v8.12.0) do not
     support an options object when calling `http.createServer`, and, for those
-    versions, any options specific to Node.js are ignored.
+    versions, any options supported by `http.createServer` in later Node.js
+    versions are ignored.
 
     Parameters
     ----------
diff --git a/lib/node_modules/@stdlib/net/http-server/docs/types/index.d.ts b/lib/node_modules/@stdlib/net/http-server/docs/types/index.d.ts
index 6e05e2b55f82..851601a7c5a0 100644
--- a/lib/node_modules/@stdlib/net/http-server/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/net/http-server/docs/types/index.d.ts
@@ -129,7 +129,7 @@ declare function factory( requestListener?: RequestListener ): httpServer;
 *
 * ## Notes
 *
-* -   In addition to options documented below, the function supports any options supported by `http.createServer`. Which server options are supported depends on the Node.js version. Older Node.js versions (e.g., <= v8.12.0) do not support an options object when calling `http.createServer`, and, for those versions, any options specific to Node.js are ignored.
+* -   In addition to options documented below, the function supports any options supported by `http.createServer`. Which server options are supported depends on the Node.js version. Older Node.js versions (e.g., <= v8.12.0) do not support an options object when calling `http.createServer`, and, for those versions, any options supported by `http.createServer` in later Node.js versions are ignored.
 *
 * @param options - server options
 * @param options.port - server port (default: 0)
diff --git a/lib/node_modules/@stdlib/net/http-server/lib/main.js b/lib/node_modules/@stdlib/net/http-server/lib/main.js
index 314cba486e98..a2c9e5afe4f5 100644
--- a/lib/node_modules/@stdlib/net/http-server/lib/main.js
+++ b/lib/node_modules/@stdlib/net/http-server/lib/main.js
@@ -50,7 +50,7 @@ var EXCLUDE_OPTIONS = [
 *
 * ## Notes
 *
-* -   In addition to options documented below, the function supports any options supported by `http.createServer`. Which server options are supported depends on the Node.js version. Older Node.js versions (e.g., <= v8.12.0) do not support an options object when calling `http.createServer`, and, for those versions, any options specific to Node.js are ignored.
+* -   In addition to options documented below, the function supports any options supported by `http.createServer`. Which server options are supported depends on the Node.js version. Older Node.js versions (e.g., <= v8.12.0) do not support an options object when calling `http.createServer`, and, for those versions, any options supported by `http.createServer` in later Node.js versions are ignored.
 *
 * @param {Options} [options] - server options
 * @param {NonNegativeInteger} [options.port=0] - server port

From 1c9a2dad4c7ff11aefab03110d9c0fa7ad94e969 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Fri, 15 Aug 2025 03:27:23 -0700
Subject: [PATCH 25/32] docs: update copy

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/net/disposable-http-server/README.md    | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/lib/node_modules/@stdlib/net/disposable-http-server/README.md b/lib/node_modules/@stdlib/net/disposable-http-server/README.md
index 640c974f1516..eeb48bbcb287 100644
--- a/lib/node_modules/@stdlib/net/disposable-http-server/README.md
+++ b/lib/node_modules/@stdlib/net/disposable-http-server/README.md
@@ -47,15 +47,20 @@ var opts = {
 httpServer( opts );
 ```
 
+The function supports the following parameters:
+
+-   **options**: function options.
+-   **clbk**: callback to invoke upon creating a server (_optional_).
+
 The function accepts the following options:
 
--   **html**: `buffer` or `string` to serve as HTML content.
--   **javascript**: `buffer` or `string` to serve as JavaScript.
+-   **html**: Buffer or string to serve as HTML content.
+-   **javascript**: Buffer or string to serve as JavaScript.
 -   **port**: server port. Default: `0` (i.e., randomly assigned).
 -   **maxport**: max server port (used when port hunting). Default: `=port`.
 -   **hostname**: server hostname.
 -   **address**: server address. Default: `"0.0.0.0"`.
--   **open**: `boolean` indicating whether to launch a web browser. Default: `false`.
+-   **open**: boolean indicating whether to launch a web browser. Default: `false`.
 
 To serve HTML content, set the `html` option. Once the content is requested, the server will close.
 
@@ -127,7 +132,7 @@ httpServer( opts, onReady );
 
 ## Notes
 
--   If neither the `html` or `javascript` option is set, the server serves an HTML boilerplate and then closes.
+-   If neither the `html` nor `javascript` option is set, the server serves an HTML boilerplate and then closes.
 
 </section>
 

From ca1908c96b83777579315cba10c11484a0d25466 Mon Sep 17 00:00:00 2001
From: Gururaj Gurram <143020143+gururaj1512@users.noreply.github.com>
Date: Fri, 15 Aug 2025 16:15:26 +0530
Subject: [PATCH 26/32] feat: add `stats/base/ndarray/minabs`

PR-URL: https://github.com/stdlib-js/stdlib/pull/7882
Reviewed-by: Athan Reines <kgryte@gmail.com>
---
 .../stats/base/ndarray/minabs/README.md       | 111 +++++++++++
 .../ndarray/minabs/benchmark/benchmark.js     | 102 +++++++++++
 .../stats/base/ndarray/minabs/docs/repl.txt   |  31 ++++
 .../base/ndarray/minabs/docs/types/index.d.ts |  45 +++++
 .../base/ndarray/minabs/docs/types/test.ts    |  57 ++++++
 .../base/ndarray/minabs/examples/index.js     |  33 ++++
 .../stats/base/ndarray/minabs/lib/index.js    |  44 +++++
 .../stats/base/ndarray/minabs/lib/main.js     |  55 ++++++
 .../stats/base/ndarray/minabs/package.json    |  69 +++++++
 .../stats/base/ndarray/minabs/test/test.js    | 172 ++++++++++++++++++
 10 files changed, 719 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/minabs/README.md
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/minabs/benchmark/benchmark.js
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/minabs/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/minabs/docs/types/index.d.ts
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/minabs/docs/types/test.ts
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/minabs/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/minabs/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/minabs/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/minabs/package.json
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/minabs/test/test.js

diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/minabs/README.md b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/README.md
new file mode 100644
index 000000000000..49c27d33b254
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/README.md
@@ -0,0 +1,111 @@
+<!--
+
+@license Apache-2.0
+
+Copyright (c) 2025 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.
+
+-->
+
+# minabs
+
+> Compute the minimum absolute value of a one-dimensional ndarray.
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var minabs = require( '@stdlib/stats/base/ndarray/minabs' );
+```
+
+#### minabs( arrays )
+
+Computes the minimum absolute value of a one-dimensional ndarray.
+
+```javascript
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+
+var xbuf = [ -1.0, 3.0, -4.0, 2.0 ];
+var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+
+var v = minabs( [ x ] );
+// returns 1.0
+```
+
+The function has the following parameters:
+
+-   **arrays**: array-like object containing a one-dimensional input ndarray.
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   If provided an empty one-dimensional ndarray, the function returns `NaN`.
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var minabs = require( '@stdlib/stats/base/ndarray/minabs' );
+
+var xbuf = discreteUniform( 10, -50, 50, {
+    'dtype': 'generic'
+});
+var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+console.log( ndarray2array( x ) );
+
+var v = minabs( [ x ] );
+console.log( v );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<!-- Section for all links. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="links">
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/minabs/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/benchmark/benchmark.js
new file mode 100644
index 000000000000..5076d7ba30ce
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/benchmark/benchmark.js
@@ -0,0 +1,102 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var pkg = require( './../package.json' ).name;
+var minabs = require( './../lib' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'generic'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var xbuf;
+	var x;
+
+	xbuf = uniform( len, -10.0, 10.0, options );
+	x = new ndarray( options.dtype, xbuf, [ len ], [ 1 ], 0, 'row-major' );
+
+	return benchmark;
+
+	function benchmark( b ) {
+		var v;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			v = minabs( [ x ] );
+			if ( isnan( v ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( v ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( pkg+':len='+len, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/minabs/docs/repl.txt b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/docs/repl.txt
new file mode 100644
index 000000000000..5c8551bd2682
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/docs/repl.txt
@@ -0,0 +1,31 @@
+
+{{alias}}( arrays )
+    Computes the minimum absolute value of a one-dimensional ndarray.
+
+    If provided an empty ndarray, the function returns `NaN`.
+
+    Parameters
+    ----------
+    arrays: ArrayLikeObject<ndarray>
+        Array-like object containing a one-dimensional input ndarray.
+
+    Returns
+    -------
+    out: number
+        Minimum absolute value.
+
+    Examples
+    --------
+    > var xbuf = [ 1.0, -2.0, 2.0 ];
+    > var dt = 'generic';
+    > var sh = [ xbuf.length ];
+    > var sx = [ 1 ];
+    > var ox = 0;
+    > var ord = 'row-major';
+    > var x = new {{alias:@stdlib/ndarray/ctor}}( dt, xbuf, sh, sx, ox, ord );
+    > {{alias}}( [ x ] )
+    1.0
+
+    See Also
+    --------
+
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/minabs/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/docs/types/index.d.ts
new file mode 100644
index 000000000000..f7fb60549e77
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/docs/types/index.d.ts
@@ -0,0 +1,45 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+// TypeScript Version: 4.1
+
+/// <reference types="@stdlib/types"/>
+
+import { ndarray } from '@stdlib/types/ndarray';
+
+/**
+* Computes the minimum absolute value of a one-dimensional ndarray.
+*
+* @param arrays - array-like object containing an input ndarray
+* @returns minimum absolute value
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+*
+* var xbuf = [ -1.0, 3.0, -4.0, 2.0 ];
+* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+*
+* var v = minabs( [ x ] );
+* // returns 1.0
+*/
+declare function minabs<T extends ndarray = ndarray>( arrays: [ T ] ): number;
+
+
+// EXPORTS //
+
+export = minabs;
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/minabs/docs/types/test.ts b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/docs/types/test.ts
new file mode 100644
index 000000000000..21964be6636d
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/docs/types/test.ts
@@ -0,0 +1,57 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable space-in-parens */
+
+import zeros = require( '@stdlib/ndarray/zeros' );
+import minabs = require( './index' );
+
+
+// TESTS //
+
+// The function returns a number...
+{
+	const x = zeros( [ 10 ], {
+		'dtype': 'generic'
+	});
+
+	minabs( [ x ] ); // $ExpectType number
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an array of ndarrays...
+{
+	minabs( '10' ); // $ExpectError
+	minabs( 10 ); // $ExpectError
+	minabs( true ); // $ExpectError
+	minabs( false ); // $ExpectError
+	minabs( null ); // $ExpectError
+	minabs( undefined ); // $ExpectError
+	minabs( [] ); // $ExpectError
+	minabs( {} ); // $ExpectError
+	minabs( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+	const x = zeros( [ 10 ], {
+		'dtype': 'generic'
+	});
+
+	minabs(); // $ExpectError
+	minabs( [ x ], {} ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/minabs/examples/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/examples/index.js
new file mode 100644
index 000000000000..b39e9ebe864b
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/examples/index.js
@@ -0,0 +1,33 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var minabs = require( './../lib' );
+
+var xbuf = discreteUniform( 10, -50, 50, {
+	'dtype': 'generic'
+});
+var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+console.log( ndarray2array( x ) );
+
+var v = minabs( [ x ] );
+console.log( v );
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/minabs/lib/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/lib/index.js
new file mode 100644
index 000000000000..0fa9243ad026
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/lib/index.js
@@ -0,0 +1,44 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+/**
+* Compute the minimum absolute value of a one-dimensional ndarray.
+*
+* @module @stdlib/stats/base/ndarray/minabs
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+* var minabs = require( '@stdlib/stats/base/ndarray/minabs' );
+*
+* var xbuf = [ -1.0, 3.0, -4.0, 2.0 ];
+* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+*
+* var v = minabs( [ x ] );
+* // returns 1.0
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/minabs/lib/main.js b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/lib/main.js
new file mode 100644
index 000000000000..e069e5784029
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/lib/main.js
@@ -0,0 +1,55 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var numelDimension = require( '@stdlib/ndarray/base/numel-dimension' );
+var getStride = require( '@stdlib/ndarray/base/stride' );
+var getOffset = require( '@stdlib/ndarray/base/offset' );
+var getData = require( '@stdlib/ndarray/base/data-buffer' );
+var strided = require( '@stdlib/stats/strided/minabs' ).ndarray;
+
+
+// MAIN //
+
+/**
+* Computes the minimum absolute value of a one-dimensional ndarray.
+*
+* @param {ArrayLikeObject<Object>} arrays - array-like object containing an input ndarray
+* @returns {number} minimum absolute value
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+*
+* var xbuf = [ -1.0, 3.0, -4.0, 2.0 ];
+* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+*
+* var v = minabs( [ x ] );
+* // returns 1.0
+*/
+function minabs( arrays ) {
+	var x = arrays[ 0 ];
+	return strided( numelDimension( x, 0 ), getData( x ), getStride( x, 0 ), getOffset( x ) ); // eslint-disable-line max-len
+}
+
+
+// EXPORTS //
+
+module.exports = minabs;
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/minabs/package.json b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/package.json
new file mode 100644
index 000000000000..df3121aca601
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/package.json
@@ -0,0 +1,69 @@
+{
+  "name": "@stdlib/stats/base/ndarray/minabs",
+  "version": "0.0.0",
+  "description": "Compute the minimum absolute value of a one-dimensional ndarray.",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "The Stdlib Authors",
+    "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+  },
+  "contributors": [
+    {
+      "name": "The Stdlib Authors",
+      "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+    }
+  ],
+  "main": "./lib",
+  "directories": {
+    "benchmark": "./benchmark",
+    "doc": "./docs",
+    "example": "./examples",
+    "lib": "./lib",
+    "test": "./test"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://github.com/stdlib-js/stdlib",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/stdlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "stdmath",
+    "statistics",
+    "stats",
+    "mathematics",
+    "math",
+    "minimum",
+    "min",
+    "absolute",
+    "abs",
+    "range",
+    "extremes",
+    "domain",
+    "extent",
+    "ndarray"
+  ],
+  "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/minabs/test/test.js b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/test/test.js
new file mode 100644
index 000000000000..9592cb39dedb
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/minabs/test/test.js
@@ -0,0 +1,172 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var minabs = require( './../lib' );
+
+
+// FUNCTIONS //
+
+/**
+* Returns a one-dimensional ndarray.
+*
+* @private
+* @param {Collection} buffer - underlying data buffer
+* @param {NonNegativeInteger} length - number of indexed elements
+* @param {integer} stride - stride length
+* @param {NonNegativeInteger} offset - index offset
+* @returns {ndarray} one-dimensional ndarray
+*/
+function vector( buffer, length, stride, offset ) {
+	return new ndarray( 'generic', buffer, [ length ], [ stride ], offset, 'row-major' );
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof minabs, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 1', function test( t ) {
+	t.strictEqual( minabs.length, 1, 'has expected arity' );
+	t.end();
+});
+
+tape( 'the function calculates the minimum absolute value of a one-dimensional ndarray', function test( t ) {
+	var x;
+	var v;
+
+	x = [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ];
+	v = minabs( [ vector( x, 6, 1, 0 ) ] );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	x = [ -4.0, -5.0 ];
+	v = minabs( [ vector( x, 2, 1, 0 ) ] );
+	t.strictEqual( v, 4.0, 'returns expected value' );
+
+	x = [ -0.0, 0.0, -0.0 ];
+	v = minabs( [ vector( x, 3, 1, 0 ) ] );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
+
+	x = [ NaN ];
+	v = minabs( [ vector( x, 1, 1, 0 ) ] );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	x = [ NaN, NaN ];
+	v = minabs( [ vector( x, 2, 1, 0 ) ] );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided an empty vector, the function returns `NaN`', function test( t ) {
+	var x;
+	var v;
+
+	x = [];
+
+	v = minabs( [ vector( x, 0, 1, 0 ) ] );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided a vector containing a single element, the function returns that element', function test( t ) {
+	var x;
+	var v;
+
+	x = [ 1.0 ];
+
+	v = minabs( [ vector( x, 1, 1, 0 ) ] );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports one-dimensional ndarrays having non-unit strides', function test( t ) {
+	var x;
+	var v;
+
+	x = [
+		1.0,  // 0
+		2.0,
+		2.0,  // 1
+		-7.0,
+		-2.0, // 2
+		3.0,
+		4.0,  // 3
+		2.0
+	];
+
+	v = minabs( [ vector( x, 4, 2, 0 ) ] );
+
+	t.strictEqual( v, 1.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports one-dimensional ndarrays having negative strides', function test( t ) {
+	var x;
+	var v;
+
+	x = [
+		1.0,  // 3
+		2.0,
+		2.0,  // 2
+		-7.0,
+		-2.0, // 1
+		3.0,
+		4.0,  // 0
+		2.0
+	];
+
+	v = minabs( [ vector( x, 4, -2, 6 ) ] );
+
+	t.strictEqual( v, 1.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports one-dimensional ndarrays having non-zero offsets', function test( t ) {
+	var x;
+	var v;
+
+	x = [
+		2.0,
+		1.0,  // 0
+		2.0,
+		-2.0, // 1
+		-2.0,
+		2.0,  // 2
+		3.0,
+		4.0   // 3
+	];
+
+	v = minabs( [ vector( x, 4, 2, 1 ) ] );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});

From b58d1233b4a139b3f70ba604541ff1ab5bae1dfd Mon Sep 17 00:00:00 2001
From: Gururaj Gurram <143020143+gururaj1512@users.noreply.github.com>
Date: Fri, 15 Aug 2025 16:57:35 +0530
Subject: [PATCH 27/32] feat: add `stats/base/ndarray/dminabs`

PR-URL: https://github.com/stdlib-js/stdlib/pull/7880
Reviewed-by: Athan Reines <kgryte@gmail.com>
---
 .../stats/base/ndarray/dminabs/README.md      | 112 ++++++++++++
 .../ndarray/dminabs/benchmark/benchmark.js    | 102 +++++++++++
 .../stats/base/ndarray/dminabs/docs/repl.txt  |  32 ++++
 .../ndarray/dminabs/docs/types/index.d.ts     |  46 +++++
 .../base/ndarray/dminabs/docs/types/test.ts   |  57 ++++++
 .../base/ndarray/dminabs/examples/index.js    |  33 ++++
 .../stats/base/ndarray/dminabs/lib/index.js   |  45 +++++
 .../stats/base/ndarray/dminabs/lib/main.js    |  56 ++++++
 .../stats/base/ndarray/dminabs/package.json   |  69 +++++++
 .../stats/base/ndarray/dminabs/test/test.js   | 173 ++++++++++++++++++
 10 files changed, 725 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/dminabs/README.md
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/dminabs/benchmark/benchmark.js
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/dminabs/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/dminabs/docs/types/index.d.ts
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/dminabs/docs/types/test.ts
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/dminabs/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/dminabs/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/dminabs/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/dminabs/package.json
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/dminabs/test/test.js

diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/README.md b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/README.md
new file mode 100644
index 000000000000..96f7da6d7b80
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/README.md
@@ -0,0 +1,112 @@
+<!--
+
+@license Apache-2.0
+
+Copyright (c) 2025 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.
+
+-->
+
+# dminabs
+
+> Compute the minimum absolute value of a one-dimensional double-precision floating-point ndarray.
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var dminabs = require( '@stdlib/stats/base/ndarray/dminabs' );
+```
+
+#### dminabs( arrays )
+
+Computes the minimum absolute value of a one-dimensional double-precision floating-point ndarray.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+
+var xbuf = new Float64Array( [ -1.0, 3.0, -4.0, 2.0 ] );
+var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+
+var v = dminabs( [ x ] );
+// returns 1.0
+```
+
+The function has the following parameters:
+
+-   **arrays**: array-like object containing a one-dimensional input ndarray.
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   If provided an empty one-dimensional ndarray, the function returns `NaN`.
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var dminabs = require( '@stdlib/stats/base/ndarray/dminabs' );
+
+var xbuf = discreteUniform( 10, -50, 50, {
+    'dtype': 'float64'
+});
+var x = new ndarray( 'float64', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+console.log( ndarray2array( x ) );
+
+var v = dminabs( [ x ] );
+console.log( v );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<!-- Section for all links. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="links">
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/benchmark/benchmark.js
new file mode 100644
index 000000000000..78eeb79d4c8b
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/benchmark/benchmark.js
@@ -0,0 +1,102 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var pkg = require( './../package.json' ).name;
+var dminabs = require( './../lib' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var xbuf;
+	var x;
+
+	xbuf = uniform( len, -10.0, 10.0, options );
+	x = new ndarray( options.dtype, xbuf, [ len ], [ 1 ], 0, 'row-major' );
+
+	return benchmark;
+
+	function benchmark( b ) {
+		var v;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			v = dminabs( [ x ] );
+			if ( isnan( v ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( v ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( pkg+':len='+len, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/docs/repl.txt b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/docs/repl.txt
new file mode 100644
index 000000000000..c364711e5005
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/docs/repl.txt
@@ -0,0 +1,32 @@
+
+{{alias}}( arrays )
+    Computes the minimum absolute value of a one-dimensional double-precision
+    floating-point ndarray.
+
+    If provided an empty ndarray, the function returns `NaN`.
+
+    Parameters
+    ----------
+    arrays: ArrayLikeObject<ndarray>
+        Array-like object containing a one-dimensional input ndarray.
+
+    Returns
+    -------
+    out: number
+        Minimum absolute value.
+
+    Examples
+    --------
+    > var xbuf = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 2.0 ] );
+    > var dt = 'float64';
+    > var sh = [ xbuf.length ];
+    > var sx = [ 1 ];
+    > var ox = 0;
+    > var ord = 'row-major';
+    > var x = new {{alias:@stdlib/ndarray/ctor}}( dt, xbuf, sh, sx, ox, ord );
+    > {{alias}}( [ x ] )
+    1.0
+
+    See Also
+    --------
+
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/docs/types/index.d.ts
new file mode 100644
index 000000000000..5240aad01ac7
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/docs/types/index.d.ts
@@ -0,0 +1,46 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+// TypeScript Version: 4.1
+
+/// <reference types="@stdlib/types"/>
+
+import { float64ndarray } from '@stdlib/types/ndarray';
+
+/**
+* Computes the minimum absolute value of a one-dimensional double-precision floating-point ndarray.
+*
+* @param arrays - array-like object containing an input ndarray
+* @returns minimum absolute value
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+*
+* var xbuf = new Float64Array( [ -1.0, 3.0, -4.0, 2.0 ] );
+* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+*
+* var v = dminabs( [ x ] );
+* // returns 1.0
+*/
+declare function dminabs( arrays: [ float64ndarray ] ): number;
+
+
+// EXPORTS //
+
+export = dminabs;
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/docs/types/test.ts b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/docs/types/test.ts
new file mode 100644
index 000000000000..0a9b9b2d70ca
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/docs/types/test.ts
@@ -0,0 +1,57 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable space-in-parens */
+
+import zeros = require( '@stdlib/ndarray/zeros' );
+import dminabs = require( './index' );
+
+
+// TESTS //
+
+// The function returns a number...
+{
+	const x = zeros( [ 10 ], {
+		'dtype': 'float64'
+	});
+
+	dminabs( [ x ] ); // $ExpectType number
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an array of ndarrays...
+{
+	dminabs( '10' ); // $ExpectError
+	dminabs( 10 ); // $ExpectError
+	dminabs( true ); // $ExpectError
+	dminabs( false ); // $ExpectError
+	dminabs( null ); // $ExpectError
+	dminabs( undefined ); // $ExpectError
+	dminabs( [] ); // $ExpectError
+	dminabs( {} ); // $ExpectError
+	dminabs( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+	const x = zeros( [ 10 ], {
+		'dtype': 'float64'
+	});
+
+	dminabs(); // $ExpectError
+	dminabs( [ x ], {} ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/examples/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/examples/index.js
new file mode 100644
index 000000000000..c498994ab094
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/examples/index.js
@@ -0,0 +1,33 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var dminabs = require( './../lib' );
+
+var xbuf = discreteUniform( 10, -50, 50, {
+	'dtype': 'float64'
+});
+var x = new ndarray( 'float64', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+console.log( ndarray2array( x ) );
+
+var v = dminabs( [ x ] );
+console.log( v );
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/lib/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/lib/index.js
new file mode 100644
index 000000000000..3e932a90002f
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/lib/index.js
@@ -0,0 +1,45 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+/**
+* Compute the minimum absolute value of a one-dimensional double-precision floating-point ndarray.
+*
+* @module @stdlib/stats/base/ndarray/dminabs
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+* var dminabs = require( '@stdlib/stats/base/ndarray/dminabs' );
+*
+* var xbuf = new Float64Array( [ -1.0, 3.0, -4.0, 2.0 ] );
+* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+*
+* var v = dminabs( [ x ] );
+* // returns 1.0
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/lib/main.js b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/lib/main.js
new file mode 100644
index 000000000000..6d7f6f21937c
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/lib/main.js
@@ -0,0 +1,56 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var numelDimension = require( '@stdlib/ndarray/base/numel-dimension' );
+var getStride = require( '@stdlib/ndarray/base/stride' );
+var getOffset = require( '@stdlib/ndarray/base/offset' );
+var getData = require( '@stdlib/ndarray/base/data-buffer' );
+var strided = require( '@stdlib/stats/strided/dminabs' ).ndarray;
+
+
+// MAIN //
+
+/**
+* Computes the minimum absolute value of a one-dimensional double-precision floating-point ndarray.
+*
+* @param {ArrayLikeObject<Object>} arrays - array-like object containing an input ndarray
+* @returns {number} minimum absolute value
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+*
+* var xbuf = new Float64Array( [ -1.0, 3.0, -4.0, 2.0 ] );
+* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+*
+* var v = dminabs( [ x ] );
+* // returns 1.0
+*/
+function dminabs( arrays ) {
+	var x = arrays[ 0 ];
+	return strided( numelDimension( x, 0 ), getData( x ), getStride( x, 0 ), getOffset( x ) ); // eslint-disable-line max-len
+}
+
+
+// EXPORTS //
+
+module.exports = dminabs;
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/package.json b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/package.json
new file mode 100644
index 000000000000..c802fa073e44
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/package.json
@@ -0,0 +1,69 @@
+{
+  "name": "@stdlib/stats/base/ndarray/dminabs",
+  "version": "0.0.0",
+  "description": "Compute the minimum absolute value of a one-dimensional double-precision floating-point ndarray.",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "The Stdlib Authors",
+    "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+  },
+  "contributors": [
+    {
+      "name": "The Stdlib Authors",
+      "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+    }
+  ],
+  "main": "./lib",
+  "directories": {
+    "benchmark": "./benchmark",
+    "doc": "./docs",
+    "example": "./examples",
+    "lib": "./lib",
+    "test": "./test"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://github.com/stdlib-js/stdlib",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/stdlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "stdmath",
+    "statistics",
+    "stats",
+    "mathematics",
+    "math",
+    "minimum",
+    "min",
+    "absolute",
+    "abs",
+    "range",
+    "extremes",
+    "domain",
+    "extent",
+    "ndarray"
+  ],
+  "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/test/test.js b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/test/test.js
new file mode 100644
index 000000000000..1804ae456f5c
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/dminabs/test/test.js
@@ -0,0 +1,173 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var dminabs = require( './../lib' );
+
+
+// FUNCTIONS //
+
+/**
+* Returns a one-dimensional ndarray.
+*
+* @private
+* @param {Collection} buffer - underlying data buffer
+* @param {NonNegativeInteger} length - number of indexed elements
+* @param {integer} stride - stride length
+* @param {NonNegativeInteger} offset - index offset
+* @returns {ndarray} one-dimensional ndarray
+*/
+function vector( buffer, length, stride, offset ) {
+	return new ndarray( 'float64', buffer, [ length ], [ stride ], offset, 'row-major' );
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dminabs, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 1', function test( t ) {
+	t.strictEqual( dminabs.length, 1, 'has expected arity' );
+	t.end();
+});
+
+tape( 'the function calculates the minimum absolute value of a one-dimensional ndarray', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] );
+	v = dminabs( [ vector( x, 6, 1, 0 ) ] );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	x = new Float64Array( [ -4.0, -5.0 ] );
+	v = dminabs( [ vector( x, 2, 1, 0 ) ] );
+	t.strictEqual( v, 4.0, 'returns expected value' );
+
+	x = new Float64Array( [ -0.0, 0.0, -0.0 ] );
+	v = dminabs( [ vector( x, 3, 1, 0 ) ] );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
+
+	x = new Float64Array( [ NaN ] );
+	v = dminabs( [ vector( x, 1, 1, 0 ) ] );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	x = new Float64Array( [ NaN, NaN ] );
+	v = dminabs( [ vector( x, 2, 1, 0 ) ] );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided an empty vector, the function returns `NaN`', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [] );
+
+	v = dminabs( [ vector( x, 0, 1, 0 ) ] );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided a vector containing a single element, the function returns that element', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [ 1.0 ] );
+
+	v = dminabs( [ vector( x, 1, 1, 0 ) ] );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports one-dimensional ndarrays having non-unit strides', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array([
+		1.0,  // 0
+		2.0,
+		2.0,  // 1
+		-7.0,
+		-2.0, // 2
+		3.0,
+		4.0,  // 3
+		2.0
+	]);
+
+	v = dminabs( [ vector( x, 4, 2, 0 ) ] );
+
+	t.strictEqual( v, 1.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports one-dimensional ndarrays having negative strides', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array([
+		1.0,  // 3
+		2.0,
+		2.0,  // 2
+		-7.0,
+		-2.0, // 1
+		3.0,
+		4.0,  // 0
+		2.0
+	]);
+
+	v = dminabs( [ vector( x, 4, -2, 6 ) ] );
+
+	t.strictEqual( v, 1.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports one-dimensional ndarrays having non-zero offsets', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array([
+		2.0,
+		1.0,  // 0
+		2.0,
+		-2.0, // 1
+		-2.0,
+		2.0,  // 2
+		3.0,
+		4.0   // 3
+	]);
+
+	v = dminabs( [ vector( x, 4, 2, 1 ) ] );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});

From 3f6ab1825eab2f3ef53d570d8e0de24b2474a9bf Mon Sep 17 00:00:00 2001
From: Gururaj Gurram <143020143+gururaj1512@users.noreply.github.com>
Date: Fri, 15 Aug 2025 16:57:55 +0530
Subject: [PATCH 28/32] feat: add `stats/base/ndarray/sminabs`

PR-URL: https://github.com/stdlib-js/stdlib/pull/7881
Co-authored-by: Athan Reines <kgryte@gmail.com>
Reviewed-by: Athan Reines <kgryte@gmail.com>
---
 .../stats/base/ndarray/sminabs/README.md      | 112 ++++++++++++
 .../ndarray/sminabs/benchmark/benchmark.js    | 102 +++++++++++
 .../stats/base/ndarray/sminabs/docs/repl.txt  |  32 ++++
 .../ndarray/sminabs/docs/types/index.d.ts     |  46 +++++
 .../base/ndarray/sminabs/docs/types/test.ts   |  57 ++++++
 .../base/ndarray/sminabs/examples/index.js    |  33 ++++
 .../stats/base/ndarray/sminabs/lib/index.js   |  45 +++++
 .../stats/base/ndarray/sminabs/lib/main.js    |  56 ++++++
 .../stats/base/ndarray/sminabs/package.json   |  69 +++++++
 .../stats/base/ndarray/sminabs/test/test.js   | 173 ++++++++++++++++++
 10 files changed, 725 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sminabs/README.md
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sminabs/benchmark/benchmark.js
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sminabs/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sminabs/docs/types/index.d.ts
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sminabs/docs/types/test.ts
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sminabs/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sminabs/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sminabs/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sminabs/package.json
 create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sminabs/test/test.js

diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/README.md b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/README.md
new file mode 100644
index 000000000000..1bc1a625aabb
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/README.md
@@ -0,0 +1,112 @@
+<!--
+
+@license Apache-2.0
+
+Copyright (c) 2025 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.
+
+-->
+
+# sminabs
+
+> Compute the minimum absolute value of a one-dimensional single-precision floating-point ndarray.
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var sminabs = require( '@stdlib/stats/base/ndarray/sminabs' );
+```
+
+#### sminabs( arrays )
+
+Computes the minimum absolute value of a one-dimensional single-precision floating-point ndarray.
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+
+var xbuf = new Float32Array( [ -1.0, 3.0, -4.0, 2.0 ] );
+var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+
+var v = sminabs( [ x ] );
+// returns 1.0
+```
+
+The function has the following parameters:
+
+-   **arrays**: array-like object containing a one-dimensional input ndarray.
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   If provided an empty one-dimensional ndarray, the function returns `NaN`.
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var sminabs = require( '@stdlib/stats/base/ndarray/sminabs' );
+
+var xbuf = discreteUniform( 10, -50, 50, {
+    'dtype': 'float32'
+});
+var x = new ndarray( 'float32', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+console.log( ndarray2array( x ) );
+
+var v = sminabs( [ x ] );
+console.log( v );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<!-- Section for all links. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="links">
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/benchmark/benchmark.js
new file mode 100644
index 000000000000..b0b4e4c556cb
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/benchmark/benchmark.js
@@ -0,0 +1,102 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var pkg = require( './../package.json' ).name;
+var sminabs = require( './../lib' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float32'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var xbuf;
+	var x;
+
+	xbuf = uniform( len, -10.0, 10.0, options );
+	x = new ndarray( options.dtype, xbuf, [ len ], [ 1 ], 0, 'row-major' );
+
+	return benchmark;
+
+	function benchmark( b ) {
+		var v;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			v = sminabs( [ x ] );
+			if ( isnan( v ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( v ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( pkg+':len='+len, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/docs/repl.txt b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/docs/repl.txt
new file mode 100644
index 000000000000..0bf14d78ab2a
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/docs/repl.txt
@@ -0,0 +1,32 @@
+
+{{alias}}( arrays )
+    Computes the minimum absolute value of a one-dimensional single-precision
+    floating-point ndarray.
+
+    If provided an empty ndarray, the function returns `NaN`.
+
+    Parameters
+    ----------
+    arrays: ArrayLikeObject<ndarray>
+        Array-like object containing a one-dimensional input ndarray.
+
+    Returns
+    -------
+    out: number
+        Minimum absolute value.
+
+    Examples
+    --------
+    > var xbuf = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 2.0 ] );
+    > var dt = 'float32';
+    > var sh = [ xbuf.length ];
+    > var sx = [ 1 ];
+    > var ox = 0;
+    > var ord = 'row-major';
+    > var x = new {{alias:@stdlib/ndarray/ctor}}( dt, xbuf, sh, sx, ox, ord );
+    > {{alias}}( [ x ] )
+    1.0
+
+    See Also
+    --------
+
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/docs/types/index.d.ts
new file mode 100644
index 000000000000..587fc1d146df
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/docs/types/index.d.ts
@@ -0,0 +1,46 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+// TypeScript Version: 4.1
+
+/// <reference types="@stdlib/types"/>
+
+import { float32ndarray } from '@stdlib/types/ndarray';
+
+/**
+* Computes the minimum absolute value of a one-dimensional single-precision floating-point ndarray.
+*
+* @param arrays - array-like object containing an input ndarray
+* @returns minimum absolute value
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+*
+* var xbuf = new Float32Array( [ -1.0, 3.0, -4.0, 2.0 ] );
+* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+*
+* var v = sminabs( [ x ] );
+* // returns 1.0
+*/
+declare function sminabs( arrays: [ float32ndarray ] ): number;
+
+
+// EXPORTS //
+
+export = sminabs;
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/docs/types/test.ts b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/docs/types/test.ts
new file mode 100644
index 000000000000..7189fc72fb07
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/docs/types/test.ts
@@ -0,0 +1,57 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable space-in-parens */
+
+import zeros = require( '@stdlib/ndarray/zeros' );
+import sminabs = require( './index' );
+
+
+// TESTS //
+
+// The function returns a number...
+{
+	const x = zeros( [ 10 ], {
+		'dtype': 'float32'
+	});
+
+	sminabs( [ x ] ); // $ExpectType number
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an array of ndarrays...
+{
+	sminabs( '10' ); // $ExpectError
+	sminabs( 10 ); // $ExpectError
+	sminabs( true ); // $ExpectError
+	sminabs( false ); // $ExpectError
+	sminabs( null ); // $ExpectError
+	sminabs( undefined ); // $ExpectError
+	sminabs( [] ); // $ExpectError
+	sminabs( {} ); // $ExpectError
+	sminabs( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+	const x = zeros( [ 10 ], {
+		'dtype': 'float32'
+	});
+
+	sminabs(); // $ExpectError
+	sminabs( [ x ], {} ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/examples/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/examples/index.js
new file mode 100644
index 000000000000..05d8c3e788ef
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/examples/index.js
@@ -0,0 +1,33 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var sminabs = require( './../lib' );
+
+var xbuf = discreteUniform( 10, -50, 50, {
+	'dtype': 'float32'
+});
+var x = new ndarray( 'float32', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+console.log( ndarray2array( x ) );
+
+var v = sminabs( [ x ] );
+console.log( v );
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/lib/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/lib/index.js
new file mode 100644
index 000000000000..198d9426948a
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/lib/index.js
@@ -0,0 +1,45 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+/**
+* Compute the minimum absolute value of a one-dimensional single-precision floating-point ndarray.
+*
+* @module @stdlib/stats/base/ndarray/sminabs
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+* var sminabs = require( '@stdlib/stats/base/ndarray/sminabs' );
+*
+* var xbuf = new Float32Array( [ -1.0, 3.0, -4.0, 2.0 ] );
+* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+*
+* var v = sminabs( [ x ] );
+* // returns 1.0
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/lib/main.js b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/lib/main.js
new file mode 100644
index 000000000000..ef5ded3dc085
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/lib/main.js
@@ -0,0 +1,56 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var numelDimension = require( '@stdlib/ndarray/base/numel-dimension' );
+var getStride = require( '@stdlib/ndarray/base/stride' );
+var getOffset = require( '@stdlib/ndarray/base/offset' );
+var getData = require( '@stdlib/ndarray/base/data-buffer' );
+var strided = require( '@stdlib/stats/strided/sminabs' ).ndarray;
+
+
+// MAIN //
+
+/**
+* Computes the minimum absolute value of a one-dimensional single-precision floating-point ndarray.
+*
+* @param {ArrayLikeObject<Object>} arrays - array-like object containing an input ndarray
+* @returns {number} minimum value
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+*
+* var xbuf = new Float32Array( [ -1.0, 3.0, -4.0, 2.0 ] );
+* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+*
+* var v = sminabs( [ x ] );
+* // returns 1.0
+*/
+function sminabs( arrays ) {
+	var x = arrays[ 0 ];
+	return strided( numelDimension( x, 0 ), getData( x ), getStride( x, 0 ), getOffset( x ) ); // eslint-disable-line max-len
+}
+
+
+// EXPORTS //
+
+module.exports = sminabs;
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/package.json b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/package.json
new file mode 100644
index 000000000000..bc770d82f654
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/package.json
@@ -0,0 +1,69 @@
+{
+  "name": "@stdlib/stats/base/ndarray/sminabs",
+  "version": "0.0.0",
+  "description": "Compute the minimum absolute value of a one-dimensional single-precision floating-point ndarray.",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "The Stdlib Authors",
+    "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+  },
+  "contributors": [
+    {
+      "name": "The Stdlib Authors",
+      "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+    }
+  ],
+  "main": "./lib",
+  "directories": {
+    "benchmark": "./benchmark",
+    "doc": "./docs",
+    "example": "./examples",
+    "lib": "./lib",
+    "test": "./test"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://github.com/stdlib-js/stdlib",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/stdlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "stdmath",
+    "statistics",
+    "stats",
+    "mathematics",
+    "math",
+    "minimum",
+    "min",
+    "absolute",
+    "abs",
+    "range",
+    "extremes",
+    "domain",
+    "extent",
+    "ndarray"
+  ],
+  "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/test/test.js b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/test/test.js
new file mode 100644
index 000000000000..3c7a5945a7c3
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/base/ndarray/sminabs/test/test.js
@@ -0,0 +1,173 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var isPositiveZerof = require( '@stdlib/math/base/assert/is-positive-zerof' );
+var Float32Array = require( '@stdlib/array/float32' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var sminabs = require( './../lib' );
+
+
+// FUNCTIONS //
+
+/**
+* Returns a one-dimensional ndarray.
+*
+* @private
+* @param {Collection} buffer - underlying data buffer
+* @param {NonNegativeInteger} length - number of indexed elements
+* @param {integer} stride - stride length
+* @param {NonNegativeInteger} offset - index offset
+* @returns {ndarray} one-dimensional ndarray
+*/
+function vector( buffer, length, stride, offset ) {
+	return new ndarray( 'float32', buffer, [ length ], [ stride ], offset, 'row-major' );
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof sminabs, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 1', function test( t ) {
+	t.strictEqual( sminabs.length, 1, 'has expected arity' );
+	t.end();
+});
+
+tape( 'the function calculates the minimum absolute value of a one-dimensional ndarray', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] );
+	v = sminabs( [ vector( x, 6, 1, 0 ) ] );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	x = new Float32Array( [ -4.0, -5.0 ] );
+	v = sminabs( [ vector( x, 2, 1, 0 ) ] );
+	t.strictEqual( v, 4.0, 'returns expected value' );
+
+	x = new Float32Array( [ -0.0, 0.0, -0.0 ] );
+	v = sminabs( [ vector( x, 3, 1, 0 ) ] );
+	t.strictEqual( isPositiveZerof( v ), true, 'returns expected value' );
+
+	x = new Float32Array( [ NaN ] );
+	v = sminabs( [ vector( x, 1, 1, 0 ) ] );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
+
+	x = new Float32Array( [ NaN, NaN ] );
+	v = sminabs( [ vector( x, 2, 1, 0 ) ] );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided an empty vector, the function returns `NaN`', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float32Array( [] );
+
+	v = sminabs( [ vector( x, 0, 1, 0 ) ] );
+	t.strictEqual( isnanf( v ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided a vector containing a single element, the function returns that element', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float32Array( [ 1.0 ] );
+
+	v = sminabs( [ vector( x, 1, 1, 0 ) ] );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports one-dimensional ndarrays having non-unit strides', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float32Array([
+		1.0,  // 0
+		2.0,
+		2.0,  // 1
+		-7.0,
+		-2.0, // 2
+		3.0,
+		4.0,  // 3
+		2.0
+	]);
+
+	v = sminabs( [ vector( x, 4, 2, 0 ) ] );
+
+	t.strictEqual( v, 1.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports one-dimensional ndarrays having negative strides', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float32Array([
+		1.0,  // 3
+		2.0,
+		2.0,  // 2
+		-7.0,
+		-2.0, // 1
+		3.0,
+		4.0,  // 0
+		2.0
+	]);
+
+	v = sminabs( [ vector( x, 4, -2, 6 ) ] );
+
+	t.strictEqual( v, 1.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports one-dimensional ndarrays having non-zero offsets', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float32Array([
+		2.0,
+		1.0,  // 0
+		2.0,
+		-2.0, // 1
+		-2.0,
+		2.0,  // 2
+		3.0,
+		4.0   // 3
+	]);
+
+	v = sminabs( [ vector( x, 4, 2, 1 ) ] );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});

From 9fb612ab6cd5c28d8900c2c7d161bca5ffcc30ff Mon Sep 17 00:00:00 2001
From: Gururaj Gurram <143020143+gururaj1512@users.noreply.github.com>
Date: Fri, 15 Aug 2025 17:08:36 +0530
Subject: [PATCH 29/32] feat: add `stats/minabs`

PR-URL: https://github.com/stdlib-js/stdlib/pull/7883
Co-authored-by: Athan Reines <kgryte@gmail.com>
Reviewed-by: Athan Reines <kgryte@gmail.com>
Co-authored-by: stdlib-bot <noreply@stdlib.io>
---
 .../@stdlib/stats/minabs/README.md            | 266 +++++++
 .../minabs/benchmark/benchmark.assign.js      | 111 +++
 .../stats/minabs/benchmark/benchmark.js       | 105 +++
 .../@stdlib/stats/minabs/docs/repl.txt        |  76 ++
 .../stats/minabs/docs/types/index.d.ts        | 151 ++++
 .../@stdlib/stats/minabs/docs/types/test.ts   | 225 ++++++
 .../@stdlib/stats/minabs/examples/index.js    |  46 ++
 .../@stdlib/stats/minabs/lib/index.js         |  63 ++
 .../@stdlib/stats/minabs/lib/main.js          | 101 +++
 .../@stdlib/stats/minabs/package.json         |  67 ++
 .../@stdlib/stats/minabs/test/test.assign.js  | 717 +++++++++++++++++
 .../@stdlib/stats/minabs/test/test.js         |  39 +
 .../@stdlib/stats/minabs/test/test.main.js    | 753 ++++++++++++++++++
 13 files changed, 2720 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/stats/minabs/README.md
 create mode 100644 lib/node_modules/@stdlib/stats/minabs/benchmark/benchmark.assign.js
 create mode 100644 lib/node_modules/@stdlib/stats/minabs/benchmark/benchmark.js
 create mode 100644 lib/node_modules/@stdlib/stats/minabs/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/stats/minabs/docs/types/index.d.ts
 create mode 100644 lib/node_modules/@stdlib/stats/minabs/docs/types/test.ts
 create mode 100644 lib/node_modules/@stdlib/stats/minabs/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/stats/minabs/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/stats/minabs/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/stats/minabs/package.json
 create mode 100644 lib/node_modules/@stdlib/stats/minabs/test/test.assign.js
 create mode 100644 lib/node_modules/@stdlib/stats/minabs/test/test.js
 create mode 100644 lib/node_modules/@stdlib/stats/minabs/test/test.main.js

diff --git a/lib/node_modules/@stdlib/stats/minabs/README.md b/lib/node_modules/@stdlib/stats/minabs/README.md
new file mode 100644
index 000000000000..2f7ce02d6cf0
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/minabs/README.md
@@ -0,0 +1,266 @@
+<!--
+
+@license Apache-2.0
+
+Copyright (c) 2025 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.
+
+-->
+
+# minabs
+
+> Compute the minimum absolute value along one or more [ndarray][@stdlib/ndarray/ctor] dimensions.
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var minabs = require( '@stdlib/stats/minabs' );
+```
+
+#### minabs( x\[, options] )
+
+Computes the minimum absolute value along one or more [ndarray][@stdlib/ndarray/ctor] dimensions.
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ -1.0, 2.0, -3.0 ] );
+
+var y = minabs( x );
+// returns <ndarray>
+
+var v = y.get();
+// returns 1.0
+```
+
+The function has the following parameters:
+
+-   **x**: input [ndarray][@stdlib/ndarray/ctor]. Must have a real-valued or "generic" [data type][@stdlib/ndarray/dtypes].
+-   **options**: function options (_optional_).
+
+The function accepts the following options:
+
+-   **dims**: list of dimensions over which to perform a reduction. If not provided, the function performs a reduction over all elements in a provided input [ndarray][@stdlib/ndarray/ctor].
+-   **dtype**: output ndarray [data type][@stdlib/ndarray/dtypes]. Must be a real-valued or "generic" [data type][@stdlib/ndarray/dtypes].
+-   **keepdims**: boolean indicating whether the reduced dimensions should be included in the returned [ndarray][@stdlib/ndarray/ctor] as singleton dimensions. Default: `false`.
+
+By default, the function performs a reduction over all elements in a provided input [ndarray][@stdlib/ndarray/ctor]. To perform a reduction over specific dimensions, provide a `dims` option.
+
+```javascript
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ -1.0, 2.0, -3.0, 4.0 ], {
+    'shape': [ 2, 2 ],
+    'order': 'row-major'
+});
+var v = ndarray2array( x );
+// returns [ [ -1.0, 2.0 ], [ -3.0, 4.0 ] ]
+
+var y = minabs( x, {
+    'dims': [ 0 ]
+});
+// returns <ndarray>
+
+v = ndarray2array( y );
+// returns [ 1.0, 2.0 ]
+
+y = minabs( x, {
+    'dims': [ 1 ]
+});
+// returns <ndarray>
+
+v = ndarray2array( y );
+// returns [ 1.0, 3.0 ]
+
+y = minabs( x, {
+    'dims': [ 0, 1 ]
+});
+// returns <ndarray>
+
+v = y.get();
+// returns 1.0
+```
+
+By default, the function excludes reduced dimensions from the output [ndarray][@stdlib/ndarray/ctor]. To include the reduced dimensions as singleton dimensions, set the `keepdims` option to `true`.
+
+```javascript
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ -1.0, 2.0, -3.0, 4.0 ], {
+    'shape': [ 2, 2 ],
+    'order': 'row-major'
+});
+
+var v = ndarray2array( x );
+// returns [ [ -1.0, 2.0 ], [ -3.0, 4.0 ] ]
+
+var y = minabs( x, {
+    'dims': [ 0 ],
+    'keepdims': true
+});
+// returns <ndarray>
+
+v = ndarray2array( y );
+// returns [ [ 1.0, 2.0 ] ]
+
+y = minabs( x, {
+    'dims': [ 1 ],
+    'keepdims': true
+});
+// returns <ndarray>
+
+v = ndarray2array( y );
+// returns [ [ 1.0 ], [ 3.0 ] ]
+
+y = minabs( x, {
+    'dims': [ 0, 1 ],
+    'keepdims': true
+});
+// returns <ndarray>
+
+v = ndarray2array( y );
+// returns [ [ 1.0 ] ]
+```
+
+By default, the function returns an [ndarray][@stdlib/ndarray/ctor] having a [data type][@stdlib/ndarray/dtypes] determined by the function's output data type [policy][@stdlib/ndarray/output-dtype-policies]. To override the default behavior, set the `dtype` option.
+
+```javascript
+var getDType = require( '@stdlib/ndarray/dtype' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ -1.0, 2.0, -3.0 ], {
+    'dtype': 'generic'
+});
+
+var y = minabs( x, {
+    'dtype': 'float64'
+});
+// returns <ndarray>
+
+var dt = getDType( y );
+// returns 'float64'
+```
+
+#### minabs.assign( x, out\[, options] )
+
+Computes the minimum absolute value along one or more [ndarray][@stdlib/ndarray/ctor] dimensions and assigns results to a provided output [ndarray][@stdlib/ndarray/ctor].
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+
+var x = array( [ -1.0, 2.0, -3.0 ] );
+var y = zeros( [] );
+
+var out = minabs.assign( x, y );
+// returns <ndarray>
+
+var v = out.get();
+// returns 1.0
+
+var bool = ( out === y );
+// returns true
+```
+
+The method has the following parameters:
+
+-   **x**: input [ndarray][@stdlib/ndarray/ctor]. Must have a real-valued or generic [data type][@stdlib/ndarray/dtypes].
+-   **out**: output [ndarray][@stdlib/ndarray/ctor].
+-   **options**: function options (_optional_).
+
+The method accepts the following options:
+
+-   **dims**: list of dimensions over which to perform a reduction. If not provided, the function performs a reduction over all elements in a provided input [ndarray][@stdlib/ndarray/ctor].
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   Setting the `keepdims` option to `true` can be useful when wanting to ensure that the output [ndarray][@stdlib/ndarray/ctor] is [broadcast-compatible][@stdlib/ndarray/base/broadcast-shapes] with ndarrays having the same shape as the input [ndarray][@stdlib/ndarray/ctor].
+-   The output data type [policy][@stdlib/ndarray/output-dtype-policies] only applies to the main function and specifies that, by default, the function must return an [ndarray][@stdlib/ndarray/ctor] having the same [data type][@stdlib/ndarray/dtypes] as the input [ndarray][@stdlib/ndarray/ctor]. For the `assign` method, the output [ndarray][@stdlib/ndarray/ctor] is allowed to have any supported output [data type][@stdlib/ndarray/dtypes].
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var minabs = require( '@stdlib/stats/minabs' );
+
+// Generate an array of random numbers:
+var xbuf = discreteUniform( 25, -10, 10, {
+    'dtype': 'generic'
+});
+
+// Wrap in an ndarray:
+var x = new ndarray( 'generic', xbuf, [ 5, 5 ], [ 5, 1 ], 0, 'row-major' );
+console.log( ndarray2array( x ) );
+
+// Perform a reduction:
+var y = minabs( x, {
+    'dims': [ 0 ]
+});
+
+// Resolve the output array data type:
+var dt = getDType( y );
+console.log( dt );
+
+// Print the results:
+console.log( ndarray2array( y ) );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<!-- Section for all links. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="links">
+
+[@stdlib/ndarray/ctor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/ctor
+
+[@stdlib/ndarray/dtypes]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/dtypes
+
+[@stdlib/ndarray/output-dtype-policies]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/output-dtype-policies
+
+[@stdlib/ndarray/base/broadcast-shapes]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/base/broadcast-shapes
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/stats/minabs/benchmark/benchmark.assign.js b/lib/node_modules/@stdlib/stats/minabs/benchmark/benchmark.assign.js
new file mode 100644
index 000000000000..8431d516a627
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/minabs/benchmark/benchmark.assign.js
@@ -0,0 +1,111 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var zeros = require( '@stdlib/array/zeros' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var pkg = require( './../package.json' ).name;
+var minabs = require( './../lib' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var out;
+	var x;
+
+	x = uniform( len, -50.0, 50.0, options );
+	x = new ndarray( options.dtype, x, [ len ], [ 1 ], 0, 'row-major' );
+
+	out = new ndarray( options.dtype, zeros( 1, options.dtype ), [], [ 0 ], 0, 'row-major' );
+
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var o;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			o = minabs.assign( x, out );
+			if ( typeof o !== 'object' ) {
+				b.fail( 'should return an ndarray' );
+			}
+		}
+		b.toc();
+		if ( isnan( o.get() ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( pkg+':assign:dtype='+options.dtype+',len='+len, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/minabs/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/minabs/benchmark/benchmark.js
new file mode 100644
index 000000000000..6de9cfe2a39f
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/minabs/benchmark/benchmark.js
@@ -0,0 +1,105 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var pkg = require( './../package.json' ).name;
+var minabs = require( './../lib' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var x = uniform( len, -50.0, 50.0, options );
+	x = new ndarray( options.dtype, x, [ len ], [ 1 ], 0, 'row-major' );
+
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var o;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			o = minabs( x );
+			if ( typeof o !== 'object' ) {
+				b.fail( 'should return an ndarray' );
+			}
+		}
+		b.toc();
+		if ( isnan( o.get() ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( pkg+':dtype='+options.dtype+',len='+len, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/minabs/docs/repl.txt b/lib/node_modules/@stdlib/stats/minabs/docs/repl.txt
new file mode 100644
index 000000000000..f5079e8df2ab
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/minabs/docs/repl.txt
@@ -0,0 +1,76 @@
+
+{{alias}}( x[, options] )
+    Computes the minimum absolute value along one or more ndarray dimensions.
+
+    Parameters
+    ----------
+    x: ndarray
+        Input array. Must have a real-valued or "generic" data type.
+
+    options: Object (optional)
+        Function options.
+
+    options.dtype: string (optional)
+        Output array data type. Must be a real-valued or "generic" data type.
+
+    options.dims: Array<integer> (optional)
+        List of dimensions over which to perform a reduction. If not provided,
+        the function performs a reduction over all elements in a provided input
+        ndarray.
+
+    options.keepdims: boolean (optional)
+        Boolean indicating whether the reduced dimensions should be included in
+        the returned ndarray as singleton dimensions. Default: false.
+
+    Returns
+    -------
+    out: ndarray
+        Output array.
+
+    Examples
+    --------
+    > var x = {{alias:@stdlib/ndarray/array}}( [ -1.0, 2.0, -3.0, -4.0 ] );
+    > var y = {{alias}}( x );
+    > var v = y.get()
+    1.0
+
+
+{{alias}}.assign( x, out[, options] )
+    Computes the minimum absolute value along one or more ndarray dimensions
+    and assigns results to a provided output ndarray.
+
+    Parameters
+    ----------
+    x: ndarray
+        Input array. Must have a real-valued or generic data type.
+
+    out: ndarray
+        Output array.
+
+    options: Object (optional)
+        Function options.
+
+    options.dims: Array<integer> (optional)
+        List of dimensions over which to perform a reduction. If not provided,
+        the function performs a reduction over all elements in a provided input
+        ndarray.
+
+    Returns
+    -------
+    out: ndarray
+        Output array.
+
+    Examples
+    --------
+    > var x = {{alias:@stdlib/ndarray/array}}( [ -1.0, 2.0, -3.0, -4.0 ] );
+    > var out = {{alias:@stdlib/ndarray/zeros}}( [] );
+    > var y = {{alias}}.assign( x, out )
+    <ndarray>
+    > var bool = ( out === y )
+    true
+    > var v = out.get()
+    1.0
+
+    See Also
+    --------
+
diff --git a/lib/node_modules/@stdlib/stats/minabs/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/minabs/docs/types/index.d.ts
new file mode 100644
index 000000000000..0ac1d555a1f9
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/minabs/docs/types/index.d.ts
@@ -0,0 +1,151 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+// TypeScript Version: 4.1
+
+/// <reference types="@stdlib/types"/>
+
+import { ArrayLike } from '@stdlib/types/array';
+import { RealAndGenericDataType as DataType, typedndarray } from '@stdlib/types/ndarray';
+
+/**
+* Input array.
+*/
+type InputArray<T> = typedndarray<T>;
+
+/**
+* Output array.
+*/
+type OutputArray<U> = typedndarray<U>;
+
+/**
+* Interface defining "base" options.
+*/
+interface BaseOptions {
+	/**
+	* List of dimensions over which to perform a reduction.
+	*/
+	dims?: ArrayLike<number>;
+}
+
+/**
+* Interface defining options.
+*/
+interface Options extends BaseOptions {
+	/**
+	* Output array data type.
+	*/
+	dtype?: DataType;
+
+	/**
+	* Boolean indicating whether the reduced dimensions should be included in the returned array as singleton dimensions. Default: `false`.
+	*/
+	keepdims?: boolean;
+}
+
+/**
+* Interface for performing a reduction on an ndarray.
+*/
+interface Unary {
+	/**
+	* Computes the minimum absolute value along one or more ndarray dimensions.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	*
+	* var y = minabs( x );
+	* // returns <ndarray>
+	*
+	* var v = y.get();
+	* // returns 1.0
+	*/
+	<T = unknown, U = unknown>( x: InputArray<T>, options?: Options ): OutputArray<U>; // NOTE: we lose type specificity here, but retaining specificity would likely be difficult and/or tedious to completely enumerate, as the output ndarray data type is dependent on how `x` interacts with output data type policy and whether that policy has been overridden by `options.dtype`.
+
+	/**
+	* Computes the minimum absolute value along one or more ndarray dimensions and assigns results to a provided output ndarray.
+	*
+	* @param x - input ndarray
+	* @param out - output ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = minabs.assign( x, y );
+	* // returns <ndarray>
+	*
+	* var v = out.get();
+	* // returns 1.0
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	assign<T = unknown, U extends OutputArray<unknown> = OutputArray<unknown>>( x: InputArray<T>, out: U, options?: BaseOptions ): U;
+}
+
+/**
+* Computes the minimum absolute value along one or more ndarray dimensions.
+*
+* @param x - input ndarray
+* @param options - function options
+* @returns output ndarray
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+*
+* var x = array( [ -1.0, 2.0, -3.0 ] );
+*
+* var y = minabs( x );
+* // returns <ndarray>
+*
+* var v = y.get();
+* // returns 1.0
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var zeros = require( '@stdlib/ndarray/zeros' );
+*
+* var x = array( [ -1.0, 2.0, -3.0 ] );
+* var y = zeros( [] );
+*
+* var out = minabs.assign( x, y );
+* // returns <ndarray>
+*
+* var v = out.get();
+* // returns 1.0
+*
+* var bool = ( out === y );
+* // returns true
+*/
+declare const minabs: Unary;
+
+
+// EXPORTS //
+
+export = minabs;
diff --git a/lib/node_modules/@stdlib/stats/minabs/docs/types/test.ts b/lib/node_modules/@stdlib/stats/minabs/docs/types/test.ts
new file mode 100644
index 000000000000..f6dd3a654e61
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/minabs/docs/types/test.ts
@@ -0,0 +1,225 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable space-in-parens */
+
+/// <reference types="@stdlib/types"/>
+
+import zeros = require( '@stdlib/ndarray/zeros' );
+import minabs = require( './index' );
+
+
+// TESTS //
+
+// The function returns an ndarray...
+{
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
+
+	minabs<number, number>( x ); // $ExpectType OutputArray<number>
+	minabs<number, number>( x, {} ); // $ExpectType OutputArray<number>
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an ndarray...
+{
+	minabs( '5' ); // $ExpectError
+	minabs( 5 ); // $ExpectError
+	minabs( true ); // $ExpectError
+	minabs( false ); // $ExpectError
+	minabs( null ); // $ExpectError
+	minabs( void 0 ); // $ExpectError
+	minabs( {} ); // $ExpectError
+	minabs( ( x: number ): number => x ); // $ExpectError
+
+	minabs( '5', {} ); // $ExpectError
+	minabs( 5, {} ); // $ExpectError
+	minabs( true, {} ); // $ExpectError
+	minabs( false, {} ); // $ExpectError
+	minabs( null, {} ); // $ExpectError
+	minabs( void 0, {} ); // $ExpectError
+	minabs( {}, {} ); // $ExpectError
+	minabs( ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not an object...
+{
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
+
+	minabs( x, '5' ); // $ExpectError
+	minabs( x, true ); // $ExpectError
+	minabs( x, false ); // $ExpectError
+	minabs( x, null ); // $ExpectError
+	minabs( x, [] ); // $ExpectError
+	minabs( x, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an invalid `dtype` option...
+{
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
+
+	minabs( x, { 'dtype': '5' } ); // $ExpectError
+	minabs( x, { 'dtype': 5 } ); // $ExpectError
+	minabs( x, { 'dtype': true } ); // $ExpectError
+	minabs( x, { 'dtype': false } ); // $ExpectError
+	minabs( x, { 'dtype': null } ); // $ExpectError
+	minabs( x, { 'dtype': [] } ); // $ExpectError
+	minabs( x, { 'dtype': {} } ); // $ExpectError
+	minabs( x, { 'dtype': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an invalid `keepdims` option...
+{
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
+
+	minabs( x, { 'keepdims': '5' } ); // $ExpectError
+	minabs( x, { 'keepdims': 5 } ); // $ExpectError
+	minabs( x, { 'keepdims': null } ); // $ExpectError
+	minabs( x, { 'keepdims': [] } ); // $ExpectError
+	minabs( x, { 'keepdims': {} } ); // $ExpectError
+	minabs( x, { 'keepdims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an invalid `dims` option...
+{
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
+
+	minabs( x, { 'dims': '5' } ); // $ExpectError
+	minabs( x, { 'dims': 5 } ); // $ExpectError
+	minabs( x, { 'dims': true } ); // $ExpectError
+	minabs( x, { 'dims': false } ); // $ExpectError
+	minabs( x, { 'dims': null } ); // $ExpectError
+	minabs( x, { 'dims': {} } ); // $ExpectError
+	minabs( x, { 'dims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
+
+	minabs(); // $ExpectError
+	minabs( x, {}, {} ); // $ExpectError
+}
+
+// Attached to the function is an `assign` method which returns an ndarray...
+{
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
+
+	minabs.assign( x, x ); // $ExpectType float64ndarray
+	minabs.assign( x, x, {} ); // $ExpectType float64ndarray
+}
+
+// The compiler throws an error if the `assign` method is provided a first argument which is not an ndarray...
+{
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
+
+	minabs.assign( '5', x ); // $ExpectError
+	minabs.assign( 5, x ); // $ExpectError
+	minabs.assign( true, x ); // $ExpectError
+	minabs.assign( false, x ); // $ExpectError
+	minabs.assign( null, x ); // $ExpectError
+	minabs.assign( void 0, x ); // $ExpectError
+	minabs.assign( {}, x ); // $ExpectError
+	minabs.assign( ( x: number ): number => x, x ); // $ExpectError
+
+	minabs.assign( '5', x, {} ); // $ExpectError
+	minabs.assign( 5, x, {} ); // $ExpectError
+	minabs.assign( true, x, {} ); // $ExpectError
+	minabs.assign( false, x, {} ); // $ExpectError
+	minabs.assign( null, x, {} ); // $ExpectError
+	minabs.assign( void 0, x, {} ); // $ExpectError
+	minabs.assign( {}, x, {} ); // $ExpectError
+	minabs.assign( ( x: number ): number => x, x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a second argument which is not an ndarray...
+{
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
+
+	minabs.assign( x, '5' ); // $ExpectError
+	minabs.assign( x, 5 ); // $ExpectError
+	minabs.assign( x, true ); // $ExpectError
+	minabs.assign( x, false ); // $ExpectError
+	minabs.assign( x, null ); // $ExpectError
+	minabs.assign( x, void 0 ); // $ExpectError
+	minabs.assign( x, ( x: number ): number => x ); // $ExpectError
+
+	minabs.assign( x, '5', {} ); // $ExpectError
+	minabs.assign( x, 5, {} ); // $ExpectError
+	minabs.assign( x, true, {} ); // $ExpectError
+	minabs.assign( x, false, {} ); // $ExpectError
+	minabs.assign( x, null, {} ); // $ExpectError
+	minabs.assign( x, void 0, {} ); // $ExpectError
+	minabs.assign( x, ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a third argument which is not an object...
+{
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
+
+	minabs.assign( x, x, '5' ); // $ExpectError
+	minabs.assign( x, x, true ); // $ExpectError
+	minabs.assign( x, x, false ); // $ExpectError
+	minabs.assign( x, x, null ); // $ExpectError
+	minabs.assign( x, x, [] ); // $ExpectError
+	minabs.assign( x, x, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided an invalid `dims` option...
+{
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
+
+	minabs.assign( x, x, { 'dims': '5' } ); // $ExpectError
+	minabs.assign( x, x, { 'dims': 5 } ); // $ExpectError
+	minabs.assign( x, x, { 'dims': true } ); // $ExpectError
+	minabs.assign( x, x, { 'dims': false } ); // $ExpectError
+	minabs.assign( x, x, { 'dims': null } ); // $ExpectError
+	minabs.assign( x, x, { 'dims': {} } ); // $ExpectError
+	minabs.assign( x, x, { 'dims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided an unsupported number of arguments...
+{
+	const x = zeros( [ 2, 2 ], {
+		'dtype': 'float64'
+	});
+
+	minabs.assign(); // $ExpectError
+	minabs.assign( x ); // $ExpectError
+	minabs.assign( x, x, {}, {} ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/stats/minabs/examples/index.js b/lib/node_modules/@stdlib/stats/minabs/examples/index.js
new file mode 100644
index 000000000000..8a5a77694fc9
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/minabs/examples/index.js
@@ -0,0 +1,46 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var minabs = require( './../lib' );
+
+// Generate an array of random numbers:
+var xbuf = discreteUniform( 25, -10, 10, {
+	'dtype': 'generic'
+});
+
+// Wrap in an ndarray:
+var x = new ndarray( 'generic', xbuf, [ 5, 5 ], [ 5, 1 ], 0, 'row-major' );
+console.log( ndarray2array( x ) );
+
+// Perform a reduction:
+var y = minabs( x, {
+	'dims': [ 0 ]
+});
+
+// Resolve the output array data type:
+var dt = getDType( y );
+console.log( dt );
+
+// Print the results:
+console.log( ndarray2array( y ) );
diff --git a/lib/node_modules/@stdlib/stats/minabs/lib/index.js b/lib/node_modules/@stdlib/stats/minabs/lib/index.js
new file mode 100644
index 000000000000..be18a83af862
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/minabs/lib/index.js
@@ -0,0 +1,63 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+/**
+* Compute the minimum absolute value along one or more ndarray dimensions.
+*
+* @module @stdlib/stats/minabs
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var minabs = require( '@stdlib/stats/minabs' );
+*
+* // Create a data buffer:
+* var xbuf = new Float64Array( [ 0.0, 2.0, 3.0, 0.0, 0.0, 6.0, 7.0, 0.0, 0.0, 10.0, 11.0, 0.0 ] );
+*
+* // Define the shape of the input array:
+* var sh = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 4, 1 ];
+*
+* // Define the index offset:
+* var ox = 1;
+*
+* // Create an input ndarray:
+* var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+*
+* // Perform reduction:
+* var out = minabs( x );
+* // returns <ndarray>
+*
+* var v = out.get();
+* // returns 2.0
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
+
+// exports: { "assign": "main.assign" }
diff --git a/lib/node_modules/@stdlib/stats/minabs/lib/main.js b/lib/node_modules/@stdlib/stats/minabs/lib/main.js
new file mode 100644
index 000000000000..1d5d2553a0e6
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/minabs/lib/main.js
@@ -0,0 +1,101 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var dtypes = require( '@stdlib/ndarray/dtypes' );
+var gminabs = require( '@stdlib/stats/base/ndarray/minabs' );
+var dminabs = require( '@stdlib/stats/base/ndarray/dminabs' );
+var sminabs = require( '@stdlib/stats/base/ndarray/sminabs' );
+var factory = require( '@stdlib/ndarray/base/unary-reduce-strided1d-dispatch-factory' );
+
+
+// VARIABLES //
+
+var idtypes = dtypes( 'real_and_generic' );
+var odtypes = dtypes( 'real_and_generic' );
+var policies = {
+	'output': 'same',
+	'casting': 'none'
+};
+var table = {
+	'types': [
+		'float64', // input
+		'float32'  // input
+	],
+	'fcns': [
+		dminabs,
+		sminabs
+	],
+	'default': gminabs
+};
+
+
+// MAIN //
+
+/**
+* Computes the minimum absolute value along one or more ndarray dimensions.
+*
+* @name minabs
+* @type {Function}
+* @param {ndarray} x - input ndarray
+* @param {Options} [options] - function options
+* @param {IntegerArray} [options.dims] - list of dimensions over which to perform a reduction
+* @param {boolean} [options.keepdims=false] - boolean indicating whether the reduced dimensions should be included in the returned ndarray as singleton dimensions
+* @param {string} [options.dtype] - output ndarray data type
+* @throws {TypeError} first argument must be an ndarray-like object
+* @throws {TypeError} options argument must be an object
+* @throws {RangeError} dimension indices must not exceed input ndarray bounds
+* @throws {RangeError} number of dimension indices must not exceed the number of input ndarray dimensions
+* @throws {Error} must provide valid options
+* @returns {ndarray} output ndarray
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+*
+* // Create a data buffer:
+* var xbuf = new Float64Array( [ 0.0, 2.0, 3.0, 0.0, 0.0, 6.0, 7.0, 0.0, 0.0, 10.0, 11.0, 0.0 ] );
+*
+* // Define the shape of the input array:
+* var sh = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 4, 1 ];
+*
+* // Define the index offset:
+* var ox = 1;
+*
+* // Create an input ndarray:
+* var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+*
+* // Perform reduction:
+* var out = minabs( x );
+* // returns <ndarray>
+*
+* var v = out.get();
+* // returns 2.0
+*/
+var minabs = factory( table, [ idtypes ], odtypes, policies );
+
+
+// EXPORTS //
+
+module.exports = minabs;
diff --git a/lib/node_modules/@stdlib/stats/minabs/package.json b/lib/node_modules/@stdlib/stats/minabs/package.json
new file mode 100644
index 000000000000..462888641bf7
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/minabs/package.json
@@ -0,0 +1,67 @@
+{
+  "name": "@stdlib/stats/minabs",
+  "version": "0.0.0",
+  "description": "Compute the minimum absolute value along one or more ndarray dimensions.",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "The Stdlib Authors",
+    "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+  },
+  "contributors": [
+    {
+      "name": "The Stdlib Authors",
+      "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+    }
+  ],
+  "main": "./lib",
+  "directories": {
+    "benchmark": "./benchmark",
+    "doc": "./docs",
+    "example": "./examples",
+    "lib": "./lib",
+    "test": "./test"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://github.com/stdlib-js/stdlib",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/stdlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "stdmath",
+    "statistics",
+    "stats",
+    "mathematics",
+    "math",
+    "minimum",
+    "min",
+    "range",
+    "extremes",
+    "domain",
+    "extent",
+    "ndarray"
+  ],
+  "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/stats/minabs/test/test.assign.js b/lib/node_modules/@stdlib/stats/minabs/test/test.assign.js
new file mode 100644
index 000000000000..c6d19982d020
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/minabs/test/test.assign.js
@@ -0,0 +1,717 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+var empty = require( '@stdlib/ndarray/empty' );
+var emptyLike = require( '@stdlib/ndarray/empty-like' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var minabs = require( './../lib' ).assign;
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof minabs, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object', function test( t ) {
+	var values;
+	var out;
+	var i;
+
+	out = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		'5',
+		5,
+		NaN,
+		true,
+		false,
+		null,
+		void 0,
+		[],
+		{},
+		function noop() {}
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( value, out );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object (options)', function test( t ) {
+	var values;
+	var out;
+	var i;
+
+	out = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		'5',
+		5,
+		NaN,
+		true,
+		false,
+		null,
+		void 0,
+		[],
+		{},
+		function noop() {}
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( value, out, {} );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type', function test( t ) {
+	var values;
+	var out;
+	var i;
+
+	out = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		empty( [ 2, 2 ], {
+			'dtype': 'bool'
+		})
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( value, out );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type (options)', function test( t ) {
+	var values;
+	var out;
+	var i;
+
+	out = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		empty( [ 2, 2 ], {
+			'dtype': 'bool'
+		})
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( value, out, {} );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a second argument which is not an ndarray-like object', function test( t ) {
+	var values;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		'5',
+		5,
+		NaN,
+		true,
+		false,
+		null,
+		void 0,
+		[],
+		{},
+		function noop() {}
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, value );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a second argument which is not an ndarray-like object (options)', function test( t ) {
+	var values;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		'5',
+		5,
+		NaN,
+		true,
+		false,
+		null,
+		void 0,
+		[],
+		{},
+		function noop() {}
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, value, {} );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a third argument which is not an object', function test( t ) {
+	var values;
+	var out;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+	out = zeros( [], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		'5',
+		5,
+		NaN,
+		true,
+		false,
+		null,
+		void 0,
+		[],
+		function noop() {}
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, out, value );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a `dims` option which is not an array-like object of integers', function test( t ) {
+	var values;
+	var out;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+	out = zeros( [], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		'5',
+		5,
+		NaN,
+		true,
+		false,
+		null,
+		void 0,
+		[ 'a' ],
+		{},
+		function noop() {}
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, out, {
+				'dims': value
+			});
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains out-of-bounds indices', function test( t ) {
+	var values;
+	var out;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+	out = zeros( [ 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		[ -10 ],
+		[ 20 ]
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, out, {
+				'dims': value
+			});
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains too many indices', function test( t ) {
+	var values;
+	var out;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+	out = zeros( [], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		[ 0, 1, 2 ],
+		[ 0, 1, 2, 3 ]
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, out, {
+				'dims': value
+			});
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains duplicate indices', function test( t ) {
+	var values;
+	var out;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+	out = zeros( [], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		[ 0, 0 ],
+		[ 1, 1 ],
+		[ 0, 1, 0 ],
+		[ 1, 0, 1 ]
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, out, {
+				'dims': value
+			});
+		};
+	}
+});
+
+tape( 'the function throws an error if provided an output array which has an invalid shape (default)', function test( t ) {
+	var values;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		[ 2, 2 ],
+		[ 2 ],
+		[ 4, 4 ],
+		[ 4 ],
+		[ 1 ],
+		[ 1, 1 ]
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			var out = zeros( value, {
+				'dtype': 'generic'
+			});
+			minabs( x, out );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided an output array which has an invalid shape (all dimensions)', function test( t ) {
+	var values;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		[ 2, 2 ],
+		[ 2 ],
+		[ 4, 4 ],
+		[ 4 ],
+		[ 1 ],
+		[ 1, 1 ]
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			var out = zeros( value, {
+				'dtype': 'generic'
+			});
+			minabs( x, out, {
+				'dims': [ 0, 1 ]
+			});
+		};
+	}
+});
+
+tape( 'the function throws an error if provided an output array which has an invalid shape (some dimensions)', function test( t ) {
+	var values;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		[],
+		[ 4, 4 ],
+		[ 4 ],
+		[ 1 ],
+		[ 1, 1 ]
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			var out = zeros( value, {
+				'dtype': 'generic'
+			});
+			minabs( x, out, {
+				'dims': [ 0 ]
+			});
+		};
+	}
+});
+
+tape( 'the function performs a reduction on an ndarray (default, row-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var out;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	out = emptyLike( x, {
+		'shape': []
+	});
+
+	actual = minabs( x, out );
+	expected = 1.0;
+
+	t.strictEqual( actual, out, 'returns expected value' );
+	t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (default, column-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var out;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	out = emptyLike( x, {
+		'shape': []
+	});
+
+	actual = minabs( x, out );
+	expected = 1.0;
+
+	t.strictEqual( actual, out, 'returns expected value' );
+	t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, row-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var out;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	out = emptyLike( x, {
+		'shape': []
+	});
+
+	actual = minabs( x, out, {
+		'dims': [ 0, 1 ]
+	});
+	expected = 1.0;
+
+	t.strictEqual( actual, out, 'returns expected value' );
+	t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, column-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var out;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	out = emptyLike( x, {
+		'shape': []
+	});
+
+	actual = minabs( x, out, {
+		'dims': [ 0, 1 ]
+	});
+	expected = 1.0;
+
+	t.strictEqual( actual, out, 'returns expected value' );
+	t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, row-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var out;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	out = emptyLike( x, {
+		'shape': [ 2, 2 ]
+	});
+
+	actual = minabs( x, out, {
+		'dims': []
+	});
+	expected = [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ];
+
+	t.strictEqual( actual, out, 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, column-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var out;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	out = emptyLike( x, {
+		'shape': [ 2, 2 ]
+	});
+
+	actual = minabs( x, out, {
+		'dims': []
+	});
+	expected = [ [ 1.0, 3.0 ], [ 2.0, 4.0 ] ];
+
+	t.strictEqual( actual, out, 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (row-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var out;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	out = emptyLike( x, {
+		'shape': [ 2 ]
+	});
+
+	actual = minabs( x, out, {
+		'dims': [ 0 ]
+	});
+	expected = [ 1.0, 2.0 ];
+
+	t.strictEqual( actual, out, 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	out = emptyLike( x, {
+		'shape': [ 2 ]
+	});
+
+	actual = minabs( x, out, {
+		'dims': [ 1 ]
+	});
+	expected = [ 1.0, 3.0 ];
+
+	t.strictEqual( actual, out, 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (column-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var out;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	out = emptyLike( x, {
+		'shape': [ 2 ]
+	});
+
+	actual = minabs( x, out, {
+		'dims': [ 0 ]
+	});
+	expected = [ 1.0, 3.0 ];
+
+	t.strictEqual( actual, out, 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	out = emptyLike( x, {
+		'shape': [ 2 ]
+	});
+
+	actual = minabs( x, out, {
+		'dims': [ 1 ]
+	});
+	expected = [ 1.0, 2.0 ];
+
+	t.strictEqual( actual, out, 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/minabs/test/test.js b/lib/node_modules/@stdlib/stats/minabs/test/test.js
new file mode 100644
index 000000000000..0dd9f163dbd2
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/minabs/test/test.js
@@ -0,0 +1,39 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isMethod = require( '@stdlib/assert/is-method' );
+var minabs = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof minabs, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'attached to the main export is an `assign` method', function test( t ) {
+	t.strictEqual( isMethod( minabs, 'assign' ), true, 'returns expected value' );
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/minabs/test/test.main.js b/lib/node_modules/@stdlib/stats/minabs/test/test.main.js
new file mode 100644
index 000000000000..3bbcf6b9b835
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/minabs/test/test.main.js
@@ -0,0 +1,753 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+var empty = require( '@stdlib/ndarray/empty' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var getShape = require( '@stdlib/ndarray/shape' );
+var getOrder = require( '@stdlib/ndarray/order' );
+var minabs = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof minabs, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object', function test( t ) {
+	var values;
+	var i;
+
+	values = [
+		'5',
+		5,
+		NaN,
+		true,
+		false,
+		null,
+		void 0,
+		[],
+		{},
+		function noop() {}
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( value );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object (options)', function test( t ) {
+	var values;
+	var i;
+
+	values = [
+		'5',
+		5,
+		NaN,
+		true,
+		false,
+		null,
+		void 0,
+		[],
+		{},
+		function noop() {}
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( value, {} );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type', function test( t ) {
+	var values;
+	var i;
+
+	values = [
+		empty( [ 2, 2 ], {
+			'dtype': 'bool'
+		})
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( value );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type (options)', function test( t ) {
+	var values;
+	var i;
+
+	values = [
+		empty( [ 2, 2 ], {
+			'dtype': 'bool'
+		})
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( value, {} );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a second argument which is not an object', function test( t ) {
+	var values;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		'5',
+		5,
+		NaN,
+		true,
+		false,
+		null,
+		void 0,
+		[],
+		function noop() {}
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, value );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a `dtype` option which is not a supported data type', function test( t ) {
+	var values;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		'foo',
+		'bar',
+		'beep',
+		'boop'
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, {
+				'dtype': value
+			});
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a `keepdims` option which is not a boolean', function test( t ) {
+	var values;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		'5',
+		5,
+		NaN,
+		null,
+		void 0,
+		[],
+		{},
+		function noop() {}
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, {
+				'keepdims': value
+			});
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a `dims` option which is not an array-like object of integers', function test( t ) {
+	var values;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		'5',
+		5,
+		NaN,
+		true,
+		false,
+		null,
+		void 0,
+		[ 'a' ],
+		{},
+		function noop() {}
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, {
+				'dims': value
+			});
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains out-of-bounds indices', function test( t ) {
+	var values;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		[ -10 ],
+		[ 0, 20 ],
+		[ 20 ]
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, {
+				'dims': value
+			});
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains too many indices', function test( t ) {
+	var values;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		[ 0, 1, 2 ],
+		[ 0, 1, 2, 3 ]
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, {
+				'dims': value
+			});
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains duplicate indices', function test( t ) {
+	var values;
+	var x;
+	var i;
+
+	x = zeros( [ 2, 2 ], {
+		'dtype': 'generic'
+	});
+
+	values = [
+		[ 0, 0 ],
+		[ 1, 1 ],
+		[ 0, 1, 0 ],
+		[ 1, 0, 1 ]
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			minabs( x, {
+				'dims': value
+			});
+		};
+	}
+});
+
+tape( 'the function performs a reduction on an ndarray (default, row-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	actual = minabs( x );
+	expected = 1.0;
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (default, column-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	actual = minabs( x );
+	expected = 1.0;
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, row-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	actual = minabs( x, {
+		'dims': [ 0, 1 ]
+	});
+	expected = 1.0;
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	actual = minabs( x, {
+		'dims': [ 0, 1 ],
+		'keepdims': false
+	});
+	expected = 1.0;
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	actual = minabs( x, {
+		'dims': [ 0, 1 ],
+		'keepdims': true
+	});
+	expected = [ [ 1.0 ] ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 1, 1 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, column-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	actual = minabs( x, {
+		'dims': [ 0, 1 ]
+	});
+	expected = 1.0;
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	actual = minabs( x, {
+		'dims': [ 0, 1 ],
+		'keepdims': false
+	});
+	expected = 1.0;
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	actual = minabs( x, {
+		'dims': [ 0, 1 ],
+		'keepdims': true
+	});
+	expected = [ [ 1.0 ] ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 1, 1 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, row-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	actual = minabs( x, {
+		'dims': [],
+		'keepdims': false
+	});
+	expected = [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	actual = minabs( x, {
+		'dims': [],
+		'keepdims': true
+	});
+	expected = [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, column-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	actual = minabs( x, {
+		'dims': [],
+		'keepdims': false
+	});
+	expected = [ [ 1.0, 3.0 ], [ 2.0, 4.0 ] ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	actual = minabs( x, {
+		'dims': [],
+		'keepdims': true
+	});
+	expected = [ [ 1.0, 3.0 ], [ 2.0, 4.0 ] ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (row-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	actual = minabs( x, {
+		'dims': [ 0 ],
+		'keepdims': false
+	});
+	expected = [ 1.0, 2.0 ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	actual = minabs( x, {
+		'dims': [ 0 ],
+		'keepdims': true
+	});
+	expected = [ [ 1.0, 2.0 ] ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 1, 2 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	actual = minabs( x, {
+		'dims': [ 1 ],
+		'keepdims': false
+	});
+	expected = [ 1.0, 3.0 ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	actual = minabs( x, {
+		'dims': [ 1 ],
+		'keepdims': true
+	});
+	expected = [ [ 1.0 ], [ 3.0 ] ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 2, 1 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (column-major)', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	actual = minabs( x, {
+		'dims': [ 0 ],
+		'keepdims': false
+	});
+	expected = [ 1.0, 3.0 ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	actual = minabs( x, {
+		'dims': [ 0 ],
+		'keepdims': true
+	});
+	expected = [ [ 1.0, 3.0 ] ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 1, 2 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	actual = minabs( x, {
+		'dims': [ 1 ],
+		'keepdims': false
+	});
+	expected = [ 1.0, 2.0 ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	actual = minabs( x, {
+		'dims': [ 1 ],
+		'keepdims': true
+	});
+	expected = [ [ 1.0 ], [ 2.0 ] ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'generic', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [ 2, 1 ], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying the output array data type', function test( t ) {
+	var expected;
+	var actual;
+	var xbuf;
+	var x;
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+	actual = minabs( x, {
+		'dtype': 'float64'
+	});
+	expected = 1.0;
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'float64', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+	xbuf = [ -1.0, 2.0, -3.0, 4.0 ];
+	x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+	actual = minabs( x, {
+		'dtype': 'float64'
+	});
+	expected = 1.0;
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( getDType( actual ), 'float64', 'returns expected value' );
+	t.deepEqual( getShape( actual ), [], 'returns expected value' );
+	t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+	t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+	t.end();
+});

From f2f4cba93e4b45064b4197f7c90f22abf8f3fb8c Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Fri, 15 Aug 2025 05:48:08 -0700
Subject: [PATCH 30/32] fix: address assignment bug

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../base/unary-reduce-strided1d/lib/10d_blocked.js     | 10 +++++-----
 .../lib/10d_blocked_accessors.js                       | 10 +++++-----
 .../base/unary-reduce-strided1d/lib/6d_blocked.js      |  2 +-
 .../unary-reduce-strided1d/lib/6d_blocked_accessors.js |  2 +-
 .../base/unary-reduce-strided1d/lib/7d_blocked.js      |  4 ++--
 .../unary-reduce-strided1d/lib/7d_blocked_accessors.js |  4 ++--
 .../base/unary-reduce-strided1d/lib/8d_blocked.js      |  6 +++---
 .../unary-reduce-strided1d/lib/8d_blocked_accessors.js |  6 +++---
 .../base/unary-reduce-strided1d/lib/9d_blocked.js      |  8 ++++----
 .../unary-reduce-strided1d/lib/9d_blocked_accessors.js |  8 ++++----
 10 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/10d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/10d_blocked.js
index af99e07bdc4f..f590cf96962b 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/10d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/10d_blocked.js
@@ -261,7 +261,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 				j8 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv9 = sv[k][9] - ( s8*sv[k][8] );
+				dv9[ k ] = sv[k][9] - ( s8*sv[k][8] );
 				ov8[ k ] = ov9[k] + ( j8*sv[k][8] );
 			}
 			for ( j7 = sh[7]; j7 > 0; ) {
@@ -273,7 +273,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 					j7 -= bsize;
 				}
 				for ( k = 0; k < N; k++ ) {
-					dv8 = sv[k][8] - ( s7*sv[k][7] );
+					dv8[ k ] = sv[k][8] - ( s7*sv[k][7] );
 					ov7[ k ] = ov8[k] + ( j7*sv[k][7] );
 				}
 				for ( j6 = sh[6]; j6 > 0; ) {
@@ -285,7 +285,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 						j6 -= bsize;
 					}
 					for ( k = 0; k < N; k++ ) {
-						dv7 = sv[k][7] - ( s6*sv[k][6] );
+						dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
 						ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
 					}
 					for ( j5 = sh[5]; j5 > 0; ) {
@@ -297,7 +297,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 							j5 -= bsize;
 						}
 						for ( k = 0; k < N; k++ ) {
-							dv6 = sv[k][6] - ( s5*sv[k][5] );
+							dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
 							ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
 						}
 						for ( j4 = sh[4]; j4 > 0; ) {
@@ -309,7 +309,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 								j4 -= bsize;
 							}
 							for ( k = 0; k < N; k++ ) {
-								dv5 = sv[k][5] - ( s4*sv[k][4] );
+								dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 								ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 							}
 							for ( j3 = sh[3]; j3 > 0; ) {
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/10d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/10d_blocked_accessors.js
index 0d6206986975..82552bdd38f7 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/10d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/10d_blocked_accessors.js
@@ -269,7 +269,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 				j8 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv9 = sv[k][9] - ( s8*sv[k][8] );
+				dv9[ k ] = sv[k][9] - ( s8*sv[k][8] );
 				ov8[ k ] = ov9[k] + ( j8*sv[k][8] );
 			}
 			for ( j7 = sh[7]; j7 > 0; ) {
@@ -281,7 +281,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 					j7 -= bsize;
 				}
 				for ( k = 0; k < N; k++ ) {
-					dv8 = sv[k][8] - ( s7*sv[k][7] );
+					dv8[ k ] = sv[k][8] - ( s7*sv[k][7] );
 					ov7[ k ] = ov8[k] + ( j7*sv[k][7] );
 				}
 				for ( j6 = sh[6]; j6 > 0; ) {
@@ -293,7 +293,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 						j6 -= bsize;
 					}
 					for ( k = 0; k < N; k++ ) {
-						dv7 = sv[k][7] - ( s6*sv[k][6] );
+						dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
 						ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
 					}
 					for ( j5 = sh[5]; j5 > 0; ) {
@@ -305,7 +305,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 							j5 -= bsize;
 						}
 						for ( k = 0; k < N; k++ ) {
-							dv6 = sv[k][6] - ( s5*sv[k][5] );
+							dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
 							ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
 						}
 						for ( j4 = sh[4]; j4 > 0; ) {
@@ -317,7 +317,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 								j4 -= bsize;
 							}
 							for ( k = 0; k < N; k++ ) {
-								dv5 = sv[k][5] - ( s4*sv[k][4] );
+								dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 								ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 							}
 							for ( j3 = sh[3]; j3 > 0; ) {
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/6d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/6d_blocked.js
index 94f0d591496c..96da633660f9 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/6d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/6d_blocked.js
@@ -233,7 +233,7 @@ function blockedunary6d( fcn, arrays, views, strides, strategy, opts ) { // esli
 				j4 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv5 = sv[k][5] - ( s4*sv[k][4] );
+				dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 				ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 			}
 			for ( j3 = sh[3]; j3 > 0; ) {
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/6d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/6d_blocked_accessors.js
index 16364307e934..08fe55e82097 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/6d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/6d_blocked_accessors.js
@@ -241,7 +241,7 @@ function blockedunary6d( fcn, arrays, views, strides, strategy, opts ) { // esli
 				j4 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv5 = sv[k][5] - ( s4*sv[k][4] );
+				dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 				ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 			}
 			for ( j3 = sh[3]; j3 > 0; ) {
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/7d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/7d_blocked.js
index 202f72d112ff..4b19abf9625a 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/7d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/7d_blocked.js
@@ -240,7 +240,7 @@ function blockedunary7d( fcn, arrays, views, strides, strategy, opts ) { // esli
 				j5 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv6 = sv[k][6] - ( s5*sv[k][5] );
+				dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
 				ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
 			}
 			for ( j4 = sh[4]; j4 > 0; ) {
@@ -252,7 +252,7 @@ function blockedunary7d( fcn, arrays, views, strides, strategy, opts ) { // esli
 					j4 -= bsize;
 				}
 				for ( k = 0; k < N; k++ ) {
-					dv5 = sv[k][5] - ( s4*sv[k][4] );
+					dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 					ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 				}
 				for ( j3 = sh[3]; j3 > 0; ) {
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/7d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/7d_blocked_accessors.js
index 9843dd09e3bc..ee5d1b97b0e6 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/7d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/7d_blocked_accessors.js
@@ -248,7 +248,7 @@ function blockedunary7d( fcn, arrays, views, strides, strategy, opts ) { // esli
 				j5 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv6 = sv[k][6] - ( s5*sv[k][5] );
+				dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
 				ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
 			}
 			for ( j4 = sh[4]; j4 > 0; ) {
@@ -260,7 +260,7 @@ function blockedunary7d( fcn, arrays, views, strides, strategy, opts ) { // esli
 					j4 -= bsize;
 				}
 				for ( k = 0; k < N; k++ ) {
-					dv5 = sv[k][5] - ( s4*sv[k][4] );
+					dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 					ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 				}
 				for ( j3 = sh[3]; j3 > 0; ) {
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/8d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/8d_blocked.js
index f764ff1d4c2a..01cc7a20afe4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/8d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/8d_blocked.js
@@ -247,7 +247,7 @@ function blockedunary8d( fcn, arrays, views, strides, strategy, opts ) { // esli
 				j6 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv7 = sv[k][7] - ( s6*sv[k][6] );
+				dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
 				ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
 			}
 			for ( j5 = sh[5]; j5 > 0; ) {
@@ -259,7 +259,7 @@ function blockedunary8d( fcn, arrays, views, strides, strategy, opts ) { // esli
 					j5 -= bsize;
 				}
 				for ( k = 0; k < N; k++ ) {
-					dv6 = sv[k][6] - ( s5*sv[k][5] );
+					dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
 					ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
 				}
 				for ( j4 = sh[4]; j4 > 0; ) {
@@ -271,7 +271,7 @@ function blockedunary8d( fcn, arrays, views, strides, strategy, opts ) { // esli
 						j4 -= bsize;
 					}
 					for ( k = 0; k < N; k++ ) {
-						dv5 = sv[k][5] - ( s4*sv[k][4] );
+						dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 						ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 					}
 					for ( j3 = sh[3]; j3 > 0; ) {
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/8d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/8d_blocked_accessors.js
index f8a87594c6fa..b04dc8cb0221 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/8d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/8d_blocked_accessors.js
@@ -255,7 +255,7 @@ function blockedunary8d( fcn, arrays, views, strides, strategy, opts ) { // esli
 				j6 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv7 = sv[k][7] - ( s6*sv[k][6] );
+				dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
 				ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
 			}
 			for ( j5 = sh[5]; j5 > 0; ) {
@@ -267,7 +267,7 @@ function blockedunary8d( fcn, arrays, views, strides, strategy, opts ) { // esli
 					j5 -= bsize;
 				}
 				for ( k = 0; k < N; k++ ) {
-					dv6 = sv[k][6] - ( s5*sv[k][5] );
+					dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
 					ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
 				}
 				for ( j4 = sh[4]; j4 > 0; ) {
@@ -279,7 +279,7 @@ function blockedunary8d( fcn, arrays, views, strides, strategy, opts ) { // esli
 						j4 -= bsize;
 					}
 					for ( k = 0; k < N; k++ ) {
-						dv5 = sv[k][5] - ( s4*sv[k][4] );
+						dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 						ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 					}
 					for ( j3 = sh[3]; j3 > 0; ) {
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/9d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/9d_blocked.js
index ba0ad843d471..55815b2cb0ec 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/9d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/9d_blocked.js
@@ -254,7 +254,7 @@ function blockedunary9d( fcn, arrays, views, strides, strategy, opts ) { // esli
 				j7 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv8 = sv[k][8] - ( s7*sv[k][7] );
+				dv8[ k ] = sv[k][8] - ( s7*sv[k][7] );
 				ov7[ k ] = ov8[k] + ( j7*sv[k][7] );
 			}
 			for ( j6 = sh[6]; j6 > 0; ) {
@@ -266,7 +266,7 @@ function blockedunary9d( fcn, arrays, views, strides, strategy, opts ) { // esli
 					j6 -= bsize;
 				}
 				for ( k = 0; k < N; k++ ) {
-					dv7 = sv[k][7] - ( s6*sv[k][6] );
+					dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
 					ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
 				}
 				for ( j5 = sh[5]; j5 > 0; ) {
@@ -278,7 +278,7 @@ function blockedunary9d( fcn, arrays, views, strides, strategy, opts ) { // esli
 						j5 -= bsize;
 					}
 					for ( k = 0; k < N; k++ ) {
-						dv6 = sv[k][6] - ( s5*sv[k][5] );
+						dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
 						ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
 					}
 					for ( j4 = sh[4]; j4 > 0; ) {
@@ -290,7 +290,7 @@ function blockedunary9d( fcn, arrays, views, strides, strategy, opts ) { // esli
 							j4 -= bsize;
 						}
 						for ( k = 0; k < N; k++ ) {
-							dv5 = sv[k][5] - ( s4*sv[k][4] );
+							dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 							ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 						}
 						for ( j3 = sh[3]; j3 > 0; ) {
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/9d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/9d_blocked_accessors.js
index 12206ad84668..cab8330905c5 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/9d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d/lib/9d_blocked_accessors.js
@@ -262,7 +262,7 @@ function blockedunary9d( fcn, arrays, views, strides, strategy, opts ) { // esli
 				j7 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv8 = sv[k][8] - ( s7*sv[k][7] );
+				dv8[ k ] = sv[k][8] - ( s7*sv[k][7] );
 				ov7[ k ] = ov8[k] + ( j7*sv[k][7] );
 			}
 			for ( j6 = sh[6]; j6 > 0; ) {
@@ -274,7 +274,7 @@ function blockedunary9d( fcn, arrays, views, strides, strategy, opts ) { // esli
 					j6 -= bsize;
 				}
 				for ( k = 0; k < N; k++ ) {
-					dv7 = sv[k][7] - ( s6*sv[k][6] );
+					dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
 					ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
 				}
 				for ( j5 = sh[5]; j5 > 0; ) {
@@ -286,7 +286,7 @@ function blockedunary9d( fcn, arrays, views, strides, strategy, opts ) { // esli
 						j5 -= bsize;
 					}
 					for ( k = 0; k < N; k++ ) {
-						dv6 = sv[k][6] - ( s5*sv[k][5] );
+						dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
 						ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
 					}
 					for ( j4 = sh[4]; j4 > 0; ) {
@@ -298,7 +298,7 @@ function blockedunary9d( fcn, arrays, views, strides, strategy, opts ) { // esli
 							j4 -= bsize;
 						}
 						for ( k = 0; k < N; k++ ) {
-							dv5 = sv[k][5] - ( s4*sv[k][4] );
+							dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 							ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 						}
 						for ( j3 = sh[3]; j3 > 0; ) {

From cae1bebbed3f299a18e786a150625582b54763a2 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Fri, 15 Aug 2025 05:50:37 -0700
Subject: [PATCH 31/32] fix: address assignment bug

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../lib/10d_blocked.js                                 | 10 +++++-----
 .../lib/6d_blocked.js                                  |  2 +-
 .../lib/7d_blocked.js                                  |  4 ++--
 .../lib/8d_blocked.js                                  |  6 +++---
 .../lib/9d_blocked.js                                  |  8 ++++----
 5 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/10d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/10d_blocked.js
index a784a6cb3fbf..6b495bed3b7d 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/10d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/10d_blocked.js
@@ -326,7 +326,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 				j8 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv9 = sv[k][9] - ( s8*sv[k][8] );
+				dv9[ k ] = sv[k][9] - ( s8*sv[k][8] );
 				ov8[ k ] = ov9[k] + ( j8*sv[k][8] );
 			}
 			for ( j7 = sh[7]; j7 > 0; ) {
@@ -338,7 +338,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 					j7 -= bsize;
 				}
 				for ( k = 0; k < N; k++ ) {
-					dv8 = sv[k][8] - ( s7*sv[k][7] );
+					dv8[ k ] = sv[k][8] - ( s7*sv[k][7] );
 					ov7[ k ] = ov8[k] + ( j7*sv[k][7] );
 				}
 				for ( j6 = sh[6]; j6 > 0; ) {
@@ -350,7 +350,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 						j6 -= bsize;
 					}
 					for ( k = 0; k < N; k++ ) {
-						dv7 = sv[k][7] - ( s6*sv[k][6] );
+						dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
 						ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
 					}
 					for ( j5 = sh[5]; j5 > 0; ) {
@@ -362,7 +362,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 							j5 -= bsize;
 						}
 						for ( k = 0; k < N; k++ ) {
-							dv6 = sv[k][6] - ( s5*sv[k][5] );
+							dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
 							ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
 						}
 						for ( j4 = sh[4]; j4 > 0; ) {
@@ -374,7 +374,7 @@ function blockedunary10d( fcn, arrays, views, strides, strategy, opts ) { // esl
 								j4 -= bsize;
 							}
 							for ( k = 0; k < N; k++ ) {
-								dv5 = sv[k][5] - ( s4*sv[k][4] );
+								dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 								ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 							}
 							for ( j3 = sh[3]; j3 > 0; ) {
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/6d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/6d_blocked.js
index 516284cc7b85..5e073bde0e43 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/6d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/6d_blocked.js
@@ -298,7 +298,7 @@ function blockedunary6d( fcn, arrays, views, strides, strategy, opts ) { // esli
 				j4 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv5 = sv[k][5] - ( s4*sv[k][4] );
+				dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 				ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 			}
 			for ( j3 = sh[3]; j3 > 0; ) {
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/7d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/7d_blocked.js
index 785e31b02526..b255963ca945 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/7d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/7d_blocked.js
@@ -305,7 +305,7 @@ function blockedunary7d( fcn, arrays, views, strides, strategy, opts ) { // esli
 				j5 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv6 = sv[k][6] - ( s5*sv[k][5] );
+				dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
 				ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
 			}
 			for ( j4 = sh[4]; j4 > 0; ) {
@@ -317,7 +317,7 @@ function blockedunary7d( fcn, arrays, views, strides, strategy, opts ) { // esli
 					j4 -= bsize;
 				}
 				for ( k = 0; k < N; k++ ) {
-					dv5 = sv[k][5] - ( s4*sv[k][4] );
+					dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 					ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 				}
 				for ( j3 = sh[3]; j3 > 0; ) {
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/8d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/8d_blocked.js
index d35258aba739..630dd2181d8f 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/8d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/8d_blocked.js
@@ -312,7 +312,7 @@ function blockedunary8d( fcn, arrays, views, strides, strategy, opts ) { // esli
 				j6 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv7 = sv[k][7] - ( s6*sv[k][6] );
+				dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
 				ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
 			}
 			for ( j5 = sh[5]; j5 > 0; ) {
@@ -324,7 +324,7 @@ function blockedunary8d( fcn, arrays, views, strides, strategy, opts ) { // esli
 					j5 -= bsize;
 				}
 				for ( k = 0; k < N; k++ ) {
-					dv6 = sv[k][6] - ( s5*sv[k][5] );
+					dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
 					ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
 				}
 				for ( j4 = sh[4]; j4 > 0; ) {
@@ -336,7 +336,7 @@ function blockedunary8d( fcn, arrays, views, strides, strategy, opts ) { // esli
 						j4 -= bsize;
 					}
 					for ( k = 0; k < N; k++ ) {
-						dv5 = sv[k][5] - ( s4*sv[k][4] );
+						dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 						ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 					}
 					for ( j3 = sh[3]; j3 > 0; ) {
diff --git a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/9d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/9d_blocked.js
index 70311cc08157..70df41a782b4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/9d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/unary-reduce-strided1d-assign-struct/lib/9d_blocked.js
@@ -319,7 +319,7 @@ function blockedunary9d( fcn, arrays, views, strides, strategy, opts ) { // esli
 				j7 -= bsize;
 			}
 			for ( k = 0; k < N; k++ ) {
-				dv8 = sv[k][8] - ( s7*sv[k][7] );
+				dv8[ k ] = sv[k][8] - ( s7*sv[k][7] );
 				ov7[ k ] = ov8[k] + ( j7*sv[k][7] );
 			}
 			for ( j6 = sh[6]; j6 > 0; ) {
@@ -331,7 +331,7 @@ function blockedunary9d( fcn, arrays, views, strides, strategy, opts ) { // esli
 					j6 -= bsize;
 				}
 				for ( k = 0; k < N; k++ ) {
-					dv7 = sv[k][7] - ( s6*sv[k][6] );
+					dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
 					ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
 				}
 				for ( j5 = sh[5]; j5 > 0; ) {
@@ -343,7 +343,7 @@ function blockedunary9d( fcn, arrays, views, strides, strategy, opts ) { // esli
 						j5 -= bsize;
 					}
 					for ( k = 0; k < N; k++ ) {
-						dv6 = sv[k][6] - ( s5*sv[k][5] );
+						dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
 						ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
 					}
 					for ( j4 = sh[4]; j4 > 0; ) {
@@ -355,7 +355,7 @@ function blockedunary9d( fcn, arrays, views, strides, strategy, opts ) { // esli
 							j4 -= bsize;
 						}
 						for ( k = 0; k < N; k++ ) {
-							dv5 = sv[k][5] - ( s4*sv[k][4] );
+							dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
 							ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
 						}
 						for ( j3 = sh[3]; j3 > 0; ) {

From c42febe4bb7062771a68d869eff02b40e3644f6d Mon Sep 17 00:00:00 2001
From: Gururaj Gurram <143020143+gururaj1512@users.noreply.github.com>
Date: Fri, 15 Aug 2025 18:21:24 +0530
Subject: [PATCH 32/32] feat: add `ndarray/base/binary-reduce-strided1d`

PR-URL: https://github.com/stdlib-js/stdlib/pull/7813
Co-authored-by: Athan Reines <kgryte@gmail.com>
Reviewed-by: Athan Reines <kgryte@gmail.com>
---
 .../base/binary-reduce-strided1d/README.md    | 216 +++++++
 .../binary-reduce-strided1d/docs/repl.txt     |  98 +++
 .../binary-reduce-strided1d/examples/index.js |  61 ++
 .../base/binary-reduce-strided1d/lib/0d.js    | 118 ++++
 .../lib/0d_accessors.js                       | 124 ++++
 .../base/binary-reduce-strided1d/lib/10d.js   | 365 +++++++++++
 .../lib/10d_accessors.js                      | 374 ++++++++++++
 .../lib/10d_blocked.js                        | 429 +++++++++++++
 .../lib/10d_blocked_accessors.js              | 438 +++++++++++++
 .../base/binary-reduce-strided1d/lib/1d.js    | 186 ++++++
 .../lib/1d_accessors.js                       | 195 ++++++
 .../base/binary-reduce-strided1d/lib/2d.js    | 221 +++++++
 .../lib/2d_accessors.js                       | 230 +++++++
 .../binary-reduce-strided1d/lib/2d_blocked.js | 245 ++++++++
 .../lib/2d_blocked_accessors.js               | 254 ++++++++
 .../base/binary-reduce-strided1d/lib/3d.js    | 239 ++++++++
 .../lib/3d_accessors.js                       | 248 ++++++++
 .../binary-reduce-strided1d/lib/3d_blocked.js | 268 ++++++++
 .../lib/3d_blocked_accessors.js               | 277 +++++++++
 .../base/binary-reduce-strided1d/lib/4d.js    | 257 ++++++++
 .../lib/4d_accessors.js                       | 266 ++++++++
 .../binary-reduce-strided1d/lib/4d_blocked.js | 291 +++++++++
 .../lib/4d_blocked_accessors.js               | 300 +++++++++
 .../base/binary-reduce-strided1d/lib/5d.js    | 275 +++++++++
 .../lib/5d_accessors.js                       | 284 +++++++++
 .../binary-reduce-strided1d/lib/5d_blocked.js | 314 ++++++++++
 .../lib/5d_blocked_accessors.js               | 323 ++++++++++
 .../base/binary-reduce-strided1d/lib/6d.js    | 293 +++++++++
 .../lib/6d_accessors.js                       | 302 +++++++++
 .../binary-reduce-strided1d/lib/6d_blocked.js | 337 ++++++++++
 .../lib/6d_blocked_accessors.js               | 346 +++++++++++
 .../base/binary-reduce-strided1d/lib/7d.js    | 311 ++++++++++
 .../lib/7d_accessors.js                       | 320 ++++++++++
 .../binary-reduce-strided1d/lib/7d_blocked.js | 360 +++++++++++
 .../lib/7d_blocked_accessors.js               | 369 +++++++++++
 .../base/binary-reduce-strided1d/lib/8d.js    | 329 ++++++++++
 .../lib/8d_accessors.js                       | 338 +++++++++++
 .../binary-reduce-strided1d/lib/8d_blocked.js | 383 ++++++++++++
 .../lib/8d_blocked_accessors.js               | 392 ++++++++++++
 .../base/binary-reduce-strided1d/lib/9d.js    | 347 +++++++++++
 .../lib/9d_accessors.js                       | 356 +++++++++++
 .../binary-reduce-strided1d/lib/9d_blocked.js | 406 +++++++++++++
 .../lib/9d_blocked_accessors.js               | 415 +++++++++++++
 .../binary-reduce-strided1d/lib/factory.js    | 133 ++++
 .../lib/increment_offsets.js                  |  46 ++
 .../base/binary-reduce-strided1d/lib/index.js | 175 ++++++
 .../lib/initialize_array_views.js             |  57 ++
 .../base/binary-reduce-strided1d/lib/main.js  | 573 ++++++++++++++++++
 .../base/binary-reduce-strided1d/lib/nd.js    | 189 ++++++
 .../lib/nd_accessors.js                       | 198 ++++++
 .../binary-reduce-strided1d/lib/offsets.js    |  42 ++
 .../lib/reshape_strategy.js                   | 260 ++++++++
 .../lib/set_view_offsets.js                   |  52 ++
 .../base/binary-reduce-strided1d/package.json |  64 ++
 .../base/binary-reduce-strided1d/test/test.js |  35 ++
 55 files changed, 14324 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/README.md
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/0d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/0d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/1d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/1d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/factory.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/increment_offsets.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/initialize_array_views.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/nd.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/nd_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/offsets.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/reshape_strategy.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/set_view_offsets.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/package.json
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/test/test.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/README.md b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/README.md
new file mode 100644
index 000000000000..2b8eaeee1d97
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/README.md
@@ -0,0 +1,216 @@
+<!--
+
+@license Apache-2.0
+
+Copyright (c) 2025 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.
+
+-->
+
+# binaryReduceStrided1d
+
+> Perform a reduction over a list of specified dimensions in two input ndarrays via a one-dimensional strided array binary reduction function and assign results to a provided output ndarray.
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var binaryReduceStrided1d = require( '@stdlib/ndarray/base/binary-reduce-strided1d' );
+```
+
+#### binaryReduceStrided1d( fcn, arrays, dims\[, options] )
+
+Performs a reduction over a list of specified dimensions in two input ndarrays via a one-dimensional strided array binary reduction function and assigns results to a provided output ndarray.
+
+<!-- eslint-disable max-len -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+
+// Define the array shapes:
+var xsh = [ 1, 3, 2, 2 ];
+var ysh = [ 1, 3, 2, 2 ];
+var zsh = [ 1, 3 ];
+
+// Define the array strides:
+var sx = [ 12, 4, 2, 1 ];
+var sy = [ 12, 4, 2, 1 ];
+var sz = [ 3, 1 ];
+
+// Define the index offsets:
+var ox = 0;
+var oy = 0;
+var oz = 0;
+
+// Create input ndarray-like objects:
+var x = {
+    'dtype': 'float64',
+    'data': xbuf,
+    'shape': xsh,
+    'strides': sx,
+    'offset': ox,
+    'order': 'row-major'
+};
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': ysh,
+    'strides': sy,
+    'offset': oy,
+    'order': 'row-major'
+};
+
+// Create an output ndarray-like object:
+var z = {
+    'dtype': 'float64',
+    'data': zbuf,
+    'shape': zsh,
+    'strides': sz,
+    'offset': oz,
+    'order': 'row-major'
+};
+
+// Perform a reduction:
+binaryReduceStrided1d( gdot, [ x, y, z ], [ 2, 3 ] );
+
+var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+// returns [ [ 30.0, 174.0, 446.0 ] ]
+```
+
+The function accepts the following arguments:
+
+-   **fcn**: function which will be applied to two one-dimensional subarrays and should reduce them to a single scalar value.
+-   **arrays**: array-like object containing two input ndarrays and one output ndarray, followed by any additional ndarray arguments.
+-   **dims**: list of dimensions over which to perform a reduction.
+-   **options**: function options which are passed through to `fcn` (_optional_).
+
+Each provided ndarray should be an object with the following properties:
+
+-   **dtype**: data type.
+-   **data**: data buffer.
+-   **shape**: dimensions.
+-   **strides**: stride lengths.
+-   **offset**: index offset.
+-   **order**: specifies whether an ndarray is row-major (C-style) or column major (Fortran-style).
+
+#### TODO: document factory method
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   The output ndarray and any additional ndarray arguments are expected to have the same dimensions as the non-reduced dimensions of the input ndarrays. When calling the reduction function, any additional ndarray arguments are provided as zero-dimensional ndarray-like objects.
+
+-   The reduction function is expected to have the following signature:
+
+    ```text
+    fcn( arrays[, options] )
+    ```
+
+    where
+
+    -   **arrays**: array containing a one-dimensional subarray for each input ndarray and any additional ndarray arguments as zero-dimensional ndarrays.
+    -   **options**: function options (_optional_).
+
+-   For very high-dimensional ndarrays which are non-contiguous, one should consider copying the underlying data to contiguous memory before performing a reduction in order to achieve better performance.
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+var binaryReduceStrided1d = require( '@stdlib/ndarray/base/binary-reduce-strided1d' );
+
+var N = 10;
+var x = {
+    'dtype': 'generic',
+    'data': discreteUniform( N, -5, 5, {
+        'dtype': 'generic'
+    }),
+    'shape': [ 1, 5, 2 ],
+    'strides': [ 10, 2, 1 ],
+    'offset': 0,
+    'order': 'row-major'
+};
+var y = {
+    'dtype': 'generic',
+    'data': discreteUniform( N, -5, 5, {
+        'dtype': 'generic'
+    }),
+    'shape': [ 1, 5, 2 ],
+    'strides': [ 10, 2, 1 ],
+    'offset': 0,
+    'order': 'row-major'
+};
+var z = {
+    'dtype': 'generic',
+    'data': zeros( 2 ),
+    'shape': [ 1, 2 ],
+    'strides': [ 2, 1 ],
+    'offset': 0,
+    'order': 'row-major'
+};
+
+binaryReduceStrided1d( gdot, [ x, y, z ], [ 1 ] );
+
+console.log( ndarray2array( x.data, x.shape, x.strides, x.offset, x.order ) );
+console.log( ndarray2array( y.data, y.shape, y.strides, y.offset, y.order ) );
+console.log( ndarray2array( z.data, z.shape, z.strides, z.offset, z.order ) );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<section class="links">
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/docs/repl.txt
new file mode 100644
index 000000000000..f8f17d6c3d21
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/docs/repl.txt
@@ -0,0 +1,98 @@
+
+{{alias}}( fcn, arrays, dims[, options] )
+    Performs a reduction over a list of specified dimensions in two input
+    ndarrays via a one-dimensional strided array binary reduction function
+    and assigns results to a provided output ndarray.
+
+    Each provided "ndarray" should be an object with the following properties:
+
+    - dtype: data type.
+    - data: data buffer.
+    - shape: dimensions.
+    - strides: stride lengths.
+    - offset: index offset.
+    - order: specifies whether an ndarray is row-major (C-style) or column-major
+    (Fortran-style).
+
+    The output ndarray and any additional ndarray arguments are expected to have
+    the same dimensions as the non-reduced dimensions of the input ndarray. When
+    calling the reduction function, any additional ndarray arguments are
+    provided as zero-dimensional ndarray-like objects.
+
+    Parameters
+    ----------
+    fcn: Function
+        Binary reduction function which will be applied to two one-dimensional
+        subarrays and should reduce them to a single scalar value. The function
+        should have the following signature:
+
+            fcn( arrays[, options] )
+
+        where
+
+        - arrays: array containing a one-dimensional subarrays for each input
+        ndarray and any additional ndarray arguments as zero-dimensional
+        ndarrays.
+        - options: function options.
+
+    arrays: ArrayLikeObject<ndarray>
+        Array-like object containing two input ndarrays and one output ndarray,
+        followed by any additional ndarray arguments.
+
+    dims: Array<integer>
+        List of dimensions over which to perform a reduction.
+
+    options: Object (optional)
+        Function options.
+
+    Examples
+    --------
+    // Define ndarray data and meta data...
+    > var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+    > var xbuf = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 3.0, 4.0 ] );
+    > var ybuf = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 3.0, 4.0 ] );
+    > var zbuf = new {{alias:@stdlib/array/float64}}( [ 0.0 ] );
+    > var dtype = 'float64';
+    > var shx = [ 2, 2 ];
+    > var shy = [ 2, 2 ];
+    > var shz = [];
+    > var sx = [ 2, 1 ];
+    > var sy = [ 2, 1 ];
+    > var sz = [ 0 ];
+    > var ox = 0;
+    > var oy = 0;
+    > var oz = 0;
+    > var order = 'row-major';
+
+    // Create ndarray objects...
+    > var x = {
+    ...     'dtype': dtype,
+    ...     'data': xbuf,
+    ...     'shape': shx,
+    ...     'strides': sx,
+    ...     'offset': ox,
+    ...     'order': order
+    ... };
+    > var y = {
+    ...     'dtype': dtype,
+    ...     'data': ybuf,
+    ...     'shape': shy,
+    ...     'strides': sy,
+    ...     'offset': oy,
+    ...     'order': order
+    ... };
+    > var z = {
+    ...     'dtype': dtype,
+    ...     'data': zbuf,
+    ...     'shape': shz,
+    ...     'strides': sz,
+    ...     'offset': oz,
+    ...     'order': order
+    ... };
+    > {{alias}}( gdot, [ x, y, z ], [ 0, 1 ] );
+    > z.data
+    <Float64Array>[ 30.0 ]
+
+    See Also
+    --------
+
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/examples/index.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/examples/index.js
new file mode 100644
index 000000000000..59880b6621d4
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/examples/index.js
@@ -0,0 +1,61 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+var binaryReduceStrided1d = require( './../lib' );
+
+var N = 10;
+var x = {
+	'dtype': 'generic',
+	'data': discreteUniform( N, -5, 5, {
+		'dtype': 'generic'
+	}),
+	'shape': [ 1, 5, 2 ],
+	'strides': [ 10, 2, 1 ],
+	'offset': 0,
+	'order': 'row-major'
+};
+var y = {
+	'dtype': 'generic',
+	'data': discreteUniform( N, -5, 5, {
+		'dtype': 'generic'
+	}),
+	'shape': [ 1, 5, 2 ],
+	'strides': [ 10, 2, 1 ],
+	'offset': 0,
+	'order': 'row-major'
+};
+var z = {
+	'dtype': 'generic',
+	'data': zeros( 2 ),
+	'shape': [ 1, 2 ],
+	'strides': [ 2, 1 ],
+	'offset': 0,
+	'order': 'row-major'
+};
+
+binaryReduceStrided1d( gdot, [ x, y, z ], [ 1 ] );
+
+console.log( ndarray2array( x.data, x.shape, x.strides, x.offset, x.order ) );
+console.log( ndarray2array( y.data, y.shape, y.strides, y.offset, y.order ) );
+console.log( ndarray2array( z.data, z.shape, z.strides, z.offset, z.order ) );
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/0d.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/0d.js
new file mode 100644
index 000000000000..3a898565e629
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/0d.js
@@ -0,0 +1,118 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var without = require( '@stdlib/array/base/without' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+* var zbuf = new Float64Array( [ 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 2, 2 ];
+* var ysh = [ 2, 2 ];
+* var zsh = [];
+*
+* // Define the array strides:
+* var sx = [ 2, 1 ];
+* var sy = [ 2, 1 ];
+* var sz = [ 0 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary0d( gdot, [ x, y, z ], strategy, strategy, {} );
+*
+* var v = z.data;
+* // returns <Float64Array>[ 30.0 ]
+*/
+function binary0d( fcn, arrays, strategyX, strategyY, opts ) {
+	arrays[ 0 ] = strategyX( arrays[ 0 ] );
+	arrays[ 1 ] = strategyY( arrays[ 1 ] );
+	arrays[ 2 ].data[ arrays[ 2 ].offset ] = fcn( without( arrays, 2 ), opts );
+}
+
+
+// EXPORTS //
+
+module.exports = binary0d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/0d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/0d_accessors.js
new file mode 100644
index 000000000000..494a41d87170
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/0d_accessors.js
@@ -0,0 +1,124 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var without = require( '@stdlib/array/base/without' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 2, 2 ];
+* var ysh = [ 2, 2 ];
+* var zsh = [];
+*
+* // Define the array strides:
+* var sx = [ 2, 1 ];
+* var sy = [ 2, 1 ];
+* var sz = [ 0 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary0d( gdot, [ x, y, z ], strategy, strategy, {} );
+*
+* var v = z.data.get( 0 );
+* // returns 30.0
+*/
+function binary0d( fcn, arrays, strategyX, strategyY, opts ) {
+	var z = arrays[ 2 ];
+	arrays[ 0 ] = strategyX( arrays[ 0 ] );
+	arrays[ 1 ] = strategyY( arrays[ 1 ] );
+	z.accessors[ 1 ]( z.data, z.offset, fcn( without( arrays, 2 ), opts ) );
+}
+
+
+// EXPORTS //
+
+module.exports = binary0d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d.js
new file mode 100644
index 000000000000..0b5b0e52cc00
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d.js
@@ -0,0 +1,365 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements, max-lines-per-function */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary10d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ] ] ] ]
+*/
+function binary10d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var dv7;
+	var dv8;
+	var dv9;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var S8;
+	var S9;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var i9;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 9 ];
+		S1 = sh[ 8 ];
+		S2 = sh[ 7 ];
+		S3 = sh[ 6 ];
+		S4 = sh[ 5 ];
+		S5 = sh[ 4 ];
+		S6 = sh[ 3 ];
+		S7 = sh[ 2 ];
+		S8 = sh[ 1 ];
+		S9 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[9],
+			stridesY[9]
+		];
+		dv1 = [
+			stridesX[8] - ( S0*stridesX[9] ),
+			stridesY[8] - ( S0*stridesY[9] )
+		];
+		dv2 = [
+			stridesX[7] - ( S1*stridesX[8] ),
+			stridesY[7] - ( S1*stridesY[8] )
+		];
+		dv3 = [
+			stridesX[6] - ( S2*stridesX[7] ),
+			stridesY[6] - ( S2*stridesY[7] )
+		];
+		dv4 = [
+			stridesX[5] - ( S3*stridesX[6] ),
+			stridesY[5] - ( S3*stridesY[6] )
+		];
+		dv5 = [
+			stridesX[4] - ( S4*stridesX[5] ),
+			stridesY[4] - ( S4*stridesY[5] )
+		];
+		dv6 = [
+			stridesX[3] - ( S5*stridesX[4] ),
+			stridesY[3] - ( S5*stridesY[4] )
+		];
+		dv7 = [
+			stridesX[2] - ( S6*stridesX[3] ),
+			stridesY[2] - ( S6*stridesY[3] )
+		];
+		dv8 = [
+			stridesX[1] - ( S7*stridesX[2] ),
+			stridesY[1] - ( S7*stridesY[2] )
+		];
+		dv9 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S8*stridesX[1] ),
+			stridesY[0] - ( S8*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[9] );
+			dv1.push( sv[8] - ( S0*sv[9] ) );
+			dv2.push( sv[7] - ( S1*sv[8] ) );
+			dv3.push( sv[6] - ( S2*sv[7] ) );
+			dv4.push( sv[5] - ( S3*sv[6] ) );
+			dv5.push( sv[4] - ( S4*sv[5] ) );
+			dv6.push( sv[3] - ( S5*sv[4] ) );
+			dv7.push( sv[2] - ( S6*sv[3] ) );
+			dv8.push( sv[1] - ( S7*sv[2] ) );
+			dv9.push( sv[0] - ( S8*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		S8 = sh[ 8 ];
+		S9 = sh[ 9 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		dv4 = [
+			stridesX[4] - ( S3*stridesX[3] ),
+			stridesY[4] - ( S3*stridesY[3] )
+		];
+		dv5 = [
+			stridesX[5] - ( S4*stridesX[4] ),
+			stridesY[5] - ( S4*stridesY[4] )
+		];
+		dv6 = [
+			stridesX[6] - ( S5*stridesX[5] ),
+			stridesY[6] - ( S5*stridesY[5] )
+		];
+		dv7 = [
+			stridesX[7] - ( S6*stridesX[6] ),
+			stridesY[7] - ( S6*stridesY[6] )
+		];
+		dv8 = [
+			stridesX[8] - ( S7*stridesX[7] ),
+			stridesY[8] - ( S7*stridesY[7] )
+		];
+		dv9 = [                                   // offset increment for outermost loop
+			stridesX[9] - ( S8*stridesX[8] ),
+			stridesY[9] - ( S8*stridesY[8] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+			dv4.push( sv[4] - ( S3*sv[3] ) );
+			dv5.push( sv[5] - ( S4*sv[4] ) );
+			dv6.push( sv[6] - ( S5*sv[5] ) );
+			dv7.push( sv[7] - ( S6*sv[6] ) );
+			dv8.push( sv[8] - ( S7*sv[7] ) );
+			dv9.push( sv[9] - ( S8*sv[8] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i9 = 0; i9 < S9; i9++ ) {
+		for ( i8 = 0; i8 < S8; i8++ ) {
+			for ( i7 = 0; i7 < S7; i7++ ) {
+				for ( i6 = 0; i6 < S6; i6++ ) {
+					for ( i5 = 0; i5 < S5; i5++ ) {
+						for ( i4 = 0; i4 < S4; i4++ ) {
+							for ( i3 = 0; i3 < S3; i3++ ) {
+								for ( i2 = 0; i2 < S2; i2++ ) {
+									for ( i1 = 0; i1 < S1; i1++ ) {
+										for ( i0 = 0; i0 < S0; i0++ ) {
+											setViewOffsets( views, iv );
+											v[ 0 ] = strategyX( views[ 0 ] );
+											v[ 1 ] = strategyY( views[ 1 ] );
+											zbuf[ iv[2] ] = fcn( v, opts );
+											incrementOffsets( iv, dv0 );
+										}
+										incrementOffsets( iv, dv1 );
+									}
+									incrementOffsets( iv, dv2 );
+								}
+								incrementOffsets( iv, dv3 );
+							}
+							incrementOffsets( iv, dv4 );
+						}
+						incrementOffsets( iv, dv5 );
+					}
+					incrementOffsets( iv, dv6 );
+				}
+				incrementOffsets( iv, dv7 );
+			}
+			incrementOffsets( iv, dv8 );
+		}
+		incrementOffsets( iv, dv9 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary10d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d_accessors.js
new file mode 100644
index 000000000000..4029346ce88a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d_accessors.js
@@ -0,0 +1,374 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements, max-lines-per-function */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary10d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ] ] ] ]
+*/
+function binary10d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var dv7;
+	var dv8;
+	var dv9;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var S8;
+	var S9;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var i9;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 9 ];
+		S1 = sh[ 8 ];
+		S2 = sh[ 7 ];
+		S3 = sh[ 6 ];
+		S4 = sh[ 5 ];
+		S5 = sh[ 4 ];
+		S6 = sh[ 3 ];
+		S7 = sh[ 2 ];
+		S8 = sh[ 1 ];
+		S9 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[9],
+			stridesY[9]
+		];
+		dv1 = [
+			stridesX[8] - ( S0*stridesX[9] ),
+			stridesY[8] - ( S0*stridesY[9] )
+		];
+		dv2 = [
+			stridesX[7] - ( S1*stridesX[8] ),
+			stridesY[7] - ( S1*stridesY[8] )
+		];
+		dv3 = [
+			stridesX[6] - ( S2*stridesX[7] ),
+			stridesY[6] - ( S2*stridesY[7] )
+		];
+		dv4 = [
+			stridesX[5] - ( S3*stridesX[6] ),
+			stridesY[5] - ( S3*stridesY[6] )
+		];
+		dv5 = [
+			stridesX[4] - ( S4*stridesX[5] ),
+			stridesY[4] - ( S4*stridesY[5] )
+		];
+		dv6 = [
+			stridesX[3] - ( S5*stridesX[4] ),
+			stridesY[3] - ( S5*stridesY[4] )
+		];
+		dv7 = [
+			stridesX[2] - ( S6*stridesX[3] ),
+			stridesY[2] - ( S6*stridesY[3] )
+		];
+		dv8 = [
+			stridesX[1] - ( S7*stridesX[2] ),
+			stridesY[1] - ( S7*stridesY[2] )
+		];
+		dv9 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S8*stridesX[1] ),
+			stridesY[0] - ( S8*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[9] );
+			dv1.push( sv[8] - ( S0*sv[9] ) );
+			dv2.push( sv[7] - ( S1*sv[8] ) );
+			dv3.push( sv[6] - ( S2*sv[7] ) );
+			dv4.push( sv[5] - ( S3*sv[6] ) );
+			dv5.push( sv[4] - ( S4*sv[5] ) );
+			dv6.push( sv[3] - ( S5*sv[4] ) );
+			dv7.push( sv[2] - ( S6*sv[3] ) );
+			dv8.push( sv[1] - ( S7*sv[2] ) );
+			dv9.push( sv[0] - ( S8*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		S8 = sh[ 8 ];
+		S9 = sh[ 9 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		dv4 = [
+			stridesX[4] - ( S3*stridesX[3] ),
+			stridesY[4] - ( S3*stridesY[3] )
+		];
+		dv5 = [
+			stridesX[5] - ( S4*stridesX[4] ),
+			stridesY[5] - ( S4*stridesY[4] )
+		];
+		dv6 = [
+			stridesX[6] - ( S5*stridesX[5] ),
+			stridesY[6] - ( S5*stridesY[5] )
+		];
+		dv7 = [
+			stridesX[7] - ( S6*stridesX[6] ),
+			stridesY[7] - ( S6*stridesY[6] )
+		];
+		dv8 = [
+			stridesX[8] - ( S7*stridesX[7] ),
+			stridesY[8] - ( S7*stridesY[7] )
+		];
+		dv9 = [                                   // offset increment for outermost loop
+			stridesX[9] - ( S8*stridesX[8] ),
+			stridesY[9] - ( S8*stridesY[8] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+			dv4.push( sv[4] - ( S3*sv[3] ) );
+			dv5.push( sv[5] - ( S4*sv[4] ) );
+			dv6.push( sv[6] - ( S5*sv[5] ) );
+			dv7.push( sv[7] - ( S6*sv[6] ) );
+			dv8.push( sv[8] - ( S7*sv[7] ) );
+			dv9.push( sv[9] - ( S8*sv[8] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i9 = 0; i9 < S9; i9++ ) {
+		for ( i8 = 0; i8 < S8; i8++ ) {
+			for ( i7 = 0; i7 < S7; i7++ ) {
+				for ( i6 = 0; i6 < S6; i6++ ) {
+					for ( i5 = 0; i5 < S5; i5++ ) {
+						for ( i4 = 0; i4 < S4; i4++ ) {
+							for ( i3 = 0; i3 < S3; i3++ ) {
+								for ( i2 = 0; i2 < S2; i2++ ) {
+									for ( i1 = 0; i1 < S1; i1++ ) {
+										for ( i0 = 0; i0 < S0; i0++ ) {
+											setViewOffsets( views, iv );
+											v[ 0 ] = strategyX( views[ 0 ] );
+											v[ 1 ] = strategyY( views[ 1 ] );
+											set( zbuf, iv[ 2 ], fcn( v, opts ) );
+											incrementOffsets( iv, dv0 );
+										}
+										incrementOffsets( iv, dv1 );
+									}
+									incrementOffsets( iv, dv2 );
+								}
+								incrementOffsets( iv, dv3 );
+							}
+							incrementOffsets( iv, dv4 );
+						}
+						incrementOffsets( iv, dv5 );
+					}
+					incrementOffsets( iv, dv6 );
+				}
+				incrementOffsets( iv, dv7 );
+			}
+			incrementOffsets( iv, dv8 );
+		}
+		incrementOffsets( iv, dv9 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary10d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d_blocked.js
new file mode 100644
index 000000000000..94c04c0f76d1
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d_blocked.js
@@ -0,0 +1,429 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements, max-lines-per-function */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary10d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ] ] ] ]
+*/
+function blockedbinary10d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var dv7;
+	var dv8;
+	var dv9;
+	var ov1;
+	var ov2;
+	var ov3;
+	var ov4;
+	var ov5;
+	var ov6;
+	var ov7;
+	var ov8;
+	var ov9;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var s8;
+	var s9;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var i9;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var j8;
+	var j9;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	ov4 = zeros( N );
+	ov5 = zeros( N );
+	ov6 = zeros( N );
+	ov7 = zeros( N );
+	ov8 = zeros( N );
+	ov9 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	dv4 = zeros( N );
+	dv5 = zeros( N );
+	dv6 = zeros( N );
+	dv7 = zeros( N );
+	dv8 = zeros( N );
+	dv9 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j9 = sh[9]; j9 > 0; ) {
+		if ( j9 < bsize ) {
+			s9 = j9;
+			j9 = 0;
+		} else {
+			s9 = bsize;
+			j9 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov9[ k ] = ov[k] + ( j9*sv[k][9] );
+		}
+		for ( j8 = sh[8]; j8 > 0; ) {
+			if ( j8 < bsize ) {
+				s8 = j8;
+				j8 = 0;
+			} else {
+				s8 = bsize;
+				j8 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				dv9[ k ] = sv[k][9] - ( s8*sv[k][8] );
+				ov8[ k ] = ov9[k] + ( j8*sv[k][8] );
+			}
+			for ( j7 = sh[7]; j7 > 0; ) {
+				if ( j7 < bsize ) {
+					s7 = j7;
+					j7 = 0;
+				} else {
+					s7 = bsize;
+					j7 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					dv8[ k ] = sv[k][8] - ( s7*sv[k][7] );
+					ov7[ k ] = ov8[k] + ( j7*sv[k][7] );
+				}
+				for ( j6 = sh[6]; j6 > 0; ) {
+					if ( j6 < bsize ) {
+						s6 = j6;
+						j6 = 0;
+					} else {
+						s6 = bsize;
+						j6 -= bsize;
+					}
+					for ( k = 0; k < N; k++ ) {
+						dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
+						ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
+					}
+					for ( j5 = sh[5]; j5 > 0; ) {
+						if ( j5 < bsize ) {
+							s5 = j5;
+							j5 = 0;
+						} else {
+							s5 = bsize;
+							j5 -= bsize;
+						}
+						for ( k = 0; k < N; k++ ) {
+							dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
+							ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
+						}
+						for ( j4 = sh[4]; j4 > 0; ) {
+							if ( j4 < bsize ) {
+								s4 = j4;
+								j4 = 0;
+							} else {
+								s4 = bsize;
+								j4 -= bsize;
+							}
+							for ( k = 0; k < N; k++ ) {
+								dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
+								ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
+							}
+							for ( j3 = sh[3]; j3 > 0; ) {
+								if ( j3 < bsize ) {
+									s3 = j3;
+									j3 = 0;
+								} else {
+									s3 = bsize;
+									j3 -= bsize;
+								}
+								for ( k = 0; k < N; k++ ) {
+									dv4[ k ] = sv[k][4] - ( s3*sv[k][3] );
+									ov3[ k ] = ov4[k] + ( j3*sv[k][3] );
+								}
+								for ( j2 = sh[2]; j2 > 0; ) {
+									if ( j2 < bsize ) {
+										s2 = j2;
+										j2 = 0;
+									} else {
+										s2 = bsize;
+										j2 -= bsize;
+									}
+									for ( k = 0; k < N; k++ ) {
+										dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+										ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+									}
+									for ( j1 = sh[1]; j1 > 0; ) {
+										if ( j1 < bsize ) {
+											s1 = j1;
+											j1 = 0;
+										} else {
+											s1 = bsize;
+											j1 -= bsize;
+										}
+										for ( k = 0; k < N; k++ ) {
+											dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+											ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+										}
+										for ( j0 = sh[0]; j0 > 0; ) {
+											if ( j0 < bsize ) {
+												s0 = j0;
+												j0 = 0;
+											} else {
+												s0 = bsize;
+												j0 -= bsize;
+											}
+											// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+											for ( k = 0; k < N; k++ ) {
+												iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+												dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+											}
+											// Iterate over the non-reduced ndarray dimensions...
+											for ( i9 = 0; i9 < s9; i9++ ) {
+												for ( i8 = 0; i8 < s8; i8++ ) {
+													for ( i7 = 0; i7 < s7; i7++ ) {
+														for ( i6 = 0; i6 < s6; i6++ ) {
+															for ( i5 = 0; i5 < s5; i5++ ) {
+																for ( i4 = 0; i4 < s4; i4++ ) {
+																	for ( i3 = 0; i3 < s3; i3++ ) {
+																		for ( i2 = 0; i2 < s2; i2++ ) {
+																			for ( i1 = 0; i1 < s1; i1++ ) {
+																				for ( i0 = 0; i0 < s0; i0++ ) {
+																					setViewOffsets( views, iv );
+																					v[ 0 ] = strategyX( views[ 0 ] );
+																					v[ 1 ] = strategyY( views[ 1 ] );
+																					zbuf[ iv[2] ] = fcn( v, opts );
+																					incrementOffsets( iv, dv0 );
+																				}
+																				incrementOffsets( iv, dv1 );
+																			}
+																			incrementOffsets( iv, dv2 );
+																		}
+																		incrementOffsets( iv, dv3 );
+																	}
+																	incrementOffsets( iv, dv4 );
+																}
+																incrementOffsets( iv, dv5 );
+															}
+															incrementOffsets( iv, dv6 );
+														}
+														incrementOffsets( iv, dv7 );
+													}
+													incrementOffsets( iv, dv8 );
+												}
+												incrementOffsets( iv, dv9 );
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary10d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d_blocked_accessors.js
new file mode 100644
index 000000000000..8996cf157e09
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/10d_blocked_accessors.js
@@ -0,0 +1,438 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements, max-lines-per-function */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary10d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ] ] ] ]
+*/
+function blockedbinary10d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var dv7;
+	var dv8;
+	var dv9;
+	var ov1;
+	var ov2;
+	var ov3;
+	var ov4;
+	var ov5;
+	var ov6;
+	var ov7;
+	var ov8;
+	var ov9;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var s8;
+	var s9;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var i9;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var j8;
+	var j9;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	ov4 = zeros( N );
+	ov5 = zeros( N );
+	ov6 = zeros( N );
+	ov7 = zeros( N );
+	ov8 = zeros( N );
+	ov9 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	dv4 = zeros( N );
+	dv5 = zeros( N );
+	dv6 = zeros( N );
+	dv7 = zeros( N );
+	dv8 = zeros( N );
+	dv9 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j9 = sh[9]; j9 > 0; ) {
+		if ( j9 < bsize ) {
+			s9 = j9;
+			j9 = 0;
+		} else {
+			s9 = bsize;
+			j9 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov9[ k ] = ov[k] + ( j9*sv[k][9] );
+		}
+		for ( j8 = sh[8]; j8 > 0; ) {
+			if ( j8 < bsize ) {
+				s8 = j8;
+				j8 = 0;
+			} else {
+				s8 = bsize;
+				j8 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				dv9[ k ] = sv[k][9] - ( s8*sv[k][8] );
+				ov8[ k ] = ov9[k] + ( j8*sv[k][8] );
+			}
+			for ( j7 = sh[7]; j7 > 0; ) {
+				if ( j7 < bsize ) {
+					s7 = j7;
+					j7 = 0;
+				} else {
+					s7 = bsize;
+					j7 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					dv8[ k ] = sv[k][8] - ( s7*sv[k][7] );
+					ov7[ k ] = ov8[k] + ( j7*sv[k][7] );
+				}
+				for ( j6 = sh[6]; j6 > 0; ) {
+					if ( j6 < bsize ) {
+						s6 = j6;
+						j6 = 0;
+					} else {
+						s6 = bsize;
+						j6 -= bsize;
+					}
+					for ( k = 0; k < N; k++ ) {
+						dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
+						ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
+					}
+					for ( j5 = sh[5]; j5 > 0; ) {
+						if ( j5 < bsize ) {
+							s5 = j5;
+							j5 = 0;
+						} else {
+							s5 = bsize;
+							j5 -= bsize;
+						}
+						for ( k = 0; k < N; k++ ) {
+							dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
+							ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
+						}
+						for ( j4 = sh[4]; j4 > 0; ) {
+							if ( j4 < bsize ) {
+								s4 = j4;
+								j4 = 0;
+							} else {
+								s4 = bsize;
+								j4 -= bsize;
+							}
+							for ( k = 0; k < N; k++ ) {
+								dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
+								ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
+							}
+							for ( j3 = sh[3]; j3 > 0; ) {
+								if ( j3 < bsize ) {
+									s3 = j3;
+									j3 = 0;
+								} else {
+									s3 = bsize;
+									j3 -= bsize;
+								}
+								for ( k = 0; k < N; k++ ) {
+									dv4[ k ] = sv[k][4] - ( s3*sv[k][3] );
+									ov3[ k ] = ov4[k] + ( j3*sv[k][3] );
+								}
+								for ( j2 = sh[2]; j2 > 0; ) {
+									if ( j2 < bsize ) {
+										s2 = j2;
+										j2 = 0;
+									} else {
+										s2 = bsize;
+										j2 -= bsize;
+									}
+									for ( k = 0; k < N; k++ ) {
+										dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+										ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+									}
+									for ( j1 = sh[1]; j1 > 0; ) {
+										if ( j1 < bsize ) {
+											s1 = j1;
+											j1 = 0;
+										} else {
+											s1 = bsize;
+											j1 -= bsize;
+										}
+										for ( k = 0; k < N; k++ ) {
+											dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+											ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+										}
+										for ( j0 = sh[0]; j0 > 0; ) {
+											if ( j0 < bsize ) {
+												s0 = j0;
+												j0 = 0;
+											} else {
+												s0 = bsize;
+												j0 -= bsize;
+											}
+											// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+											for ( k = 0; k < N; k++ ) {
+												iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+												dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+											}
+											// Iterate over the non-reduced ndarray dimensions...
+											for ( i9 = 0; i9 < s9; i9++ ) {
+												for ( i8 = 0; i8 < s8; i8++ ) {
+													for ( i7 = 0; i7 < s7; i7++ ) {
+														for ( i6 = 0; i6 < s6; i6++ ) {
+															for ( i5 = 0; i5 < s5; i5++ ) {
+																for ( i4 = 0; i4 < s4; i4++ ) {
+																	for ( i3 = 0; i3 < s3; i3++ ) {
+																		for ( i2 = 0; i2 < s2; i2++ ) {
+																			for ( i1 = 0; i1 < s1; i1++ ) {
+																				for ( i0 = 0; i0 < s0; i0++ ) {
+																					setViewOffsets( views, iv );
+																					v[ 0 ] = strategyX( views[ 0 ] );
+																					v[ 1 ] = strategyY( views[ 1 ] );
+																					set( zbuf, iv[ 2 ], fcn( v, opts ) );
+																					incrementOffsets( iv, dv0 );
+																				}
+																				incrementOffsets( iv, dv1 );
+																			}
+																			incrementOffsets( iv, dv2 );
+																		}
+																		incrementOffsets( iv, dv3 );
+																	}
+																	incrementOffsets( iv, dv4 );
+																}
+																incrementOffsets( iv, dv5 );
+															}
+															incrementOffsets( iv, dv6 );
+														}
+														incrementOffsets( iv, dv7 );
+													}
+													incrementOffsets( iv, dv8 );
+												}
+												incrementOffsets( iv, dv9 );
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary10d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/1d.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/1d.js
new file mode 100644
index 000000000000..95a3c027afa9
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/1d.js
@@ -0,0 +1,186 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 3, 2, 2 ];
+* var ysh = [ 3, 2, 2 ];
+* var zsh = [ 3 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 2, 1 ];
+* var sy = [ 4, 2, 1 ];
+* var sz = [ 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary1d( gdot, [ x, y, z ], views, [ 4 ], [ 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ 30.0, 174.0, 446.0 ]
+*/
+function binary1d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var zbuf;
+	var dv0;
+	var sh;
+	var S0;
+	var iv;
+	var i0;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	S0 = sh[ 0 ];
+	dv0 = [
+		stridesX[0],
+		stridesY[0]
+	];
+	for ( i = 2; i < arrays.length; i++ ) {
+		dv0.push( arrays[i].strides[0] );
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i0 = 0; i0 < S0; i0++ ) {
+		setViewOffsets( views, iv );
+		v[ 0 ] = strategyX( views[ 0 ] );
+		v[ 1 ] = strategyY( views[ 1 ] );
+		zbuf[ iv[2] ] = fcn( v, opts );
+		incrementOffsets( iv, dv0 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary1d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/1d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/1d_accessors.js
new file mode 100644
index 000000000000..09eb83b43e78
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/1d_accessors.js
@@ -0,0 +1,195 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 3, 2, 2 ];
+* var ysh = [ 3, 2, 2 ];
+* var zsh = [ 3 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 2, 1 ];
+* var sy = [ 4, 2, 1 ];
+* var sz = [ 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary1d( gdot, [ x, y, z ], views, [ 4 ], [ 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ 30.0, 174.0, 446.0 ]
+*/
+function binary1d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var zbuf;
+	var set;
+	var dv0;
+	var sh;
+	var S0;
+	var iv;
+	var i0;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables: dimensions and loop offset (pointer) increments...
+	S0 = sh[ 0 ];
+	dv0 = [
+		stridesX[0],
+		stridesY[0]
+	];
+	for ( i = 2; i < arrays.length; i++ ) {
+		dv0.push( arrays[i].strides[0] );
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i0 = 0; i0 < S0; i0++ ) {
+		setViewOffsets( views, iv );
+		v[ 0 ] = strategyX( views[ 0 ] );
+		v[ 1 ] = strategyY( views[ 1 ] );
+		set( zbuf, iv[2], fcn( v, opts ) );
+		incrementOffsets( iv, dv0 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary1d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d.js
new file mode 100644
index 000000000000..70fcf146aba8
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d.js
@@ -0,0 +1,221 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 3, 2, 2 ];
+* var ysh = [ 1, 3, 2, 2 ];
+* var zsh = [ 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 4, 2, 1 ];
+* var sy = [ 12, 4, 2, 1 ];
+* var sz = [ 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary2d( gdot, [ x, y, z ], views, [ 12, 4 ], [ 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ 30.0, 174.0, 446.0 ] ]
+*/
+function binary2d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var dv0;
+	var dv1;
+	var sh;
+	var S0;
+	var S1;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 1 ];
+		S1 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[1],
+			stridesY[1]
+		];
+		dv1 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S0*stridesX[1] ),
+			stridesY[0] - ( S0*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[1] );
+			dv1.push( sv[0] - ( S0*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [                                   // offset increment for outermost loop
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i1 = 0; i1 < S1; i1++ ) {
+		for ( i0 = 0; i0 < S0; i0++ ) {
+			setViewOffsets( views, iv );
+			v[ 0 ] = strategyX( views[ 0 ] );
+			v[ 1 ] = strategyY( views[ 1 ] );
+			zbuf[ iv[2] ] = fcn( v, opts );
+			incrementOffsets( iv, dv0 );
+		}
+		incrementOffsets( iv, dv1 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary2d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d_accessors.js
new file mode 100644
index 000000000000..cf89fc810693
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d_accessors.js
@@ -0,0 +1,230 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 3, 2, 2 ];
+* var ysh = [ 1, 3, 2, 2 ];
+* var zsh = [ 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 4, 2, 1 ];
+* var sy = [ 12, 4, 2, 1 ];
+* var sz = [ 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary2d( gdot, [ x, y, z ], views, [ 12, 4 ], [ 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ 30.0, 174.0, 446.0 ] ]
+*/
+function binary2d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var sh;
+	var S0;
+	var S1;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 1 ];
+		S1 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[1],
+			stridesY[1]
+		];
+		dv1 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S0*stridesX[1] ),
+			stridesY[0] - ( S0*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[1] );
+			dv1.push( sv[0] - ( S0*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [                                   // offset increment for outermost loop
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i1 = 0; i1 < S1; i1++ ) {
+		for ( i0 = 0; i0 < S0; i0++ ) {
+			setViewOffsets( views, iv );
+			v[ 0 ] = strategyX( views[ 0 ] );
+			v[ 1 ] = strategyY( views[ 1 ] );
+			set( zbuf, iv[ 2 ], fcn( v, opts ) );
+			incrementOffsets( iv, dv0 );
+		}
+		incrementOffsets( iv, dv1 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary2d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d_blocked.js
new file mode 100644
index 000000000000..9b94f712bb65
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d_blocked.js
@@ -0,0 +1,245 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 3, 2, 2 ];
+* var ysh = [ 1, 3, 2, 2 ];
+* var zsh = [ 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 4, 2, 1 ];
+* var sy = [ 12, 4, 2, 1 ];
+* var sz = [ 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary2d( gdot, [ x, y, z ], views, [ 12, 4 ], [ 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ 30.0, 174.0, 446.0 ] ]
+*/
+function blockedbinary2d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var dv0;
+	var dv1;
+	var ov1;
+	var sh;
+	var s0;
+	var s1;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var j0;
+	var j1;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	dv1 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j1 = sh[1]; j1 > 0; ) {
+		if ( j1 < bsize ) {
+			s1 = j1;
+			j1 = 0;
+		} else {
+			s1 = bsize;
+			j1 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov1[ k ] = ov[k] + ( j1*sv[k][1] );
+		}
+		for ( j0 = sh[0]; j0 > 0; ) {
+			if ( j0 < bsize ) {
+				s0 = j0;
+				j0 = 0;
+			} else {
+				s0 = bsize;
+				j0 -= bsize;
+			}
+			// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+			for ( k = 0; k < N; k++ ) {
+				iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+				dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+			}
+			// Iterate over the non-reduced ndarray dimensions...
+			for ( i1 = 0; i1 < s1; i1++ ) {
+				for ( i0 = 0; i0 < s0; i0++ ) {
+					setViewOffsets( views, iv );
+					v[ 0 ] = strategyX( views[ 0 ] );
+					v[ 1 ] = strategyY( views[ 1 ] );
+					zbuf[ iv[2] ] = fcn( v, opts );
+					incrementOffsets( iv, dv0 );
+				}
+				incrementOffsets( iv, dv1 );
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary2d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d_blocked_accessors.js
new file mode 100644
index 000000000000..3e0c08407648
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/2d_blocked_accessors.js
@@ -0,0 +1,254 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 3, 2, 2 ];
+* var ysh = [ 1, 3, 2, 2 ];
+* var zsh = [ 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 4, 2, 1 ];
+* var sy = [ 12, 4, 2, 1 ];
+* var sz = [ 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary2d( gdot, [ x, y, z ], views, [ 12, 4 ], [ 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ 30.0, 174.0, 446.0 ] ]
+*/
+function blockedbinary2d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var ov1;
+	var sh;
+	var s0;
+	var s1;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var j0;
+	var j1;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[1];
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	dv1 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j1 = sh[1]; j1 > 0; ) {
+		if ( j1 < bsize ) {
+			s1 = j1;
+			j1 = 0;
+		} else {
+			s1 = bsize;
+			j1 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov1[ k ] = ov[k] + ( j1*sv[k][1] );
+		}
+		for ( j0 = sh[0]; j0 > 0; ) {
+			if ( j0 < bsize ) {
+				s0 = j0;
+				j0 = 0;
+			} else {
+				s0 = bsize;
+				j0 -= bsize;
+			}
+			// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+			for ( k = 0; k < N; k++ ) {
+				iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+				dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+			}
+			// Iterate over the non-reduced ndarray dimensions...
+			for ( i1 = 0; i1 < s1; i1++ ) {
+				for ( i0 = 0; i0 < s0; i0++ ) {
+					setViewOffsets( views, iv );
+					v[ 0 ] = strategyX( views[ 0 ] );
+					v[ 1 ] = strategyY( views[ 1 ] );
+					set( zbuf, iv[ 2 ], fcn( v, opts ) );
+					incrementOffsets( iv, dv0 );
+				}
+				incrementOffsets( iv, dv1 );
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary2d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d.js
new file mode 100644
index 000000000000..4f79f14ef687
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d.js
@@ -0,0 +1,239 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary3d( gdot, [ x, y, z ], views, [ 12, 12, 4 ], [ 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ 30.0, 174.0, 446.0 ] ] ]
+*/
+function binary3d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 2 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[2],
+			stridesY[2]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[2] ),
+			stridesY[1] - ( S0*stridesY[2] )
+		];
+		dv2 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S1*stridesX[1] ),
+			stridesY[0] - ( S1*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[2] );
+			dv1.push( sv[1] - ( S0*sv[2] ) );
+			dv2.push( sv[0] - ( S1*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [                                   // offset increment for outermost loop
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i2 = 0; i2 < S2; i2++ ) {
+		for ( i1 = 0; i1 < S1; i1++ ) {
+			for ( i0 = 0; i0 < S0; i0++ ) {
+				setViewOffsets( views, iv );
+				v[ 0 ] = strategyX( views[ 0 ] );
+				v[ 1 ] = strategyY( views[ 1 ] );
+				zbuf[ iv[2] ] = fcn( v, opts );
+				incrementOffsets( iv, dv0 );
+			}
+			incrementOffsets( iv, dv1 );
+		}
+		incrementOffsets( iv, dv2 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary3d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d_accessors.js
new file mode 100644
index 000000000000..cb8c5d2bb4ee
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d_accessors.js
@@ -0,0 +1,248 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary3d( gdot, [ x, y, z ], views, [ 12, 12, 4 ], [ 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ 30.0, 174.0, 446.0 ] ] ]
+*/
+function binary3d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 2 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[2],
+			stridesY[2]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[2] ),
+			stridesY[1] - ( S0*stridesY[2] )
+		];
+		dv2 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S1*stridesX[1] ),
+			stridesY[0] - ( S1*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[2] );
+			dv1.push( sv[1] - ( S0*sv[2] ) );
+			dv2.push( sv[0] - ( S1*sv[1] ) );
+		}
+	} else {
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [                                   // offset increment for outermost loop
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i2 = 0; i2 < S2; i2++ ) {
+		for ( i1 = 0; i1 < S1; i1++ ) {
+			for ( i0 = 0; i0 < S0; i0++ ) {
+				setViewOffsets( views, iv );
+				v[ 0 ] = strategyX( views[ 0 ] );
+				v[ 1 ] = strategyY( views[ 1 ] );
+				set( zbuf, iv[ 2 ], fcn( v, opts ) );
+				incrementOffsets( iv, dv0 );
+			}
+			incrementOffsets( iv, dv1 );
+		}
+		incrementOffsets( iv, dv2 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary3d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d_blocked.js
new file mode 100644
index 000000000000..0619d6931942
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d_blocked.js
@@ -0,0 +1,268 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary3d( gdot, [ x, y, z ], views, [ 12, 12, 4 ], [ 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ 30.0, 174.0, 446.0 ] ] ]
+*/
+function blockedbinary3d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var ov1;
+	var ov2;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var j0;
+	var j1;
+	var j2;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j2 = sh[2]; j2 > 0; ) {
+		if ( j2 < bsize ) {
+			s2 = j2;
+			j2 = 0;
+		} else {
+			s2 = bsize;
+			j2 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov2[ k ] = ov[k] + ( j2*sv[k][2] );
+		}
+		for ( j1 = sh[1]; j1 > 0; ) {
+			if ( j1 < bsize ) {
+				s1 = j1;
+				j1 = 0;
+			} else {
+				s1 = bsize;
+				j1 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+				dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+			}
+			for ( j0 = sh[0]; j0 > 0; ) {
+				if ( j0 < bsize ) {
+					s0 = j0;
+					j0 = 0;
+				} else {
+					s0 = bsize;
+					j0 -= bsize;
+				}
+				// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+				for ( k = 0; k < N; k++ ) {
+					iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+					dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+				}
+				// Iterate over the non-reduced ndarray dimensions...
+				for ( i2 = 0; i2 < s2; i2++ ) {
+					for ( i1 = 0; i1 < s1; i1++ ) {
+						for ( i0 = 0; i0 < s0; i0++ ) {
+							setViewOffsets( views, iv );
+							v[ 0 ] = strategyX( views[ 0 ] );
+							v[ 1 ] = strategyY( views[ 1 ] );
+							zbuf[ iv[2] ] = fcn( v, opts );
+							incrementOffsets( iv, dv0 );
+						}
+						incrementOffsets( iv, dv1 );
+					}
+					incrementOffsets( iv, dv2 );
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary3d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d_blocked_accessors.js
new file mode 100644
index 000000000000..129fc1dcbe0c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/3d_blocked_accessors.js
@@ -0,0 +1,277 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary3d( gdot, [ x, y, z ], views, [ 12, 12, 4 ], [ 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ 30.0, 174.0, 446.0 ] ] ]
+*/
+function blockedbinary3d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var ov1;
+	var ov2;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var j0;
+	var j1;
+	var j2;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[1];
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j2 = sh[2]; j2 > 0; ) {
+		if ( j2 < bsize ) {
+			s2 = j2;
+			j2 = 0;
+		} else {
+			s2 = bsize;
+			j2 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov2[ k ] = ov[k] + ( j2*sv[k][2] );
+		}
+		for ( j1 = sh[1]; j1 > 0; ) {
+			if ( j1 < bsize ) {
+				s1 = j1;
+				j1 = 0;
+			} else {
+				s1 = bsize;
+				j1 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+				dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+			}
+			for ( j0 = sh[0]; j0 > 0; ) {
+				if ( j0 < bsize ) {
+					s0 = j0;
+					j0 = 0;
+				} else {
+					s0 = bsize;
+					j0 -= bsize;
+				}
+				// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+				for ( k = 0; k < N; k++ ) {
+					iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+					dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+				}
+				// Iterate over the non-reduced ndarray dimensions...
+				for ( i2 = 0; i2 < s2; i2++ ) {
+					for ( i1 = 0; i1 < s1; i1++ ) {
+						for ( i0 = 0; i0 < s0; i0++ ) {
+							setViewOffsets( views, iv );
+							v[ 0 ] = strategyX( views[ 0 ] );
+							v[ 1 ] = strategyY( views[ 1 ] );
+							set( zbuf, iv[ 2 ], fcn( v, opts ) );
+							incrementOffsets( iv, dv0 );
+						}
+						incrementOffsets( iv, dv1 );
+					}
+					incrementOffsets( iv, dv2 );
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary3d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d.js
new file mode 100644
index 000000000000..660aff79a877
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d.js
@@ -0,0 +1,257 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary4d( gdot, [ x, y, z ], views, [ 12, 12, 12, 4 ], [ 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ]
+*/
+function binary4d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 3 ];
+		S1 = sh[ 2 ];
+		S2 = sh[ 1 ];
+		S3 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[3],
+			stridesY[3]
+		];
+		dv1 = [
+			stridesX[2] - ( S0*stridesX[3] ),
+			stridesY[2] - ( S0*stridesY[3] )
+		];
+		dv2 = [
+			stridesX[1] - ( S1*stridesX[2] ),
+			stridesY[1] - ( S1*stridesY[2] )
+		];
+		dv3 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S2*stridesX[1] ),
+			stridesY[0] - ( S2*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[3] );
+			dv1.push( sv[2] - ( S0*sv[3] ) );
+			dv2.push( sv[1] - ( S1*sv[2] ) );
+			dv3.push( sv[0] - ( S2*sv[1]) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [                                   // offset increment for outermost loop
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i3 = 0; i3 < S3; i3++ ) {
+		for ( i2 = 0; i2 < S2; i2++ ) {
+			for ( i1 = 0; i1 < S1; i1++ ) {
+				for ( i0 = 0; i0 < S0; i0++ ) {
+					setViewOffsets( views, iv );
+					v[ 0 ] = strategyX( views[ 0 ] );
+					v[ 1 ] = strategyY( views[ 1 ] );
+					zbuf[ iv[2] ] = fcn( v, opts );
+					incrementOffsets( iv, dv0 );
+				}
+				incrementOffsets( iv, dv1 );
+			}
+			incrementOffsets( iv, dv2 );
+		}
+		incrementOffsets( iv, dv3 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary4d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d_accessors.js
new file mode 100644
index 000000000000..73378fca2289
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d_accessors.js
@@ -0,0 +1,266 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary4d( gdot, [ x, y, z ], views, [ 12, 12, 12, 4 ], [ 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ]
+*/
+function binary4d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 3 ];
+		S1 = sh[ 2 ];
+		S2 = sh[ 1 ];
+		S3 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[3],
+			stridesY[3]
+		];
+		dv1 = [
+			stridesX[2] - ( S0*stridesX[3] ),
+			stridesY[2] - ( S0*stridesY[3] )
+		];
+		dv2 = [
+			stridesX[1] - ( S1*stridesX[2] ),
+			stridesY[1] - ( S1*stridesY[2] )
+		];
+		dv3 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S2*stridesX[1] ),
+			stridesY[0] - ( S2*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[3] );
+			dv1.push( sv[2] - ( S0*sv[3] ) );
+			dv2.push( sv[1] - ( S1*sv[2] ) );
+			dv3.push( sv[0] - ( S2*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [                                   // offset increment for outermost loop
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		for ( i = 1; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i3 = 0; i3 < S3; i3++ ) {
+		for ( i2 = 0; i2 < S2; i2++ ) {
+			for ( i1 = 0; i1 < S1; i1++ ) {
+				for ( i0 = 0; i0 < S0; i0++ ) {
+					setViewOffsets( views, iv );
+					v[ 0 ] = strategyX( views[ 0 ] );
+					v[ 1 ] = strategyY( views[ 1 ] );
+					set( zbuf, iv[ 2 ], fcn( v, opts ) );
+					incrementOffsets( iv, dv0 );
+				}
+				incrementOffsets( iv, dv1 );
+			}
+			incrementOffsets( iv, dv2 );
+		}
+		incrementOffsets( iv, dv3 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary4d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d_blocked.js
new file mode 100644
index 000000000000..d9e746cbc97c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d_blocked.js
@@ -0,0 +1,291 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary4d( gdot, [ x, y, z ], views, [ 12, 12, 12, 4 ], [ 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ]
+*/
+function blockedbinary4d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var ov1;
+	var ov2;
+	var ov3;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j3 = sh[3]; j3 > 0; ) {
+		if ( j3 < bsize ) {
+			s3 = j3;
+			j3 = 0;
+		} else {
+			s3 = bsize;
+			j3 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov3[ k ] = ov[k] + ( j3*sv[k][3] );
+		}
+		for ( j2 = sh[2]; j2 > 0; ) {
+			if ( j2 < bsize ) {
+				s2 = j2;
+				j2 = 0;
+			} else {
+				s2 = bsize;
+				j2 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+				dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+			}
+			for ( j1 = sh[1]; j1 > 0; ) {
+				if ( j1 < bsize ) {
+					s1 = j1;
+					j1 = 0;
+				} else {
+					s1 = bsize;
+					j1 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+					dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+				}
+				for ( j0 = sh[0]; j0 > 0; ) {
+					if ( j0 < bsize ) {
+						s0 = j0;
+						j0 = 0;
+					} else {
+						s0 = bsize;
+						j0 -= bsize;
+					}
+					// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+					for ( k = 0; k < N; k++ ) {
+						iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+						dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+					}
+					// Iterate over the non-reduced ndarray dimensions...
+					for ( i3 = 0; i3 < s3; i3++ ) {
+						for ( i2 = 0; i2 < s2; i2++ ) {
+							for ( i1 = 0; i1 < s1; i1++ ) {
+								for ( i0 = 0; i0 < s0; i0++ ) {
+									setViewOffsets( views, iv );
+									v[ 0 ] = strategyX( views[ 0 ] );
+									v[ 1 ] = strategyY( views[ 1 ] );
+									zbuf[ iv[2] ] = fcn( v, opts );
+									incrementOffsets( iv, dv0 );
+								}
+								incrementOffsets( iv, dv1 );
+							}
+							incrementOffsets( iv, dv2 );
+						}
+						incrementOffsets( iv, dv3 );
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary4d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d_blocked_accessors.js
new file mode 100644
index 000000000000..3544e3d3244c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/4d_blocked_accessors.js
@@ -0,0 +1,300 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary4d( gdot, [ x, y, z ], views, [ 12, 12, 12, 4 ], [ 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ]
+*/
+function blockedbinary4d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var ov1;
+	var ov2;
+	var ov3;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[1];
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j3 = sh[3]; j3 > 0; ) {
+		if ( j3 < bsize ) {
+			s3 = j3;
+			j3 = 0;
+		} else {
+			s3 = bsize;
+			j3 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov3[ k ] = ov[k] + ( j3*sv[k][3] );
+		}
+		for ( j2 = sh[2]; j2 > 0; ) {
+			if ( j2 < bsize ) {
+				s2 = j2;
+				j2 = 0;
+			} else {
+				s2 = bsize;
+				j2 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+				dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+			}
+			for ( j1 = sh[1]; j1 > 0; ) {
+				if ( j1 < bsize ) {
+					s1 = j1;
+					j1 = 0;
+				} else {
+					s1 = bsize;
+					j1 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+					dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+				}
+				for ( j0 = sh[0]; j0 > 0; ) {
+					if ( j0 < bsize ) {
+						s0 = j0;
+						j0 = 0;
+					} else {
+						s0 = bsize;
+						j0 -= bsize;
+					}
+					// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+					for ( k = 0; k < N; k++ ) {
+						iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+						dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+					}
+					// Iterate over the non-reduced ndarray dimensions...
+					for ( i3 = 0; i3 < s3; i3++ ) {
+						for ( i2 = 0; i2 < s2; i2++ ) {
+							for ( i1 = 0; i1 < s1; i1++ ) {
+								for ( i0 = 0; i0 < s0; i0++ ) {
+									setViewOffsets( views, iv );
+									v[ 0 ] = strategyX( views[ 0 ] );
+									v[ 1 ] = strategyY( views[ 1 ] );
+									set( zbuf, iv[ 2 ], fcn( v, opts ) );
+									incrementOffsets( iv, dv0 );
+								}
+								incrementOffsets( iv, dv1 );
+							}
+							incrementOffsets( iv, dv2 );
+						}
+						incrementOffsets( iv, dv3 );
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary4d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d.js
new file mode 100644
index 000000000000..fcf16b8f4ff2
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d.js
@@ -0,0 +1,275 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary5d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ]
+*/
+function binary5d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 4 ];
+		S1 = sh[ 3 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 1 ];
+		S4 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[4],
+			stridesY[4]
+		];
+		dv1 = [
+			stridesX[3] - ( S0*stridesX[4] ),
+			stridesY[3] - ( S0*stridesY[4] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[3] ),
+			stridesY[2] - ( S1*stridesY[3] )
+		];
+		dv3 = [
+			stridesX[1] - ( S2*stridesX[2] ),
+			stridesY[1] - ( S2*stridesY[2] )
+		];
+		dv4 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S3*stridesX[1] ),
+			stridesY[0] - ( S3*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[4] );
+			dv1.push( sv[3] - ( S0*sv[4] ) );
+			dv2.push( sv[2] - ( S1*sv[3] ) );
+			dv3.push( sv[1] - ( S2*sv[2] ) );
+			dv4.push( sv[0] - ( S3*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		dv4 = [                                   // offset increment for outermost loop
+			stridesX[4] - ( S3*stridesX[3] ),
+			stridesY[4] - ( S3*stridesY[3] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+			dv4.push( sv[4] - ( S3*sv[3] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i4 = 0; i4 < S4; i4++ ) {
+		for ( i3 = 0; i3 < S3; i3++ ) {
+			for ( i2 = 0; i2 < S2; i2++ ) {
+				for ( i1 = 0; i1 < S1; i1++ ) {
+					for ( i0 = 0; i0 < S0; i0++ ) {
+						setViewOffsets( views, iv );
+						v[ 0 ] = strategyX( views[ 0 ] );
+						v[ 1 ] = strategyY( views[ 1 ] );
+						zbuf[ iv[2] ] = fcn( v, opts );
+						incrementOffsets( iv, dv0 );
+					}
+					incrementOffsets( iv, dv1 );
+				}
+				incrementOffsets( iv, dv2 );
+			}
+			incrementOffsets( iv, dv3 );
+		}
+		incrementOffsets( iv, dv4 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary5d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d_accessors.js
new file mode 100644
index 000000000000..b685944e22d4
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d_accessors.js
@@ -0,0 +1,284 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary5d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ]
+*/
+function binary5d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 4 ];
+		S1 = sh[ 3 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 1 ];
+		S4 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[4],
+			stridesY[4]
+		];
+		dv1 = [
+			stridesX[3] - ( S0*stridesX[4] ),
+			stridesY[3] - ( S0*stridesY[4] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[3] ),
+			stridesY[2] - ( S1*stridesY[3] )
+		];
+		dv3 = [
+			stridesX[1] - ( S2*stridesX[2] ),
+			stridesY[1] - ( S2*stridesY[2] )
+		];
+		dv4 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S3*stridesX[1] ),
+			stridesY[0] - ( S3*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[4] );
+			dv1.push( sv[3] - ( S0*sv[4] ) );
+			dv2.push( sv[2] - ( S1*sv[3] ) );
+			dv3.push( sv[1] - ( S2*sv[2] ) );
+			dv4.push( sv[0] - ( S3*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		dv4 = [                                   // offset increment for outermost loop
+			stridesX[4] - ( S3*stridesX[3] ),
+			stridesY[4] - ( S3*stridesY[3] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+			dv4.push( sv[4] - ( S3*sv[3] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i4 = 0; i4 < S4; i4++ ) {
+		for ( i3 = 0; i3 < S3; i3++ ) {
+			for ( i2 = 0; i2 < S2; i2++ ) {
+				for ( i1 = 0; i1 < S1; i1++ ) {
+					for ( i0 = 0; i0 < S0; i0++ ) {
+						setViewOffsets( views, iv );
+						v[ 0 ] = strategyX( views[ 0 ] );
+						v[ 1 ] = strategyY( views[ 1 ] );
+						set( zbuf, iv[ 2 ], fcn( v, opts ) );
+						incrementOffsets( iv, dv0 );
+					}
+					incrementOffsets( iv, dv1 );
+				}
+				incrementOffsets( iv, dv2 );
+			}
+			incrementOffsets( iv, dv3 );
+		}
+		incrementOffsets( iv, dv4 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary5d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d_blocked.js
new file mode 100644
index 000000000000..748189b9b1f0
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d_blocked.js
@@ -0,0 +1,314 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-statements, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary5d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ]
+*/
+function blockedbinary5d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var ov1;
+	var ov2;
+	var ov3;
+	var ov4;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	ov4 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	dv4 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j4 = sh[4]; j4 > 0; ) {
+		if ( j4 < bsize ) {
+			s4 = j4;
+			j4 = 0;
+		} else {
+			s4 = bsize;
+			j4 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov4[ k ] = ov[k] + ( j4*sv[k][4] );
+		}
+		for ( j3 = sh[3]; j3 > 0; ) {
+			if ( j3 < bsize ) {
+				s3 = j3;
+				j3 = 0;
+			} else {
+				s3 = bsize;
+				j3 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				dv4[ k ] = sv[k][4] - ( s3*sv[k][3] );
+				ov3[ k ] = ov4[k] + ( j3*sv[k][3] );
+			}
+			for ( j2 = sh[2]; j2 > 0; ) {
+				if ( j2 < bsize ) {
+					s2 = j2;
+					j2 = 0;
+				} else {
+					s2 = bsize;
+					j2 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+					ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+				}
+				for ( j1 = sh[1]; j1 > 0; ) {
+					if ( j1 < bsize ) {
+						s1 = j1;
+						j1 = 0;
+					} else {
+						s1 = bsize;
+						j1 -= bsize;
+					}
+					for ( k = 0; k < N; k++ ) {
+						dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+						ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+					}
+					for ( j0 = sh[0]; j0 > 0; ) {
+						if ( j0 < bsize ) {
+							s0 = j0;
+							j0 = 0;
+						} else {
+							s0 = bsize;
+							j0 -= bsize;
+						}
+						// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+						for ( k = 0; k < N; k++ ) {
+							iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+							dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+						}
+						// Iterate over the non-reduced ndarray dimensions...
+						for ( i4 = 0; i4 < s4; i4++ ) {
+							for ( i3 = 0; i3 < s3; i3++ ) {
+								for ( i2 = 0; i2 < s2; i2++ ) {
+									for ( i1 = 0; i1 < s1; i1++ ) {
+										for ( i0 = 0; i0 < s0; i0++ ) {
+											setViewOffsets( views, iv );
+											v[ 0 ] = strategyX( views[ 0 ] );
+											v[ 1 ] = strategyY( views[ 1 ] );
+											zbuf[ iv[2] ] = fcn( v, opts );
+											incrementOffsets( iv, dv0 );
+										}
+										incrementOffsets( iv, dv1 );
+									}
+									incrementOffsets( iv, dv2 );
+								}
+								incrementOffsets( iv, dv3 );
+							}
+							incrementOffsets( iv, dv4 );
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary5d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d_blocked_accessors.js
new file mode 100644
index 000000000000..bcd752501b35
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/5d_blocked_accessors.js
@@ -0,0 +1,323 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary5d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ]
+*/
+function blockedbinary5d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var ov1;
+	var ov2;
+	var ov3;
+	var ov4;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[1];
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	ov4 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	dv4 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j4 = sh[4]; j4 > 0; ) {
+		if ( j4 < bsize ) {
+			s4 = j4;
+			j4 = 0;
+		} else {
+			s4 = bsize;
+			j4 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov4[ k ] = ov[k] + ( j4*sv[k][4] );
+		}
+		for ( j3 = sh[3]; j3 > 0; ) {
+			if ( j3 < bsize ) {
+				s3 = j3;
+				j3 = 0;
+			} else {
+				s3 = bsize;
+				j3 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				dv4[ k ] = sv[k][4] - ( s3*sv[k][3] );
+				ov3[ k ] = ov4[k] + ( j3*sv[k][3] );
+			}
+			for ( j2 = sh[2]; j2 > 0; ) {
+				if ( j2 < bsize ) {
+					s2 = j2;
+					j2 = 0;
+				} else {
+					s2 = bsize;
+					j2 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+					ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+				}
+				for ( j1 = sh[1]; j1 > 0; ) {
+					if ( j1 < bsize ) {
+						s1 = j1;
+						j1 = 0;
+					} else {
+						s1 = bsize;
+						j1 -= bsize;
+					}
+					for ( k = 0; k < N; k++ ) {
+						dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+						ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+					}
+					for ( j0 = sh[0]; j0 > 0; ) {
+						if ( j0 < bsize ) {
+							s0 = j0;
+							j0 = 0;
+						} else {
+							s0 = bsize;
+							j0 -= bsize;
+						}
+						// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+						for ( k = 0; k < N; k++ ) {
+							iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+							dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+						}
+						// Iterate over the non-reduced ndarray dimensions...
+						for ( i4 = 0; i4 < s4; i4++ ) {
+							for ( i3 = 0; i3 < s3; i3++ ) {
+								for ( i2 = 0; i2 < s2; i2++ ) {
+									for ( i1 = 0; i1 < s1; i1++ ) {
+										for ( i0 = 0; i0 < s0; i0++ ) {
+											setViewOffsets( views, iv );
+											v[ 0 ] = strategyX( views[ 0 ] );
+											v[ 1 ] = strategyY( views[ 1 ] );
+											set( zbuf, iv[ 2 ], fcn( v, opts ) );
+											incrementOffsets( iv, dv0 );
+										}
+										incrementOffsets( iv, dv1 );
+									}
+									incrementOffsets( iv, dv2 );
+								}
+								incrementOffsets( iv, dv3 );
+							}
+							incrementOffsets( iv, dv4 );
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary5d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d.js
new file mode 100644
index 000000000000..03b51ffb55b8
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d.js
@@ -0,0 +1,293 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary6d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ]
+*/
+function binary6d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 5 ];
+		S1 = sh[ 4 ];
+		S2 = sh[ 3 ];
+		S3 = sh[ 2 ];
+		S4 = sh[ 1 ];
+		S5 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[5],
+			stridesY[5]
+		];
+		dv1 = [
+			stridesX[4] - ( S0*stridesX[5] ),
+			stridesY[4] - ( S0*stridesY[5] )
+		];
+		dv2 = [
+			stridesX[3] - ( S1*stridesX[4] ),
+			stridesY[3] - ( S1*stridesY[4] )
+		];
+		dv3 = [
+			stridesX[2] - ( S2*stridesX[3] ),
+			stridesY[2] - ( S2*stridesY[3] )
+		];
+		dv4 = [
+			stridesX[1] - ( S3*stridesX[2] ),
+			stridesY[1] - ( S3*stridesY[2] )
+		];
+		dv5 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S4*stridesX[1] ),
+			stridesY[0] - ( S4*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[5] );
+			dv1.push( sv[4] - ( S0*sv[5] ) );
+			dv2.push( sv[3] - ( S1*sv[4] ) );
+			dv3.push( sv[2] - ( S2*sv[3] ) );
+			dv4.push( sv[1] - ( S3*sv[2] ) );
+			dv5.push( sv[0] - ( S4*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		dv4 = [
+			stridesX[4] - ( S3*stridesX[3] ),
+			stridesY[4] - ( S3*stridesY[3] )
+		];
+		dv5 = [                                   // offset increment for outermost loop
+			stridesX[5] - ( S4*stridesX[4] ),
+			stridesY[5] - ( S4*stridesY[4] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+			dv4.push( sv[4] - ( S3*sv[3] ) );
+			dv5.push( sv[5] - ( S4*sv[4] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i5 = 0; i5 < S5; i5++ ) {
+		for ( i4 = 0; i4 < S4; i4++ ) {
+			for ( i3 = 0; i3 < S3; i3++ ) {
+				for ( i2 = 0; i2 < S2; i2++ ) {
+					for ( i1 = 0; i1 < S1; i1++ ) {
+						for ( i0 = 0; i0 < S0; i0++ ) {
+							setViewOffsets( views, iv );
+							v[ 0 ] = strategyX( views[ 0 ] );
+							v[ 1 ] = strategyY( views[ 1 ] );
+							zbuf[ iv[2] ] = fcn( v, opts );
+							incrementOffsets( iv, dv0 );
+						}
+						incrementOffsets( iv, dv1 );
+					}
+					incrementOffsets( iv, dv2 );
+				}
+				incrementOffsets( iv, dv3 );
+			}
+			incrementOffsets( iv, dv4 );
+		}
+		incrementOffsets( iv, dv5 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary6d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d_accessors.js
new file mode 100644
index 000000000000..5a60f9feffdf
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d_accessors.js
@@ -0,0 +1,302 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary6d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ]
+*/
+function binary6d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 5 ];
+		S1 = sh[ 4 ];
+		S2 = sh[ 3 ];
+		S3 = sh[ 2 ];
+		S4 = sh[ 1 ];
+		S5 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[5],
+			stridesY[5]
+		];
+		dv1 = [
+			stridesX[4] - ( S0*stridesX[5] ),
+			stridesY[4] - ( S0*stridesY[5] )
+		];
+		dv2 = [
+			stridesX[3] - ( S1*stridesX[4] ),
+			stridesY[3] - ( S1*stridesY[4] )
+		];
+		dv3 = [
+			stridesX[2] - ( S2*stridesX[3] ),
+			stridesY[2] - ( S2*stridesY[3] )
+		];
+		dv4 = [
+			stridesX[1] - ( S3*stridesX[2] ),
+			stridesY[1] - ( S3*stridesY[2] )
+		];
+		dv5 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S4*stridesX[1] ),
+			stridesY[0] - ( S4*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[5] );
+			dv1.push( sv[4] - ( S0*sv[5] ) );
+			dv2.push( sv[3] - ( S1*sv[4] ) );
+			dv3.push( sv[2] - ( S2*sv[3] ) );
+			dv4.push( sv[1] - ( S3*sv[2] ) );
+			dv5.push( sv[0] - ( S4*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		dv4 = [
+			stridesX[4] - ( S3*stridesX[3] ),
+			stridesY[4] - ( S3*stridesY[3] )
+		];
+		dv5 = [                                   // offset increment for outermost loop
+			stridesX[5] - ( S4*stridesX[4] ),
+			stridesY[5] - ( S4*stridesY[4] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+			dv4.push( sv[4] - ( S3*sv[3] ) );
+			dv5.push( sv[5] - ( S4*sv[4] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i5 = 0; i5 < S5; i5++ ) {
+		for ( i4 = 0; i4 < S4; i4++ ) {
+			for ( i3 = 0; i3 < S3; i3++ ) {
+				for ( i2 = 0; i2 < S2; i2++ ) {
+					for ( i1 = 0; i1 < S1; i1++ ) {
+						for ( i0 = 0; i0 < S0; i0++ ) {
+							setViewOffsets( views, iv );
+							v[ 0 ] = strategyX( views[ 0 ] );
+							v[ 1 ] = strategyY( views[ 1 ] );
+							set( zbuf, iv[ 2 ], fcn( v, opts ) );
+							incrementOffsets( iv, dv0 );
+						}
+						incrementOffsets( iv, dv1 );
+					}
+					incrementOffsets( iv, dv2 );
+				}
+				incrementOffsets( iv, dv3 );
+			}
+			incrementOffsets( iv, dv4 );
+		}
+		incrementOffsets( iv, dv5 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary6d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d_blocked.js
new file mode 100644
index 000000000000..7f099c73028d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d_blocked.js
@@ -0,0 +1,337 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary6d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ]
+*/
+function blockedbinary6d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var ov1;
+	var ov2;
+	var ov3;
+	var ov4;
+	var ov5;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	ov4 = zeros( N );
+	ov5 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	dv4 = zeros( N );
+	dv5 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j5 = sh[5]; j5 > 0; ) {
+		if ( j5 < bsize ) {
+			s5 = j5;
+			j5 = 0;
+		} else {
+			s5 = bsize;
+			j5 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov5[ k ] = ov[k] + ( j5*sv[k][5] );
+		}
+		for ( j4 = sh[4]; j4 > 0; ) {
+			if ( j4 < bsize ) {
+				s4 = j4;
+				j4 = 0;
+			} else {
+				s4 = bsize;
+				j4 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
+				ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
+			}
+			for ( j3 = sh[3]; j3 > 0; ) {
+				if ( j3 < bsize ) {
+					s3 = j3;
+					j3 = 0;
+				} else {
+					s3 = bsize;
+					j3 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					dv4[ k ] = sv[k][4] - ( s3*sv[k][3] );
+					ov3[ k ] = ov4[k] + ( j3*sv[k][3] );
+				}
+				for ( j2 = sh[2]; j2 > 0; ) {
+					if ( j2 < bsize ) {
+						s2 = j2;
+						j2 = 0;
+					} else {
+						s2 = bsize;
+						j2 -= bsize;
+					}
+					for ( k = 0; k < N; k++ ) {
+						dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+						ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+					}
+					for ( j1 = sh[1]; j1 > 0; ) {
+						if ( j1 < bsize ) {
+							s1 = j1;
+							j1 = 0;
+						} else {
+							s1 = bsize;
+							j1 -= bsize;
+						}
+						for ( k = 0; k < N; k++ ) {
+							dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+							ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+						}
+						for ( j0 = sh[0]; j0 > 0; ) {
+							if ( j0 < bsize ) {
+								s0 = j0;
+								j0 = 0;
+							} else {
+								s0 = bsize;
+								j0 -= bsize;
+							}
+							// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+							for ( k = 0; k < N; k++ ) {
+								iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+								dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+							}
+							// Iterate over the non-reduced ndarray dimensions...
+							for ( i5 = 0; i5 < s5; i5++ ) {
+								for ( i4 = 0; i4 < s4; i4++ ) {
+									for ( i3 = 0; i3 < s3; i3++ ) {
+										for ( i2 = 0; i2 < s2; i2++ ) {
+											for ( i1 = 0; i1 < s1; i1++ ) {
+												for ( i0 = 0; i0 < s0; i0++ ) {
+													setViewOffsets( views, iv );
+													v[ 0 ] = strategyX( views[ 0 ] );
+													v[ 1 ] = strategyY( views[ 1 ] );
+													zbuf[ iv[2] ] = fcn( v, opts );
+													incrementOffsets( iv, dv0 );
+												}
+												incrementOffsets( iv, dv1 );
+											}
+											incrementOffsets( iv, dv2 );
+										}
+										incrementOffsets( iv, dv3 );
+									}
+									incrementOffsets( iv, dv4 );
+								}
+								incrementOffsets( iv, dv5 );
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary6d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d_blocked_accessors.js
new file mode 100644
index 000000000000..dac4814708a0
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/6d_blocked_accessors.js
@@ -0,0 +1,346 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary6d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ]
+*/
+function blockedbinary6d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var ov1;
+	var ov2;
+	var ov3;
+	var ov4;
+	var ov5;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[1];
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	ov4 = zeros( N );
+	ov5 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	dv4 = zeros( N );
+	dv5 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j5 = sh[5]; j5 > 0; ) {
+		if ( j5 < bsize ) {
+			s5 = j5;
+			j5 = 0;
+		} else {
+			s5 = bsize;
+			j5 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov5[ k ] = ov[k] + ( j5*sv[k][5] );
+		}
+		for ( j4 = sh[4]; j4 > 0; ) {
+			if ( j4 < bsize ) {
+				s4 = j4;
+				j4 = 0;
+			} else {
+				s4 = bsize;
+				j4 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
+				ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
+			}
+			for ( j3 = sh[3]; j3 > 0; ) {
+				if ( j3 < bsize ) {
+					s3 = j3;
+					j3 = 0;
+				} else {
+					s3 = bsize;
+					j3 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					dv4[ k ] = sv[k][4] - ( s3*sv[k][3] );
+					ov3[ k ] = ov4[k] + ( j3*sv[k][3] );
+				}
+				for ( j2 = sh[2]; j2 > 0; ) {
+					if ( j2 < bsize ) {
+						s2 = j2;
+						j2 = 0;
+					} else {
+						s2 = bsize;
+						j2 -= bsize;
+					}
+					for ( k = 0; k < N; k++ ) {
+						dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+						ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+					}
+					for ( j1 = sh[1]; j1 > 0; ) {
+						if ( j1 < bsize ) {
+							s1 = j1;
+							j1 = 0;
+						} else {
+							s1 = bsize;
+							j1 -= bsize;
+						}
+						for ( k = 0; k < N; k++ ) {
+							dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+							ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+						}
+						for ( j0 = sh[0]; j0 > 0; ) {
+							if ( j0 < bsize ) {
+								s0 = j0;
+								j0 = 0;
+							} else {
+								s0 = bsize;
+								j0 -= bsize;
+							}
+							// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+							for ( k = 0; k < N; k++ ) {
+								iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+								dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+							}
+							// Iterate over the non-reduced ndarray dimensions...
+							for ( i5 = 0; i5 < s5; i5++ ) {
+								for ( i4 = 0; i4 < s4; i4++ ) {
+									for ( i3 = 0; i3 < s3; i3++ ) {
+										for ( i2 = 0; i2 < s2; i2++ ) {
+											for ( i1 = 0; i1 < s1; i1++ ) {
+												for ( i0 = 0; i0 < s0; i0++ ) {
+													setViewOffsets( views, iv );
+													v[ 0 ] = strategyX( views[ 0 ] );
+													v[ 1 ] = strategyY( views[ 1 ] );
+													set( zbuf, iv[ 2 ], fcn( v, opts ) );
+													incrementOffsets( iv, dv0 );
+												}
+												incrementOffsets( iv, dv1 );
+											}
+											incrementOffsets( iv, dv2 );
+										}
+										incrementOffsets( iv, dv3 );
+									}
+									incrementOffsets( iv, dv4 );
+								}
+								incrementOffsets( iv, dv5 );
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary6d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d.js
new file mode 100644
index 000000000000..c209579088f8
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d.js
@@ -0,0 +1,311 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary7d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ]
+*/
+function binary7d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 6 ];
+		S1 = sh[ 5 ];
+		S2 = sh[ 4 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 2 ];
+		S5 = sh[ 1 ];
+		S6 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[6],
+			stridesY[6]
+		];
+		dv1 = [
+			stridesX[5] - ( S0*stridesX[6] ),
+			stridesY[5] - ( S0*stridesY[6] )
+		];
+		dv2 = [
+			stridesX[4] - ( S1*stridesX[5] ),
+			stridesY[4] - ( S1*stridesY[5] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[4] ),
+			stridesY[3] - ( S2*stridesY[4] )
+		];
+		dv4 = [
+			stridesX[2] - ( S3*stridesX[3] ),
+			stridesY[2] - ( S3*stridesY[3] )
+		];
+		dv5 = [
+			stridesX[1] - ( S4*stridesX[2] ),
+			stridesY[1] - ( S4*stridesY[2] )
+		];
+		dv6 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S5*stridesX[1] ),
+			stridesY[0] - ( S5*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[6] );
+			dv1.push( sv[5] - ( S0*sv[6] ) );
+			dv2.push( sv[4] - ( S1*sv[5] ) );
+			dv3.push( sv[3] - ( S2*sv[4] ) );
+			dv4.push( sv[2] - ( S3*sv[3] ) );
+			dv5.push( sv[1] - ( S4*sv[2] ) );
+			dv6.push( sv[0] - ( S5*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		dv4 = [
+			stridesX[4] - ( S3*stridesX[3] ),
+			stridesY[4] - ( S3*stridesY[3] )
+		];
+		dv5 = [
+			stridesX[5] - ( S4*stridesX[4] ),
+			stridesY[5] - ( S4*stridesY[4] )
+		];
+		dv6 = [                                   // offset increment for outermost loop
+			stridesX[6] - ( S5*stridesX[5] ),
+			stridesY[6] - ( S5*stridesY[5] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+			dv4.push( sv[4] - ( S3*sv[3] ) );
+			dv5.push( sv[5] - ( S4*sv[4] ) );
+			dv6.push( sv[6] - ( S5*sv[5] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i6 = 0; i6 < S6; i6++ ) {
+		for ( i5 = 0; i5 < S5; i5++ ) {
+			for ( i4 = 0; i4 < S4; i4++ ) {
+				for ( i3 = 0; i3 < S3; i3++ ) {
+					for ( i2 = 0; i2 < S2; i2++ ) {
+						for ( i1 = 0; i1 < S1; i1++ ) {
+							for ( i0 = 0; i0 < S0; i0++ ) {
+								setViewOffsets( views, iv );
+								v[ 0 ] = strategyX( views[ 0 ] );
+								v[ 1 ] = strategyY( views[ 1 ] );
+								zbuf[ iv[2] ] = fcn( v, opts );
+								incrementOffsets( iv, dv0 );
+							}
+							incrementOffsets( iv, dv1 );
+						}
+						incrementOffsets( iv, dv2 );
+					}
+					incrementOffsets( iv, dv3 );
+				}
+				incrementOffsets( iv, dv4 );
+			}
+			incrementOffsets( iv, dv5 );
+		}
+		incrementOffsets( iv, dv6 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary7d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d_accessors.js
new file mode 100644
index 000000000000..ce404c8c602a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d_accessors.js
@@ -0,0 +1,320 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary7d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ]
+*/
+function binary7d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 6 ];
+		S1 = sh[ 5 ];
+		S2 = sh[ 4 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 2 ];
+		S5 = sh[ 1 ];
+		S6 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[6],
+			stridesY[6]
+		];
+		dv1 = [
+			stridesX[5] - ( S0*stridesX[6] ),
+			stridesY[5] - ( S0*stridesY[6] )
+		];
+		dv2 = [
+			stridesX[4] - ( S1*stridesX[5] ),
+			stridesY[4] - ( S1*stridesY[5] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[4] ),
+			stridesY[3] - ( S2*stridesY[4] )
+		];
+		dv4 = [
+			stridesX[2] - ( S3*stridesX[3] ),
+			stridesY[2] - ( S3*stridesY[3] )
+		];
+		dv5 = [
+			stridesX[1] - ( S4*stridesX[2] ),
+			stridesY[1] - ( S4*stridesY[2] )
+		];
+		dv6 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S5*stridesX[1] ),
+			stridesY[0] - ( S5*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[6] );
+			dv1.push( sv[5] - ( S0*sv[6] ) );
+			dv2.push( sv[4] - ( S1*sv[5] ) );
+			dv3.push( sv[3] - ( S2*sv[4] ) );
+			dv4.push( sv[2] - ( S3*sv[3] ) );
+			dv5.push( sv[1] - ( S4*sv[2] ) );
+			dv6.push( sv[0] - ( S5*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		dv4 = [
+			stridesX[4] - ( S3*stridesX[3] ),
+			stridesY[4] - ( S3*stridesY[3] )
+		];
+		dv5 = [
+			stridesX[5] - ( S4*stridesX[4] ),
+			stridesY[5] - ( S4*stridesY[4] )
+		];
+		dv6 = [                                   // offset increment for outermost loop
+			stridesX[6] - ( S5*stridesX[5] ),
+			stridesY[6] - ( S5*stridesY[5] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+			dv4.push( sv[4] - ( S3*sv[3] ) );
+			dv5.push( sv[5] - ( S4*sv[4] ) );
+			dv6.push( sv[6] - ( S5*sv[5] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i6 = 0; i6 < S6; i6++ ) {
+		for ( i5 = 0; i5 < S5; i5++ ) {
+			for ( i4 = 0; i4 < S4; i4++ ) {
+				for ( i3 = 0; i3 < S3; i3++ ) {
+					for ( i2 = 0; i2 < S2; i2++ ) {
+						for ( i1 = 0; i1 < S1; i1++ ) {
+							for ( i0 = 0; i0 < S0; i0++ ) {
+								setViewOffsets( views, iv );
+								v[ 0 ] = strategyX( views[ 0 ] );
+								v[ 1 ] = strategyY( views[ 1 ] );
+								set( zbuf, iv[ 2 ], fcn( v, opts ) );
+								incrementOffsets( iv, dv0 );
+							}
+							incrementOffsets( iv, dv1 );
+						}
+						incrementOffsets( iv, dv2 );
+					}
+					incrementOffsets( iv, dv3 );
+				}
+				incrementOffsets( iv, dv4 );
+			}
+			incrementOffsets( iv, dv5 );
+		}
+		incrementOffsets( iv, dv6 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary7d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d_blocked.js
new file mode 100644
index 000000000000..8e6d4dcf43f5
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d_blocked.js
@@ -0,0 +1,360 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary7d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ]
+*/
+function blockedbinary7d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var ov1;
+	var ov2;
+	var ov3;
+	var ov4;
+	var ov5;
+	var ov6;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	ov4 = zeros( N );
+	ov5 = zeros( N );
+	ov6 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	dv4 = zeros( N );
+	dv5 = zeros( N );
+	dv6 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j6 = sh[6]; j6 > 0; ) {
+		if ( j6 < bsize ) {
+			s6 = j6;
+			j6 = 0;
+		} else {
+			s6 = bsize;
+			j6 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov6[ k ] = ov[k] + ( j6*sv[k][6] );
+		}
+		for ( j5 = sh[5]; j5 > 0; ) {
+			if ( j5 < bsize ) {
+				s5 = j5;
+				j5 = 0;
+			} else {
+				s5 = bsize;
+				j5 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
+				ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
+			}
+			for ( j4 = sh[4]; j4 > 0; ) {
+				if ( j4 < bsize ) {
+					s4 = j4;
+					j4 = 0;
+				} else {
+					s4 = bsize;
+					j4 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
+					ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
+				}
+				for ( j3 = sh[3]; j3 > 0; ) {
+					if ( j3 < bsize ) {
+						s3 = j3;
+						j3 = 0;
+					} else {
+						s3 = bsize;
+						j3 -= bsize;
+					}
+					for ( k = 0; k < N; k++ ) {
+						dv4[ k ] = sv[k][4] - ( s3*sv[k][3] );
+						ov3[ k ] = ov4[k] + ( j3*sv[k][3] );
+					}
+					for ( j2 = sh[2]; j2 > 0; ) {
+						if ( j2 < bsize ) {
+							s2 = j2;
+							j2 = 0;
+						} else {
+							s2 = bsize;
+							j2 -= bsize;
+						}
+						for ( k = 0; k < N; k++ ) {
+							dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+							ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+						}
+						for ( j1 = sh[1]; j1 > 0; ) {
+							if ( j1 < bsize ) {
+								s1 = j1;
+								j1 = 0;
+							} else {
+								s1 = bsize;
+								j1 -= bsize;
+							}
+							for ( k = 0; k < N; k++ ) {
+								dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+								ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+							}
+							for ( j0 = sh[0]; j0 > 0; ) {
+								if ( j0 < bsize ) {
+									s0 = j0;
+									j0 = 0;
+								} else {
+									s0 = bsize;
+									j0 -= bsize;
+								}
+								// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+								for ( k = 0; k < N; k++ ) {
+									iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+									dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+								}
+								// Iterate over the non-reduced ndarray dimensions...
+								for ( i6 = 0; i6 < s6; i6++ ) {
+									for ( i5 = 0; i5 < s5; i5++ ) {
+										for ( i4 = 0; i4 < s4; i4++ ) {
+											for ( i3 = 0; i3 < s3; i3++ ) {
+												for ( i2 = 0; i2 < s2; i2++ ) {
+													for ( i1 = 0; i1 < s1; i1++ ) {
+														for ( i0 = 0; i0 < s0; i0++ ) {
+															setViewOffsets( views, iv );
+															v[ 0 ] = strategyX( views[ 0 ] );
+															v[ 1 ] = strategyY( views[ 1 ] );
+															zbuf[ iv[2] ] = fcn( v, opts );
+															incrementOffsets( iv, dv0 );
+														}
+														incrementOffsets( iv, dv1 );
+													}
+													incrementOffsets( iv, dv2 );
+												}
+												incrementOffsets( iv, dv3 );
+											}
+											incrementOffsets( iv, dv4 );
+										}
+										incrementOffsets( iv, dv5 );
+									}
+									incrementOffsets( iv, dv6 );
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary7d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d_blocked_accessors.js
new file mode 100644
index 000000000000..8a2652f97584
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/7d_blocked_accessors.js
@@ -0,0 +1,369 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary7d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ]
+*/
+function blockedbinary7d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var ov1;
+	var ov2;
+	var ov3;
+	var ov4;
+	var ov5;
+	var ov6;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	ov4 = zeros( N );
+	ov5 = zeros( N );
+	ov6 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	dv4 = zeros( N );
+	dv5 = zeros( N );
+	dv6 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j6 = sh[6]; j6 > 0; ) {
+		if ( j6 < bsize ) {
+			s6 = j6;
+			j6 = 0;
+		} else {
+			s6 = bsize;
+			j6 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov6[ k ] = ov[k] + ( j6*sv[k][6] );
+		}
+		for ( j5 = sh[5]; j5 > 0; ) {
+			if ( j5 < bsize ) {
+				s5 = j5;
+				j5 = 0;
+			} else {
+				s5 = bsize;
+				j5 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
+				ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
+			}
+			for ( j4 = sh[4]; j4 > 0; ) {
+				if ( j4 < bsize ) {
+					s4 = j4;
+					j4 = 0;
+				} else {
+					s4 = bsize;
+					j4 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
+					ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
+				}
+				for ( j3 = sh[3]; j3 > 0; ) {
+					if ( j3 < bsize ) {
+						s3 = j3;
+						j3 = 0;
+					} else {
+						s3 = bsize;
+						j3 -= bsize;
+					}
+					for ( k = 0; k < N; k++ ) {
+						dv4[ k ] = sv[k][4] - ( s3*sv[k][3] );
+						ov3[ k ] = ov4[k] + ( j3*sv[k][3] );
+					}
+					for ( j2 = sh[2]; j2 > 0; ) {
+						if ( j2 < bsize ) {
+							s2 = j2;
+							j2 = 0;
+						} else {
+							s2 = bsize;
+							j2 -= bsize;
+						}
+						for ( k = 0; k < N; k++ ) {
+							dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+							ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+						}
+						for ( j1 = sh[1]; j1 > 0; ) {
+							if ( j1 < bsize ) {
+								s1 = j1;
+								j1 = 0;
+							} else {
+								s1 = bsize;
+								j1 -= bsize;
+							}
+							for ( k = 0; k < N; k++ ) {
+								dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+								ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+							}
+							for ( j0 = sh[0]; j0 > 0; ) {
+								if ( j0 < bsize ) {
+									s0 = j0;
+									j0 = 0;
+								} else {
+									s0 = bsize;
+									j0 -= bsize;
+								}
+								// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+								for ( k = 0; k < N; k++ ) {
+									iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+									dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+								}
+								// Iterate over the non-reduced ndarray dimensions...
+								for ( i6 = 0; i6 < s6; i6++ ) {
+									for ( i5 = 0; i5 < s5; i5++ ) {
+										for ( i4 = 0; i4 < s4; i4++ ) {
+											for ( i3 = 0; i3 < s3; i3++ ) {
+												for ( i2 = 0; i2 < s2; i2++ ) {
+													for ( i1 = 0; i1 < s1; i1++ ) {
+														for ( i0 = 0; i0 < s0; i0++ ) {
+															setViewOffsets( views, iv );
+															v[ 0 ] = strategyX( views[ 0 ] );
+															v[ 1 ] = strategyY( views[ 1 ] );
+															set( zbuf, iv[ 2 ], fcn( v, opts ) );
+															incrementOffsets( iv, dv0 );
+														}
+														incrementOffsets( iv, dv1 );
+													}
+													incrementOffsets( iv, dv2 );
+												}
+												incrementOffsets( iv, dv3 );
+											}
+											incrementOffsets( iv, dv4 );
+										}
+										incrementOffsets( iv, dv5 );
+									}
+									incrementOffsets( iv, dv6 );
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary7d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d.js
new file mode 100644
index 000000000000..52259c41b9ce
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d.js
@@ -0,0 +1,329 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary8d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ] ]
+*/
+function binary8d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var dv7;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 7 ];
+		S1 = sh[ 6 ];
+		S2 = sh[ 5 ];
+		S3 = sh[ 4 ];
+		S4 = sh[ 3 ];
+		S5 = sh[ 2 ];
+		S6 = sh[ 1 ];
+		S7 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[7],
+			stridesY[7]
+		];
+		dv1 = [
+			stridesX[6] - ( S0*stridesX[7] ),
+			stridesY[6] - ( S0*stridesY[7] )
+		];
+		dv2 = [
+			stridesX[5] - ( S1*stridesX[6] ),
+			stridesY[5] - ( S1*stridesY[6] )
+		];
+		dv3 = [
+			stridesX[4] - ( S2*stridesX[5] ),
+			stridesY[4] - ( S2*stridesY[5] )
+		];
+		dv4 = [
+			stridesX[3] - ( S3*stridesX[4] ),
+			stridesY[3] - ( S3*stridesY[4] )
+		];
+		dv5 = [
+			stridesX[2] - ( S4*stridesX[3] ),
+			stridesY[2] - ( S4*stridesY[3] )
+		];
+		dv6 = [
+			stridesX[1] - ( S5*stridesX[2] ),
+			stridesY[1] - ( S5*stridesY[2] )
+		];
+		dv7 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S6*stridesX[1] ),
+			stridesY[0] - ( S6*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[7] );
+			dv1.push( sv[6] - ( S0*sv[7] ) );
+			dv2.push( sv[5] - ( S1*sv[6] ) );
+			dv3.push( sv[4] - ( S2*sv[5] ) );
+			dv4.push( sv[3] - ( S3*sv[4] ) );
+			dv5.push( sv[2] - ( S4*sv[3] ) );
+			dv6.push( sv[1] - ( S5*sv[2] ) );
+			dv7.push( sv[0] - ( S6*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		dv4 = [
+			stridesX[4] - ( S3*stridesX[3] ),
+			stridesY[4] - ( S3*stridesY[3] )
+		];
+		dv5 = [
+			stridesX[5] - ( S4*stridesX[4] ),
+			stridesY[5] - ( S4*stridesY[4] )
+		];
+		dv6 = [
+			stridesX[6] - ( S5*stridesX[5] ),
+			stridesY[6] - ( S5*stridesY[5] )
+		];
+		dv7 = [                                   // offset increment for outermost loop
+			stridesX[7] - ( S6*stridesX[6] ),
+			stridesY[7] - ( S6*stridesY[6] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+			dv4.push( sv[4] - ( S3*sv[3] ) );
+			dv5.push( sv[5] - ( S4*sv[4] ) );
+			dv6.push( sv[6] - ( S5*sv[5] ) );
+			dv7.push( sv[7] - ( S6*sv[6] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i7 = 0; i7 < S7; i7++ ) {
+		for ( i6 = 0; i6 < S6; i6++ ) {
+			for ( i5 = 0; i5 < S5; i5++ ) {
+				for ( i4 = 0; i4 < S4; i4++ ) {
+					for ( i3 = 0; i3 < S3; i3++ ) {
+						for ( i2 = 0; i2 < S2; i2++ ) {
+							for ( i1 = 0; i1 < S1; i1++ ) {
+								for ( i0 = 0; i0 < S0; i0++ ) {
+									setViewOffsets( views, iv );
+									v[ 0 ] = strategyX( views[ 0 ] );
+									v[ 1 ] = strategyY( views[ 1 ] );
+									zbuf[ iv[2] ] = fcn( v, opts );
+									incrementOffsets( iv, dv0 );
+								}
+								incrementOffsets( iv, dv1 );
+							}
+							incrementOffsets( iv, dv2 );
+						}
+						incrementOffsets( iv, dv3 );
+					}
+					incrementOffsets( iv, dv4 );
+				}
+				incrementOffsets( iv, dv5 );
+			}
+			incrementOffsets( iv, dv6 );
+		}
+		incrementOffsets( iv, dv7 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary8d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d_accessors.js
new file mode 100644
index 000000000000..8c01e4c5c895
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d_accessors.js
@@ -0,0 +1,338 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary8d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ] ]
+*/
+function binary8d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var dv7;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 7 ];
+		S1 = sh[ 6 ];
+		S2 = sh[ 5 ];
+		S3 = sh[ 4 ];
+		S4 = sh[ 3 ];
+		S5 = sh[ 2 ];
+		S6 = sh[ 1 ];
+		S7 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[7],
+			stridesY[7]
+		];
+		dv1 = [
+			stridesX[6] - ( S0*stridesX[7] ),
+			stridesY[6] - ( S0*stridesY[7] )
+		];
+		dv2 = [
+			stridesX[5] - ( S1*stridesX[6] ),
+			stridesY[5] - ( S1*stridesY[6] )
+		];
+		dv3 = [
+			stridesX[4] - ( S2*stridesX[5] ),
+			stridesY[4] - ( S2*stridesY[5] )
+		];
+		dv4 = [
+			stridesX[3] - ( S3*stridesX[4] ),
+			stridesY[3] - ( S3*stridesY[4] )
+		];
+		dv5 = [
+			stridesX[2] - ( S4*stridesX[3] ),
+			stridesY[2] - ( S4*stridesY[3] )
+		];
+		dv6 = [
+			stridesX[1] - ( S5*stridesX[2] ),
+			stridesY[1] - ( S5*stridesY[2] )
+		];
+		dv7 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S6*stridesX[1] ),
+			stridesY[0] - ( S6*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[7] );
+			dv1.push( sv[6] - ( S0*sv[7] ) );
+			dv2.push( sv[5] - ( S1*sv[6] ) );
+			dv3.push( sv[4] - ( S2*sv[5] ) );
+			dv4.push( sv[3] - ( S3*sv[4] ) );
+			dv5.push( sv[2] - ( S4*sv[3] ) );
+			dv6.push( sv[1] - ( S5*sv[2] ) );
+			dv7.push( sv[0] - ( S6*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		dv4 = [
+			stridesX[4] - ( S3*stridesX[3] ),
+			stridesY[4] - ( S3*stridesY[3] )
+		];
+		dv5 = [
+			stridesX[5] - ( S4*stridesX[4] ),
+			stridesY[5] - ( S4*stridesY[4] )
+		];
+		dv6 = [
+			stridesX[6] - ( S5*stridesX[5] ),
+			stridesY[6] - ( S5*stridesY[5] )
+		];
+		dv7 = [                                   // offset increment for outermost loop
+			stridesX[7] - ( S6*stridesX[6] ),
+			stridesY[7] - ( S6*stridesY[6] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+			dv4.push( sv[4] - ( S3*sv[3] ) );
+			dv5.push( sv[5] - ( S4*sv[4] ) );
+			dv6.push( sv[6] - ( S5*sv[5] ) );
+			dv7.push( sv[7] - ( S6*sv[6] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i7 = 0; i7 < S7; i7++ ) {
+		for ( i6 = 0; i6 < S6; i6++ ) {
+			for ( i5 = 0; i5 < S5; i5++ ) {
+				for ( i4 = 0; i4 < S4; i4++ ) {
+					for ( i3 = 0; i3 < S3; i3++ ) {
+						for ( i2 = 0; i2 < S2; i2++ ) {
+							for ( i1 = 0; i1 < S1; i1++ ) {
+								for ( i0 = 0; i0 < S0; i0++ ) {
+									setViewOffsets( views, iv );
+									v[ 0 ] = strategyX( views[ 0 ] );
+									v[ 1 ] = strategyY( views[ 1 ] );
+									set( zbuf, iv[ 2 ], fcn( v, opts ) );
+									incrementOffsets( iv, dv0 );
+								}
+								incrementOffsets( iv, dv1 );
+							}
+							incrementOffsets( iv, dv2 );
+						}
+						incrementOffsets( iv, dv3 );
+					}
+					incrementOffsets( iv, dv4 );
+				}
+				incrementOffsets( iv, dv5 );
+			}
+			incrementOffsets( iv, dv6 );
+		}
+		incrementOffsets( iv, dv7 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary8d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d_blocked.js
new file mode 100644
index 000000000000..15ce645370c4
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d_blocked.js
@@ -0,0 +1,383 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements, max-lines-per-function */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary8d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ] ]
+*/
+function blockedbinary8d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var dv7;
+	var ov1;
+	var ov2;
+	var ov3;
+	var ov4;
+	var ov5;
+	var ov6;
+	var ov7;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	ov4 = zeros( N );
+	ov5 = zeros( N );
+	ov6 = zeros( N );
+	ov7 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	dv4 = zeros( N );
+	dv5 = zeros( N );
+	dv6 = zeros( N );
+	dv7 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j7 = sh[7]; j7 > 0; ) {
+		if ( j7 < bsize ) {
+			s7 = j7;
+			j7 = 0;
+		} else {
+			s7 = bsize;
+			j7 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov7[ k ] = ov[k] + ( j7*sv[k][7] );
+		}
+		for ( j6 = sh[6]; j6 > 0; ) {
+			if ( j6 < bsize ) {
+				s6 = j6;
+				j6 = 0;
+			} else {
+				s6 = bsize;
+				j6 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
+				ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
+			}
+			for ( j5 = sh[5]; j5 > 0; ) {
+				if ( j5 < bsize ) {
+					s5 = j5;
+					j5 = 0;
+				} else {
+					s5 = bsize;
+					j5 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
+					ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
+				}
+				for ( j4 = sh[4]; j4 > 0; ) {
+					if ( j4 < bsize ) {
+						s4 = j4;
+						j4 = 0;
+					} else {
+						s4 = bsize;
+						j4 -= bsize;
+					}
+					for ( k = 0; k < N; k++ ) {
+						dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
+						ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
+					}
+					for ( j3 = sh[3]; j3 > 0; ) {
+						if ( j3 < bsize ) {
+							s3 = j3;
+							j3 = 0;
+						} else {
+							s3 = bsize;
+							j3 -= bsize;
+						}
+						for ( k = 0; k < N; k++ ) {
+							dv4[ k ] = sv[k][4] - ( s3*sv[k][3] );
+							ov3[ k ] = ov4[k] + ( j3*sv[k][3] );
+						}
+						for ( j2 = sh[2]; j2 > 0; ) {
+							if ( j2 < bsize ) {
+								s2 = j2;
+								j2 = 0;
+							} else {
+								s2 = bsize;
+								j2 -= bsize;
+							}
+							for ( k = 0; k < N; k++ ) {
+								dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+								ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+							}
+							for ( j1 = sh[1]; j1 > 0; ) {
+								if ( j1 < bsize ) {
+									s1 = j1;
+									j1 = 0;
+								} else {
+									s1 = bsize;
+									j1 -= bsize;
+								}
+								for ( k = 0; k < N; k++ ) {
+									dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+									ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+								}
+								for ( j0 = sh[0]; j0 > 0; ) {
+									if ( j0 < bsize ) {
+										s0 = j0;
+										j0 = 0;
+									} else {
+										s0 = bsize;
+										j0 -= bsize;
+									}
+									// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+									for ( k = 0; k < N; k++ ) {
+										iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+										dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+									}
+									// Iterate over the non-reduced ndarray dimensions...
+									for ( i7 = 0; i7 < s7; i7++ ) {
+										for ( i6 = 0; i6 < s6; i6++ ) {
+											for ( i5 = 0; i5 < s5; i5++ ) {
+												for ( i4 = 0; i4 < s4; i4++ ) {
+													for ( i3 = 0; i3 < s3; i3++ ) {
+														for ( i2 = 0; i2 < s2; i2++ ) {
+															for ( i1 = 0; i1 < s1; i1++ ) {
+																for ( i0 = 0; i0 < s0; i0++ ) {
+																	setViewOffsets( views, iv );
+																	v[ 0 ] = strategyX( views[ 0 ] );
+																	v[ 1 ] = strategyY( views[ 1 ] );
+																	zbuf[ iv[2] ] = fcn( v, opts );
+																	incrementOffsets( iv, dv0 );
+																}
+																incrementOffsets( iv, dv1 );
+															}
+															incrementOffsets( iv, dv2 );
+														}
+														incrementOffsets( iv, dv3 );
+													}
+													incrementOffsets( iv, dv4 );
+												}
+												incrementOffsets( iv, dv5 );
+											}
+											incrementOffsets( iv, dv6 );
+										}
+										incrementOffsets( iv, dv7 );
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary8d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d_blocked_accessors.js
new file mode 100644
index 000000000000..0bce22b92563
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/8d_blocked_accessors.js
@@ -0,0 +1,392 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements, max-lines-per-function */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary8d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ] ]
+*/
+function blockedbinary8d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var dv7;
+	var ov1;
+	var ov2;
+	var ov3;
+	var ov4;
+	var ov5;
+	var ov6;
+	var ov7;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	ov4 = zeros( N );
+	ov5 = zeros( N );
+	ov6 = zeros( N );
+	ov7 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	dv4 = zeros( N );
+	dv5 = zeros( N );
+	dv6 = zeros( N );
+	dv7 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j7 = sh[7]; j7 > 0; ) {
+		if ( j7 < bsize ) {
+			s7 = j7;
+			j7 = 0;
+		} else {
+			s7 = bsize;
+			j7 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov7[ k ] = ov[k] + ( j7*sv[k][7] );
+		}
+		for ( j6 = sh[6]; j6 > 0; ) {
+			if ( j6 < bsize ) {
+				s6 = j6;
+				j6 = 0;
+			} else {
+				s6 = bsize;
+				j6 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
+				ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
+			}
+			for ( j5 = sh[5]; j5 > 0; ) {
+				if ( j5 < bsize ) {
+					s5 = j5;
+					j5 = 0;
+				} else {
+					s5 = bsize;
+					j5 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
+					ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
+				}
+				for ( j4 = sh[4]; j4 > 0; ) {
+					if ( j4 < bsize ) {
+						s4 = j4;
+						j4 = 0;
+					} else {
+						s4 = bsize;
+						j4 -= bsize;
+					}
+					for ( k = 0; k < N; k++ ) {
+						dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
+						ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
+					}
+					for ( j3 = sh[3]; j3 > 0; ) {
+						if ( j3 < bsize ) {
+							s3 = j3;
+							j3 = 0;
+						} else {
+							s3 = bsize;
+							j3 -= bsize;
+						}
+						for ( k = 0; k < N; k++ ) {
+							dv4[ k ] = sv[k][4] - ( s3*sv[k][3] );
+							ov3[ k ] = ov4[k] + ( j3*sv[k][3] );
+						}
+						for ( j2 = sh[2]; j2 > 0; ) {
+							if ( j2 < bsize ) {
+								s2 = j2;
+								j2 = 0;
+							} else {
+								s2 = bsize;
+								j2 -= bsize;
+							}
+							for ( k = 0; k < N; k++ ) {
+								dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+								ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+							}
+							for ( j1 = sh[1]; j1 > 0; ) {
+								if ( j1 < bsize ) {
+									s1 = j1;
+									j1 = 0;
+								} else {
+									s1 = bsize;
+									j1 -= bsize;
+								}
+								for ( k = 0; k < N; k++ ) {
+									dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+									ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+								}
+								for ( j0 = sh[0]; j0 > 0; ) {
+									if ( j0 < bsize ) {
+										s0 = j0;
+										j0 = 0;
+									} else {
+										s0 = bsize;
+										j0 -= bsize;
+									}
+									// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+									for ( k = 0; k < N; k++ ) {
+										iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+										dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+									}
+									// Iterate over the non-reduced ndarray dimensions...
+									for ( i7 = 0; i7 < s7; i7++ ) {
+										for ( i6 = 0; i6 < s6; i6++ ) {
+											for ( i5 = 0; i5 < s5; i5++ ) {
+												for ( i4 = 0; i4 < s4; i4++ ) {
+													for ( i3 = 0; i3 < s3; i3++ ) {
+														for ( i2 = 0; i2 < s2; i2++ ) {
+															for ( i1 = 0; i1 < s1; i1++ ) {
+																for ( i0 = 0; i0 < s0; i0++ ) {
+																	setViewOffsets( views, iv );
+																	v[ 0 ] = strategyX( views[ 0 ] );
+																	v[ 1 ] = strategyY( views[ 1 ] );
+																	set( zbuf, iv[ 2 ], fcn( v, opts ) );
+																	incrementOffsets( iv, dv0 );
+																}
+																incrementOffsets( iv, dv1 );
+															}
+															incrementOffsets( iv, dv2 );
+														}
+														incrementOffsets( iv, dv3 );
+													}
+													incrementOffsets( iv, dv4 );
+												}
+												incrementOffsets( iv, dv5 );
+											}
+											incrementOffsets( iv, dv6 );
+										}
+										incrementOffsets( iv, dv7 );
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary8d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d.js
new file mode 100644
index 000000000000..383311ddd35f
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d.js
@@ -0,0 +1,347 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary9d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ] ] ]
+*/
+function binary9d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var dv7;
+	var dv8;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var S8;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 8 ];
+		S1 = sh[ 7 ];
+		S2 = sh[ 6 ];
+		S3 = sh[ 5 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 3 ];
+		S6 = sh[ 2 ];
+		S7 = sh[ 1 ];
+		S8 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[8],
+			stridesY[8]
+		];
+		dv1 = [
+			stridesX[7] - ( S0*stridesX[8] ),
+			stridesY[7] - ( S0*stridesY[8] )
+		];
+		dv2 = [
+			stridesX[6] - ( S1*stridesX[7] ),
+			stridesY[6] - ( S1*stridesY[7] )
+		];
+		dv3 = [
+			stridesX[5] - ( S2*stridesX[6] ),
+			stridesY[5] - ( S2*stridesY[6] )
+		];
+		dv4 = [
+			stridesX[4] - ( S3*stridesX[5] ),
+			stridesY[4] - ( S3*stridesY[5] )
+		];
+		dv5 = [
+			stridesX[3] - ( S4*stridesX[4] ),
+			stridesY[3] - ( S4*stridesY[4] )
+		];
+		dv6 = [
+			stridesX[2] - ( S5*stridesX[3] ),
+			stridesY[2] - ( S5*stridesY[3] )
+		];
+		dv7 = [
+			stridesX[1] - ( S6*stridesX[2] ),
+			stridesY[1] - ( S6*stridesY[2] )
+		];
+		dv8 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S7*stridesX[1] ),
+			stridesY[0] - ( S7*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[8] );
+			dv1.push( sv[7] - ( S0*sv[8] ) );
+			dv2.push( sv[6] - ( S1*sv[7] ) );
+			dv3.push( sv[5] - ( S2*sv[6] ) );
+			dv4.push( sv[4] - ( S3*sv[5] ) );
+			dv5.push( sv[3] - ( S4*sv[4] ) );
+			dv6.push( sv[2] - ( S5*sv[3] ) );
+			dv7.push( sv[1] - ( S6*sv[2] ) );
+			dv8.push( sv[0] - ( S7*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		S8 = sh[ 8 ];
+		dv0 = [
+			stridesX[0],
+			stridesY[0]
+		]; // offset increment for innermost loop
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		dv4 = [
+			stridesX[4] - ( S3*stridesX[3] ),
+			stridesY[4] - ( S3*stridesY[3] )
+		];
+		dv5 = [
+			stridesX[5] - ( S4*stridesX[4] ),
+			stridesY[5] - ( S4*stridesY[4] )
+		];
+		dv6 = [
+			stridesX[6] - ( S5*stridesX[5] ),
+			stridesY[6] - ( S5*stridesY[5] )
+		];
+		dv7 = [
+			stridesX[7] - ( S6*stridesX[6] ),
+			stridesY[7] - ( S6*stridesY[6] )
+		];
+		dv8 = [                                   // offset increment for outermost loop
+			stridesX[8] - ( S7*stridesX[7] ),
+			stridesY[8] - ( S7*stridesY[7] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+			dv4.push( sv[4] - ( S3*sv[3] ) );
+			dv5.push( sv[5] - ( S4*sv[4] ) );
+			dv6.push( sv[6] - ( S5*sv[5] ) );
+			dv7.push( sv[7] - ( S6*sv[6] ) );
+			dv8.push( sv[8] - ( S7*sv[7] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i8 = 0; i8 < S8; i8++ ) {
+		for ( i7 = 0; i7 < S7; i7++ ) {
+			for ( i6 = 0; i6 < S6; i6++ ) {
+				for ( i5 = 0; i5 < S5; i5++ ) {
+					for ( i4 = 0; i4 < S4; i4++ ) {
+						for ( i3 = 0; i3 < S3; i3++ ) {
+							for ( i2 = 0; i2 < S2; i2++ ) {
+								for ( i1 = 0; i1 < S1; i1++ ) {
+									for ( i0 = 0; i0 < S0; i0++ ) {
+										setViewOffsets( views, iv );
+										v[ 0 ] = strategyX( views[ 0 ] );
+										v[ 1 ] = strategyY( views[ 1 ] );
+										zbuf[ iv[2] ] = fcn( v, opts );
+										incrementOffsets( iv, dv0 );
+									}
+									incrementOffsets( iv, dv1 );
+								}
+								incrementOffsets( iv, dv2 );
+							}
+							incrementOffsets( iv, dv3 );
+						}
+						incrementOffsets( iv, dv4 );
+					}
+					incrementOffsets( iv, dv5 );
+				}
+				incrementOffsets( iv, dv6 );
+			}
+			incrementOffsets( iv, dv7 );
+		}
+		incrementOffsets( iv, dv8 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary9d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d_accessors.js
new file mode 100644
index 000000000000..abab07440ee8
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d_accessors.js
@@ -0,0 +1,356 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements */
+
+'use strict';
+
+// MODULES //
+
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binary9d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 12, 12, 4 ], true, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ] ] ]
+*/
+function binary9d( fcn, arrays, views, stridesX, stridesY, isRowMajor, strategyX, strategyY, opts ) {
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var dv7;
+	var dv8;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var S8;
+	var sv;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var z;
+	var v;
+	var i;
+
+	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 8 ];
+		S1 = sh[ 7 ];
+		S2 = sh[ 6 ];
+		S3 = sh[ 5 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 3 ];
+		S6 = sh[ 2 ];
+		S7 = sh[ 1 ];
+		S8 = sh[ 0 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[8],
+			stridesY[8]
+		];
+		dv1 = [
+			stridesX[7] - ( S0*stridesX[8] ),
+			stridesY[7] - ( S0*stridesY[8] )
+		];
+		dv2 = [
+			stridesX[6] - ( S1*stridesX[7] ),
+			stridesY[6] - ( S1*stridesY[7] )
+		];
+		dv3 = [
+			stridesX[5] - ( S2*stridesX[6] ),
+			stridesY[5] - ( S2*stridesY[6] )
+		];
+		dv4 = [
+			stridesX[4] - ( S3*stridesX[5] ),
+			stridesY[4] - ( S3*stridesY[5] )
+		];
+		dv5 = [
+			stridesX[3] - ( S4*stridesX[4] ),
+			stridesY[3] - ( S4*stridesY[4] )
+		];
+		dv6 = [
+			stridesX[2] - ( S5*stridesX[3] ),
+			stridesY[2] - ( S5*stridesY[3] )
+		];
+		dv7 = [
+			stridesX[1] - ( S6*stridesX[2] ),
+			stridesY[1] - ( S6*stridesY[2] )
+		];
+		dv8 = [                                   // offset increment for outermost loop
+			stridesX[0] - ( S7*stridesX[1] ),
+			stridesY[0] - ( S7*stridesY[1] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[8] );
+			dv1.push( sv[7] - ( S0*sv[8] ) );
+			dv2.push( sv[6] - ( S1*sv[7] ) );
+			dv3.push( sv[5] - ( S2*sv[6] ) );
+			dv4.push( sv[4] - ( S3*sv[5] ) );
+			dv5.push( sv[3] - ( S4*sv[4] ) );
+			dv6.push( sv[2] - ( S5*sv[3] ) );
+			dv7.push( sv[1] - ( S6*sv[2] ) );
+			dv8.push( sv[0] - ( S7*sv[1] ) );
+		}
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		S8 = sh[ 8 ];
+		dv0 = [                                   // offset increment for innermost loop
+			stridesX[0],
+			stridesY[0]
+		];
+		dv1 = [
+			stridesX[1] - ( S0*stridesX[0] ),
+			stridesY[1] - ( S0*stridesY[0] )
+		];
+		dv2 = [
+			stridesX[2] - ( S1*stridesX[1] ),
+			stridesY[2] - ( S1*stridesY[1] )
+		];
+		dv3 = [
+			stridesX[3] - ( S2*stridesX[2] ),
+			stridesY[3] - ( S2*stridesY[2] )
+		];
+		dv4 = [
+			stridesX[4] - ( S3*stridesX[3] ),
+			stridesY[4] - ( S3*stridesY[3] )
+		];
+		dv5 = [
+			stridesX[5] - ( S4*stridesX[4] ),
+			stridesY[5] - ( S4*stridesY[4] )
+		];
+		dv6 = [
+			stridesX[6] - ( S5*stridesX[5] ),
+			stridesY[6] - ( S5*stridesY[5] )
+		];
+		dv7 = [
+			stridesX[7] - ( S6*stridesX[6] ),
+			stridesY[7] - ( S6*stridesY[6] )
+		];
+		dv8 = [                                   // offset increment for outermost loop
+			stridesX[8] - ( S7*stridesX[7] ),
+			stridesY[8] - ( S7*stridesY[7] )
+		];
+		for ( i = 2; i < arrays.length; i++ ) {
+			sv = arrays[ i ].strides;
+			dv0.push( sv[0] );
+			dv1.push( sv[1] - ( S0*sv[0] ) );
+			dv2.push( sv[2] - ( S1*sv[1] ) );
+			dv3.push( sv[3] - ( S2*sv[2] ) );
+			dv4.push( sv[4] - ( S3*sv[3] ) );
+			dv5.push( sv[5] - ( S4*sv[4] ) );
+			dv6.push( sv[6] - ( S5*sv[5] ) );
+			dv7.push( sv[7] - ( S6*sv[6] ) );
+			dv8.push( sv[8] - ( S7*sv[7] ) );
+		}
+	}
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Iterate over the non-reduced ndarray dimensions...
+	for ( i8 = 0; i8 < S8; i8++ ) {
+		for ( i7 = 0; i7 < S7; i7++ ) {
+			for ( i6 = 0; i6 < S6; i6++ ) {
+				for ( i5 = 0; i5 < S5; i5++ ) {
+					for ( i4 = 0; i4 < S4; i4++ ) {
+						for ( i3 = 0; i3 < S3; i3++ ) {
+							for ( i2 = 0; i2 < S2; i2++ ) {
+								for ( i1 = 0; i1 < S1; i1++ ) {
+									for ( i0 = 0; i0 < S0; i0++ ) {
+										setViewOffsets( views, iv );
+										v[ 0 ] = strategyX( views[ 0 ] );
+										v[ 1 ] = strategyY( views[ 1 ] );
+										set( zbuf, iv[ 2 ], fcn( v, opts ) );
+										incrementOffsets( iv, dv0 );
+									}
+									incrementOffsets( iv, dv1 );
+								}
+								incrementOffsets( iv, dv2 );
+							}
+							incrementOffsets( iv, dv3 );
+						}
+						incrementOffsets( iv, dv4 );
+					}
+					incrementOffsets( iv, dv5 );
+				}
+				incrementOffsets( iv, dv6 );
+			}
+			incrementOffsets( iv, dv7 );
+		}
+		incrementOffsets( iv, dv8 );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binary9d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d_blocked.js
new file mode 100644
index 000000000000..434b5ce55c20
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d_blocked.js
@@ -0,0 +1,406 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements, max-lines-per-function */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary9d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ] ] ]
+*/
+function blockedbinary9d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var dv7;
+	var dv8;
+	var ov1;
+	var ov2;
+	var ov3;
+	var ov4;
+	var ov5;
+	var ov6;
+	var ov7;
+	var ov8;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var s8;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var j8;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	ov4 = zeros( N );
+	ov5 = zeros( N );
+	ov6 = zeros( N );
+	ov7 = zeros( N );
+	ov8 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	dv4 = zeros( N );
+	dv5 = zeros( N );
+	dv6 = zeros( N );
+	dv7 = zeros( N );
+	dv8 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j8 = sh[8]; j8 > 0; ) {
+		if ( j8 < bsize ) {
+			s8 = j8;
+			j8 = 0;
+		} else {
+			s8 = bsize;
+			j8 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov8[ k ] = ov[k] + ( j8*sv[k][8] );
+		}
+		for ( j7 = sh[7]; j7 > 0; ) {
+			if ( j7 < bsize ) {
+				s7 = j7;
+				j7 = 0;
+			} else {
+				s7 = bsize;
+				j7 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				dv8[ k ] = sv[k][8] - ( s7*sv[k][7] );
+				ov7[ k ] = ov8[k] + ( j7*sv[k][7] );
+			}
+			for ( j6 = sh[6]; j6 > 0; ) {
+				if ( j6 < bsize ) {
+					s6 = j6;
+					j6 = 0;
+				} else {
+					s6 = bsize;
+					j6 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
+					ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
+				}
+				for ( j5 = sh[5]; j5 > 0; ) {
+					if ( j5 < bsize ) {
+						s5 = j5;
+						j5 = 0;
+					} else {
+						s5 = bsize;
+						j5 -= bsize;
+					}
+					for ( k = 0; k < N; k++ ) {
+						dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
+						ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
+					}
+					for ( j4 = sh[4]; j4 > 0; ) {
+						if ( j4 < bsize ) {
+							s4 = j4;
+							j4 = 0;
+						} else {
+							s4 = bsize;
+							j4 -= bsize;
+						}
+						for ( k = 0; k < N; k++ ) {
+							dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
+							ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
+						}
+						for ( j3 = sh[3]; j3 > 0; ) {
+							if ( j3 < bsize ) {
+								s3 = j3;
+								j3 = 0;
+							} else {
+								s3 = bsize;
+								j3 -= bsize;
+							}
+							for ( k = 0; k < N; k++ ) {
+								dv4[ k ] = sv[k][4] - ( s3*sv[k][3] );
+								ov3[ k ] = ov4[k] + ( j3*sv[k][3] );
+							}
+							for ( j2 = sh[2]; j2 > 0; ) {
+								if ( j2 < bsize ) {
+									s2 = j2;
+									j2 = 0;
+								} else {
+									s2 = bsize;
+									j2 -= bsize;
+								}
+								for ( k = 0; k < N; k++ ) {
+									dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+									ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+								}
+								for ( j1 = sh[1]; j1 > 0; ) {
+									if ( j1 < bsize ) {
+										s1 = j1;
+										j1 = 0;
+									} else {
+										s1 = bsize;
+										j1 -= bsize;
+									}
+									for ( k = 0; k < N; k++ ) {
+										dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+										ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+									}
+									for ( j0 = sh[0]; j0 > 0; ) {
+										if ( j0 < bsize ) {
+											s0 = j0;
+											j0 = 0;
+										} else {
+											s0 = bsize;
+											j0 -= bsize;
+										}
+										// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+										for ( k = 0; k < N; k++ ) {
+											iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+											dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+										}
+										// Iterate over the non-reduced ndarray dimensions...
+										for ( i8 = 0; i8 < s8; i8++ ) {
+											for ( i7 = 0; i7 < s7; i7++ ) {
+												for ( i6 = 0; i6 < s6; i6++ ) {
+													for ( i5 = 0; i5 < s5; i5++ ) {
+														for ( i4 = 0; i4 < s4; i4++ ) {
+															for ( i3 = 0; i3 < s3; i3++ ) {
+																for ( i2 = 0; i2 < s2; i2++ ) {
+																	for ( i1 = 0; i1 < s1; i1++ ) {
+																		for ( i0 = 0; i0 < s0; i0++ ) {
+																			setViewOffsets( views, iv );
+																			v[ 0 ] = strategyX( views[ 0 ] );
+																			v[ 1 ] = strategyY( views[ 1 ] );
+																			zbuf[ iv[2] ] = fcn( v, opts );
+																			incrementOffsets( iv, dv0 );
+																		}
+																		incrementOffsets( iv, dv1 );
+																	}
+																	incrementOffsets( iv, dv2 );
+																}
+																incrementOffsets( iv, dv3 );
+															}
+															incrementOffsets( iv, dv4 );
+														}
+														incrementOffsets( iv, dv5 );
+													}
+													incrementOffsets( iv, dv6 );
+												}
+												incrementOffsets( iv, dv7 );
+											}
+											incrementOffsets( iv, dv8 );
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary9d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d_blocked_accessors.js
new file mode 100644
index 000000000000..586062c0212d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/9d_blocked_accessors.js
@@ -0,0 +1,415 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-depth, max-len, max-statements, max-lines-per-function */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/binary-tiling-block-size' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var incrementOffsets = require( './increment_offsets.js' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray via loop blocking.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {IntegerArray} stridesX - loop dimension strides for the first input ndarray
+* @param {IntegerArray} stridesY - loop dimension strides for the second input ndarray
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var ysh = [ 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+* var zsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 12, 4, 2, 1 ];
+* var sz = [ 3, 3, 3, 3, 3, 3, 3, 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* blockedbinary9d( gdot, [ x, y, z ], views, [ 12, 12, 12, 12, 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 12, 12, 12, 12, 4 ], strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ [ [ [ [ [ [ 30.0, 174.0, 446.0 ] ] ] ] ] ] ] ] ]
+*/
+function blockedbinary9d( fcn, arrays, views, stridesX, stridesY, strategyX, strategyY, opts ) {
+	var bsize;
+	var zbuf;
+	var set;
+	var dv0;
+	var dv1;
+	var dv2;
+	var dv3;
+	var dv4;
+	var dv5;
+	var dv6;
+	var dv7;
+	var dv8;
+	var ov1;
+	var ov2;
+	var ov3;
+	var ov4;
+	var ov5;
+	var ov6;
+	var ov7;
+	var ov8;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var s8;
+	var sv;
+	var ov;
+	var iv;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var j8;
+	var N;
+	var o;
+	var x;
+	var y;
+	var z;
+	var v;
+	var k;
+
+	// Note on variable naming convention: S#, dv#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	N = arrays.length;
+	x = arrays[ 0 ];
+	y = arrays[ 1 ];
+	z = arrays[ 2 ];
+
+	// Resolve the loop interchange order:
+	o = loopOrder( z.shape, stridesX, stridesY, z.strides );
+	sh = o.sh;
+	sv = [ o.sx, o.sy, o.sz ];
+	for ( k = 3; k < N; k++ ) {
+		sv.push( takeIndexed( arrays[k].strides, o.idx ) );
+	}
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	ov = offsets( arrays );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Cache offset increments for the innermost loop...
+	dv0 = [];
+	for ( k = 0; k < N; k++ ) {
+		dv0.push( sv[k][0] );
+	}
+	// Initialize loop variables...
+	ov1 = zeros( N );
+	ov2 = zeros( N );
+	ov3 = zeros( N );
+	ov4 = zeros( N );
+	ov5 = zeros( N );
+	ov6 = zeros( N );
+	ov7 = zeros( N );
+	ov8 = zeros( N );
+	dv1 = zeros( N );
+	dv2 = zeros( N );
+	dv3 = zeros( N );
+	dv4 = zeros( N );
+	dv5 = zeros( N );
+	dv6 = zeros( N );
+	dv7 = zeros( N );
+	dv8 = zeros( N );
+	iv = zeros( N );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Iterate over blocks...
+	for ( j8 = sh[8]; j8 > 0; ) {
+		if ( j8 < bsize ) {
+			s8 = j8;
+			j8 = 0;
+		} else {
+			s8 = bsize;
+			j8 -= bsize;
+		}
+		for ( k = 0; k < N; k++ ) {
+			ov8[ k ] = ov[k] + ( j8*sv[k][8] );
+		}
+		for ( j7 = sh[7]; j7 > 0; ) {
+			if ( j7 < bsize ) {
+				s7 = j7;
+				j7 = 0;
+			} else {
+				s7 = bsize;
+				j7 -= bsize;
+			}
+			for ( k = 0; k < N; k++ ) {
+				dv8[ k ] = sv[k][8] - ( s7*sv[k][7] );
+				ov7[ k ] = ov8[k] + ( j7*sv[k][7] );
+			}
+			for ( j6 = sh[6]; j6 > 0; ) {
+				if ( j6 < bsize ) {
+					s6 = j6;
+					j6 = 0;
+				} else {
+					s6 = bsize;
+					j6 -= bsize;
+				}
+				for ( k = 0; k < N; k++ ) {
+					dv7[ k ] = sv[k][7] - ( s6*sv[k][6] );
+					ov6[ k ] = ov7[k] + ( j6*sv[k][6] );
+				}
+				for ( j5 = sh[5]; j5 > 0; ) {
+					if ( j5 < bsize ) {
+						s5 = j5;
+						j5 = 0;
+					} else {
+						s5 = bsize;
+						j5 -= bsize;
+					}
+					for ( k = 0; k < N; k++ ) {
+						dv6[ k ] = sv[k][6] - ( s5*sv[k][5] );
+						ov5[ k ] = ov6[k] + ( j5*sv[k][5] );
+					}
+					for ( j4 = sh[4]; j4 > 0; ) {
+						if ( j4 < bsize ) {
+							s4 = j4;
+							j4 = 0;
+						} else {
+							s4 = bsize;
+							j4 -= bsize;
+						}
+						for ( k = 0; k < N; k++ ) {
+							dv5[ k ] = sv[k][5] - ( s4*sv[k][4] );
+							ov4[ k ] = ov5[k] + ( j4*sv[k][4] );
+						}
+						for ( j3 = sh[3]; j3 > 0; ) {
+							if ( j3 < bsize ) {
+								s3 = j3;
+								j3 = 0;
+							} else {
+								s3 = bsize;
+								j3 -= bsize;
+							}
+							for ( k = 0; k < N; k++ ) {
+								dv4[ k ] = sv[k][4] - ( s3*sv[k][3] );
+								ov3[ k ] = ov4[k] + ( j3*sv[k][3] );
+							}
+							for ( j2 = sh[2]; j2 > 0; ) {
+								if ( j2 < bsize ) {
+									s2 = j2;
+									j2 = 0;
+								} else {
+									s2 = bsize;
+									j2 -= bsize;
+								}
+								for ( k = 0; k < N; k++ ) {
+									dv3[ k ] = sv[k][3] - ( s2*sv[k][2] );
+									ov2[ k ] = ov3[k] + ( j2*sv[k][2] );
+								}
+								for ( j1 = sh[1]; j1 > 0; ) {
+									if ( j1 < bsize ) {
+										s1 = j1;
+										j1 = 0;
+									} else {
+										s1 = bsize;
+										j1 -= bsize;
+									}
+									for ( k = 0; k < N; k++ ) {
+										dv2[ k ] = sv[k][2] - ( s1*sv[k][1] );
+										ov1[ k ] = ov2[k] + ( j1*sv[k][1] );
+									}
+									for ( j0 = sh[0]; j0 > 0; ) {
+										if ( j0 < bsize ) {
+											s0 = j0;
+											j0 = 0;
+										} else {
+											s0 = bsize;
+											j0 -= bsize;
+										}
+										// Compute index offsets and loop offset increments for the first ndarray elements in the current block...
+										for ( k = 0; k < N; k++ ) {
+											iv[ k ] = ov1[k] + ( j0*sv[k][0] );
+											dv1[ k ] = sv[k][1] - ( s0*sv[k][0] );
+										}
+										// Iterate over the non-reduced ndarray dimensions...
+										for ( i8 = 0; i8 < s8; i8++ ) {
+											for ( i7 = 0; i7 < s7; i7++ ) {
+												for ( i6 = 0; i6 < s6; i6++ ) {
+													for ( i5 = 0; i5 < s5; i5++ ) {
+														for ( i4 = 0; i4 < s4; i4++ ) {
+															for ( i3 = 0; i3 < s3; i3++ ) {
+																for ( i2 = 0; i2 < s2; i2++ ) {
+																	for ( i1 = 0; i1 < s1; i1++ ) {
+																		for ( i0 = 0; i0 < s0; i0++ ) {
+																			setViewOffsets( views, iv );
+																			v[ 0 ] = strategyX( views[ 0 ] );
+																			v[ 1 ] = strategyY( views[ 1 ] );
+																			set( zbuf, iv[ 2 ], fcn( v, opts ) );
+																			incrementOffsets( iv, dv0 );
+																		}
+																		incrementOffsets( iv, dv1 );
+																	}
+																	incrementOffsets( iv, dv2 );
+																}
+																incrementOffsets( iv, dv3 );
+															}
+															incrementOffsets( iv, dv4 );
+														}
+														incrementOffsets( iv, dv5 );
+													}
+													incrementOffsets( iv, dv6 );
+												}
+												incrementOffsets( iv, dv7 );
+											}
+											incrementOffsets( iv, dv8 );
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedbinary9d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/factory.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/factory.js
new file mode 100644
index 000000000000..df990d5a9b6f
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/factory.js
@@ -0,0 +1,133 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var isFunction = require( '@stdlib/assert/is-function' );
+var format = require( '@stdlib/string/format' );
+var reduce = require( './main.js' );
+
+
+// MAIN //
+
+/**
+* Return a function for performing a reduction over a list of specified dimensions in two input ndarrays via a one-dimensional strided array binary reduction function and assigning results to a provided output ndarray.
+*
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @throws {TypeError} first argument must be a function
+* @returns {Function} function for performing a reduction
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var getStride = require( '@stdlib/ndarray/base/stride' );
+* var getOffset = require( '@stdlib/ndarray/base/offset' );
+* var getData = require( '@stdlib/ndarray/base/data-buffer' );
+* var numelDimension = require( '@stdlib/ndarray/base/numel-dimension' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 3, 2, 2 ];
+* var ysh = [ 1, 3, 2, 2 ];
+* var zsh = [ 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 4, 2, 1 ];
+* var sy = [ 12, 4, 2, 1 ];
+* var sz = [ 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Create a function for performing a reduction over subarrays:
+* var dot = factory( gdot );
+* // returns <Function>
+*
+* // Perform a reduction:
+* dot( [ x, y, z ], [ 2, 3 ] );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ 30.0, 174.0, 446.0 ] ]
+*/
+function factory( fcn ) {
+	if ( !isFunction( fcn ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be a function. Value: `%s`.', fcn ) );
+	}
+	return reducer;
+
+	/**
+	* Performs a reduction over a list of specified dimensions in two input ndarrays via a one-dimensional strided array binary reduction function and assigns results to a provided output ndarray.
+	*
+	* @private
+	* @param {ArrayLikeObject<Object>} arrays - array-like object containing ndarrays
+	* @param {IntegerArray} dims - list of dimensions over which to perform a reduction
+	* @param {Options} [options] - function options
+	* @returns {void}
+	*/
+	function reducer( arrays, dims, options ) {
+		var opts;
+		if ( arguments.length > 2 ) {
+			opts = options;
+		} else {
+			opts = {};
+		}
+		return reduce( fcn, arrays, dims, opts );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = factory;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/increment_offsets.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/increment_offsets.js
new file mode 100644
index 000000000000..7d525521b721
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/increment_offsets.js
@@ -0,0 +1,46 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MAIN //
+
+/**
+* Increments index offsets according to a list of increments.
+*
+* ## Notes
+*
+* -   This function mutates the list of index offsets.
+*
+* @private
+* @param {NonNegativeIntegerArray} offsets - list of index offsets
+* @param {NonNegativeIntegerArray} inc - list of increments
+* @returns {NonNegativeIntegerArray} updated offsets
+*/
+function incrementOffsets( offsets, inc ) {
+	var i;
+	for ( i = 0; i < offsets.length; i++ ) {
+		offsets[ i ] += inc[ i ];
+	}
+	return offsets;
+}
+
+
+// EXPORTS //
+
+module.exports = incrementOffsets;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/index.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/index.js
new file mode 100644
index 000000000000..66a25b064df5
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/index.js
@@ -0,0 +1,175 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+/**
+* Perform a reduction over a list of specified dimensions in two input ndarrays via a one-dimensional strided array binary reduction function and assign results to a provided output ndarray.
+*
+* @module @stdlib/ndarray/base/binary-reduce-strided1d
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var getStride = require( '@stdlib/ndarray/base/stride' );
+* var getOffset = require( '@stdlib/ndarray/base/offset' );
+* var getData = require( '@stdlib/ndarray/base/data-buffer' );
+* var numelDimension = require( '@stdlib/ndarray/base/numel-dimension' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+* var binaryReduceStrided1d = require( '@stdlib/ndarray/base/binary-reduce-strided1d' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 3, 2, 2 ];
+* var ysh = [ 1, 3, 2, 2 ];
+* var zsh = [ 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 4, 2, 1 ];
+* var sy = [ 12, 4, 2, 1 ];
+* var sz = [ 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Perform a reduction:
+* binaryReduceStrided1d( gdot, [ x, y, z ], [ 2, 3 ] );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ 30.0, 174.0, 446.0 ] ]
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var getStride = require( '@stdlib/ndarray/base/stride' );
+* var getOffset = require( '@stdlib/ndarray/base/offset' );
+* var getData = require( '@stdlib/ndarray/base/data-buffer' );
+* var numelDimension = require( '@stdlib/ndarray/base/numel-dimension' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+* var binaryReduceStrided1d = require( '@stdlib/ndarray/base/binary-reduce-strided1d' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 3, 2, 2 ];
+* var ysh = [ 1, 3, 2, 2 ];
+* var zsh = [ 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 4, 2, 1 ];
+* var sy = [ 12, 4, 2, 1 ];
+* var sz = [ 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Create a function for performing a reduction over subarrays:
+* var dot = binaryReduceStrided1d.factory( gdot );
+* // returns <Function>
+*
+* // Perform a reduction:
+* dot( [ x, y, z ], [ 2, 3 ] );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ 30.0, 174.0, 446.0 ] ]
+*/
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var main = require( './main.js' );
+var factory = require( './factory.js' );
+
+
+// MAIN //
+
+setReadOnly( main, 'factory', factory );
+
+
+// EXPORTS //
+
+module.exports = main;
+
+// exports: { "factory": "main.factory" }
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/initialize_array_views.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/initialize_array_views.js
new file mode 100644
index 000000000000..3e7eadf96e79
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/initialize_array_views.js
@@ -0,0 +1,57 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MAIN //
+
+/**
+* Initialize ndarray-like objects for representing zero-dimensional sub-array views of ancillary ndarray arguments.
+*
+* ## Notes
+*
+* -   This function ignores the first three ndarray-like objects, which are assumed to be two input ndarrays and one output ndarray, respectively.
+* -   This function mutates the provided output array.
+*
+* @private
+* @param {ArrayLikeObject<Object>} arrays - list of ndarray-like objects
+* @param {Array<Object>} out - output array
+* @returns {Array<Object>} output array
+*/
+function initializeViews( arrays, out ) {
+	var v;
+	var i;
+
+	for ( i = 3; i < arrays.length; i++ ) {
+		v = arrays[ i ];
+		out.push({
+			'dtype': v.dtype,
+			'data': v.data,
+			'shape': [],
+			'strides': [ 0 ],
+			'offset': v.offset,
+			'order': v.order
+		});
+	}
+	return out;
+}
+
+
+// EXPORTS //
+
+module.exports = initializeViews;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/main.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/main.js
new file mode 100644
index 000000000000..0b0a4afe0c7c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/main.js
@@ -0,0 +1,573 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var ndarray2object = require( '@stdlib/ndarray/base/ndarraylike2object' );
+var normalizeIndices = require( '@stdlib/ndarray/base/to-unique-normalized-indices' );
+var indicesComplement = require( '@stdlib/array/base/indices-complement' );
+var takeIndexed2 = require( '@stdlib/array/base/take-indexed2' );
+var iterationOrder = require( '@stdlib/ndarray/base/iteration-order' );
+var strides2order = require( '@stdlib/ndarray/base/strides2order' );
+var anyIsEntryIn = require( '@stdlib/array/base/any-is-entry-in' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var join = require( '@stdlib/array/base/join' );
+var format = require( '@stdlib/string/format' );
+var initializeViews = require( './initialize_array_views.js' );
+var reshapeStrategy = require( './reshape_strategy.js' );
+var blockedaccessorbinary2d = require( './2d_blocked_accessors.js' );
+var blockedaccessorbinary3d = require( './3d_blocked_accessors.js' );
+var blockedaccessorbinary4d = require( './4d_blocked_accessors.js' );
+var blockedaccessorbinary5d = require( './5d_blocked_accessors.js' );
+var blockedaccessorbinary6d = require( './6d_blocked_accessors.js' );
+var blockedaccessorbinary7d = require( './7d_blocked_accessors.js' );
+var blockedaccessorbinary8d = require( './8d_blocked_accessors.js' );
+var blockedaccessorbinary9d = require( './9d_blocked_accessors.js' );
+var blockedaccessorbinary10d = require( './10d_blocked_accessors.js' );
+var blockedbinary2d = require( './2d_blocked.js' );
+var blockedbinary3d = require( './3d_blocked.js' );
+var blockedbinary4d = require( './4d_blocked.js' );
+var blockedbinary5d = require( './5d_blocked.js' );
+var blockedbinary6d = require( './6d_blocked.js' );
+var blockedbinary7d = require( './7d_blocked.js' );
+var blockedbinary8d = require( './8d_blocked.js' );
+var blockedbinary9d = require( './9d_blocked.js' );
+var blockedbinary10d = require( './10d_blocked.js' );
+var accessorbinary0d = require( './0d_accessors.js' );
+var accessorbinary1d = require( './1d_accessors.js' );
+var accessorbinary2d = require( './2d_accessors.js' );
+var accessorbinary3d = require( './3d_accessors.js' );
+var accessorbinary4d = require( './4d_accessors.js' );
+var accessorbinary5d = require( './5d_accessors.js' );
+var accessorbinary6d = require( './6d_accessors.js' );
+var accessorbinary7d = require( './7d_accessors.js' );
+var accessorbinary8d = require( './8d_accessors.js' );
+var accessorbinary9d = require( './9d_accessors.js' );
+var accessorbinary10d = require( './10d_accessors.js' );
+var accessorbinarynd = require( './nd_accessors.js' );
+var binary0d = require( './0d.js' );
+var binary1d = require( './1d.js' );
+var binary2d = require( './2d.js' );
+var binary3d = require( './3d.js' );
+var binary4d = require( './4d.js' );
+var binary5d = require( './5d.js' );
+var binary6d = require( './6d.js' );
+var binary7d = require( './7d.js' );
+var binary8d = require( './8d.js' );
+var binary9d = require( './9d.js' );
+var binary10d = require( './10d.js' );
+var binarynd = require( './nd.js' );
+
+
+// VARIABLES //
+
+var BINARY = [
+	binary0d,
+	binary1d,
+	binary2d,
+	binary3d,
+	binary4d,
+	binary5d,
+	binary6d,
+	binary7d,
+	binary8d,
+	binary9d,
+	binary10d
+];
+var ACCESSOR_BINARY = [
+	accessorbinary0d,
+	accessorbinary1d,
+	accessorbinary2d,
+	accessorbinary3d,
+	accessorbinary4d,
+	accessorbinary5d,
+	accessorbinary6d,
+	accessorbinary7d,
+	accessorbinary8d,
+	accessorbinary9d,
+	accessorbinary10d
+];
+var BLOCKED_BINARY = [
+	blockedbinary2d, // 0
+	blockedbinary3d,
+	blockedbinary4d,
+	blockedbinary5d,
+	blockedbinary6d,
+	blockedbinary7d,
+	blockedbinary8d,
+	blockedbinary9d,
+	blockedbinary10d // 8
+];
+var BLOCKED_ACCESSOR_BINARY = [
+	blockedaccessorbinary2d, // 0
+	blockedaccessorbinary3d,
+	blockedaccessorbinary4d,
+	blockedaccessorbinary5d,
+	blockedaccessorbinary6d,
+	blockedaccessorbinary7d,
+	blockedaccessorbinary8d,
+	blockedaccessorbinary9d,
+	blockedaccessorbinary10d // 8
+];
+var MAX_DIMS = BINARY.length - 1;
+
+
+// FUNCTIONS //
+
+/**
+* Returns a boolean indicating if at least one ndarray data buffer implements the accessor protocol.
+*
+* @private
+* @param {ndarrayLike} x - first ndarray
+* @param {ndarrayLike} y - second ndarray
+* @param {ndarrayLike} z - third ndarray
+* @returns {boolean} boolean indicating whether an ndarray data buffer implements the accessor protocol
+*/
+function hasAccessors( x, y, z ) {
+	return anyIsEntryIn( [ x, y, z ], 'accessorProtocol', true );
+}
+
+
+// MAIN //
+
+/**
+* Performs a reduction over a list of specified dimensions in two input ndarrays via a one-dimensional strided array binary reduction function and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {ArrayLikeObject<Object>} arrays - array-like object containing ndarrays
+* @param {IntegerArray} dims - list of dimensions over which to perform a reduction
+* @param {Options} [options] - function options
+* @throws {Error} arrays must have the expected number of dimensions
+* @throws {RangeError} dimension indices must not exceed input ndarray bounds
+* @throws {RangeError} number of dimension indices must not exceed the number of input ndarray dimensions
+* @throws {Error} must provide unique dimension indices
+* @throws {Error} arrays must have the same loop dimension sizes
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var getStride = require( '@stdlib/ndarray/base/stride' );
+* var getOffset = require( '@stdlib/ndarray/base/offset' );
+* var getData = require( '@stdlib/ndarray/base/data-buffer' );
+* var numelDimension = require( '@stdlib/ndarray/base/numel-dimension' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 3, 2, 2 ];
+* var ysh = [ 1, 3, 2, 2 ];
+* var zsh = [ 1, 3 ];
+*
+* // Define the array strides:
+* var sx = [ 12, 4, 2, 1 ];
+* var sy = [ 12, 4, 2, 1 ];
+* var sz = [ 3, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Perform a reduction:
+* binaryReduceStrided1d( gdot, [ x, y, z ], [ 2, 3 ] );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ 30.0, 174.0, 446.0 ] ]
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var getStride = require( '@stdlib/ndarray/base/stride' );
+* var getOffset = require( '@stdlib/ndarray/base/offset' );
+* var getData = require( '@stdlib/ndarray/base/data-buffer' );
+* var numelDimension = require( '@stdlib/ndarray/base/numel-dimension' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 1, 3, 2, 2 ];
+* var ysh = [ 1, 3, 2, 2 ];
+* var zsh = [];
+*
+* // Define the array strides:
+* var sx = [ 12, 4, 2, 1 ];
+* var sy = [ 12, 4, 2, 1 ];
+* var sz = [ 0 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Perform a reduction:
+* binaryReduceStrided1d( gdot, [ x, y, z ], [ 0, 1, 2, 3 ] );
+*
+* var v = z.data;
+* // returns <Float64Array>[ 650.0 ]
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var getStride = require( '@stdlib/ndarray/base/stride' );
+* var getOffset = require( '@stdlib/ndarray/base/offset' );
+* var getData = require( '@stdlib/ndarray/base/data-buffer' );
+* var numelDimension = require( '@stdlib/ndarray/base/numel-dimension' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 3, 2, 2 ];
+* var ysh = [ 3, 2, 2 ];
+* var zsh = [ 3, 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 2, 1 ];
+* var sy = [ 4, 2, 1 ];
+* var sz = [ 4, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Perform a reduction:
+* binaryReduceStrided1d( gdot, [ x, y, z ], [] );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ [ [ 1.0, 4.0 ], [ 9.0, 16.0 ] ], [ [ 25.0, 36.0 ], [ 49.0, 64.0 ] ], [ [ 81.0, 100.0 ], [ 121.0, 144.0 ] ] ]
+*/
+function binaryReduceStrided1d( fcn, arrays, dims, options ) { // eslint-disable-line max-statements
+	var strategyX;
+	var strategyY;
+	var views;
+	var ndims;
+	var ldims;
+	var opts;
+	var ordx;
+	var ordy;
+	var ordz;
+	var tmpx;
+	var tmpy;
+	var arr;
+	var len;
+	var shx;
+	var shy;
+	var shc;
+	var shl;
+	var iox;
+	var ioy;
+	var ioz;
+	var scx;
+	var scy;
+	var slx;
+	var sly;
+	var sz;
+	var ns;
+	var d;
+	var s;
+	var N;
+	var M;
+	var K;
+	var x;
+	var y;
+	var z;
+	var i;
+	var j;
+
+	if ( arguments.length > 3 ) {
+		opts = options;
+	} else {
+		opts = {};
+	}
+	// Standardize ndarray meta data...
+	N = arrays.length;
+	arr = [];
+	for ( i = 0; i < N; i++ ) {
+		arr.push( ndarray2object( arrays[ i ] ) );
+	}
+	// Cache references to the input and output arrays:
+	x = arr[ 0 ];
+	y = arr[ 1 ];
+	z = arr[ 2 ];
+
+	// Resolve the number of input array dimensions:
+	shx = x.shape;
+	shy = y.shape;
+	ndims = shx.length;
+
+	// Verify that both input arrays have the same shape:
+	if ( shx.length !== shy.length ) {
+		throw new Error( format( 'invalid argument. Input arrays must have the same number of dimensions. First array dimensions: %d. Second array dimensions: %d.', shx.length, shy.length ) );
+	}
+	for ( i = 0; i < ndims; i++ ) {
+		if ( shx[ i ] !== shy[ i ] ) {
+			throw new Error( format( 'invalid argument. Input arrays must have the same shape. First array shape: [%s]. Second array shape: [%s].', join( shx, ',' ), join( shy, ',' ) ) );
+		}
+	}
+
+	// Verify that we've been provided a list of unique dimension indices...
+	M = dims.length;
+	d = normalizeIndices( dims, ndims-1 );
+	if ( d === null ) {
+		throw new RangeError( format( 'invalid argument. Third argument contains an out-of-bounds dimension index. Value: [%s].', join( dims, ',' ) ) );
+	}
+	d.sort();
+	if ( d.length !== M ) {
+		throw new Error( format( 'invalid argument. Third argument must contain a list of unique dimension indices. Value: [%s].', join( dims, ',' ) ) );
+	}
+	// Check whether we've been provided a valid number of dimensions to reduce...
+	if ( M > ndims ) {
+		throw new RangeError( format( 'invalid argument. Number of specified dimensions cannot exceed the number of dimensions in the input array. Number of dimensions: %d. Value: [%s].', ndims, join( dims, ',' ) ) );
+	}
+	// Verify that provided ndarrays have the expected number of dimensions...
+	K = ndims - M;
+	if ( z.shape.length !== K ) {
+		throw new Error( format( 'invalid argument. Output array must have the same number of non-reduced dimensions as input arrays. Input array shape: [%s]. Number of non-reduced dimensions: %d. Output array shape: [%s].', join( shx, ',' ), K, join( z.shape, ',' ) ) );
+	}
+
+	// Resolve the non-reduced ("loop") dimensions and associated strides:
+	ldims = indicesComplement( shx.length, d );
+	tmpx = takeIndexed2( shx, x.strides, ldims );
+	tmpy = takeIndexed2( shy, y.strides, ldims );
+	shl = tmpx[ 0 ]; // tmpx[ 0 ] == tmpy[ 0 ]
+	slx = tmpx[ 1 ];
+	sly = tmpy[ 1 ];
+
+	// Resolve the reduced ("core") dimensions and associated strides:
+	tmpx = takeIndexed2( shx, x.strides, d );
+	tmpy = takeIndexed2( shy, y.strides, d );
+	shc = tmpx[ 0 ]; // tmpx[ 0 ] == tmpy[ 0 ]
+	scx = tmpx[ 1 ];
+	scy = tmpy[ 1 ];
+
+	// Verify that the provided arrays have the same loop dimensions...
+	len = 1; // number of elements
+	ns = 0;  // number of singleton dimensions
+	for ( i = 0; i < K; i++ ) {
+		s = shl[ i ];
+		for ( j = 2; j < N; j++ ) {
+			if ( s !== arr[ j ].shape[ i ] ) {
+				throw new Error( format( 'invalid argument. Non-reduced dimensions must be consistent across all provided arrays. Input array shape: [%s]. Non-reduced dimension indices: [%s]. Non-reduced dimensions: [%s]. Array shape: [%s] (index: %d).', join( shx, ',' ), join( ldims, ',' ), join( shl, ',' ), join( arr[ j ].shape, ',' ), j ) );
+			}
+		}
+		// Note that, if one of the dimensions is `0`, the length will be `0`...
+		len *= s;
+
+		// Check whether the current dimension is a singleton dimension...
+		if ( s === 1 ) {
+			ns += 1;
+		}
+	}
+	// Check whether we were provided empty ndarrays...
+	if ( len === 0 || ( shc.length && numel( shc ) === 0 ) ) {
+		return;
+	}
+	// Initialize ndarray-like objects for representing sub-array views...
+	views = [
+		{
+			'dtype': x.dtype,
+			'data': x.data,
+			'shape': shc,
+			'strides': scx,
+			'offset': x.offset,
+			'order': x.order
+		},
+		{
+			'dtype': y.dtype,
+			'data': y.data,
+			'shape': shc,
+			'strides': scy,
+			'offset': y.offset,
+			'order': y.order
+		}
+	];
+	initializeViews( arr, views );
+
+	// Determine the strategy for reshaping sub-array views of the input arrays prior to performing a reduction:
+	strategyX = reshapeStrategy( views[ 0 ] );
+	strategyY = reshapeStrategy( views[ 1 ] );
+
+	// Determine whether we can avoid iteration altogether...
+	if ( K === 0 ) {
+		if ( hasAccessors( x, y, z ) ) {
+			return ACCESSOR_BINARY[ K ]( fcn, arr, strategyX, strategyY, opts );
+		}
+		return BINARY[ K ]( fcn, arr, strategyX, strategyY, opts );
+	}
+	// Determine whether we only have one loop dimension and can thus readily perform one-dimensional iteration...
+	if ( K === 1 ) {
+		if ( hasAccessors( x, y, z ) ) {
+			return ACCESSOR_BINARY[ K ]( fcn, arr, views, slx, sly, strategyX, strategyY, opts ); // eslint-disable-line max-len
+		}
+		return BINARY[ K ]( fcn, arr, views, slx, sly, strategyX, strategyY, opts ); // eslint-disable-line max-len
+	}
+	sz = z.strides;
+
+	// Determine whether the loop dimensions have only **one** non-singleton dimension (e.g., shape=[10,1,1,1]) so that we can treat loop iteration as being equivalent to one-dimensional iteration...
+	if ( ns === K-1 ) {
+		// Get the index of the non-singleton dimension...
+		for ( i = 0; i < K; i++ ) {
+			if ( shl[ i ] !== 1 ) {
+				break;
+			}
+		}
+		z.shape = [ shl[i] ];
+		for ( j = 0; j < N; j++ ) {
+			arr[ j ].strides = [ arr[j].strides[i] ];
+		}
+		slx = [ slx[i] ];
+		sly = [ sly[i] ];
+		if ( hasAccessors( x, y, z ) ) {
+			return ACCESSOR_BINARY[ 1 ]( fcn, arr, views, slx, sly, strategyX, strategyY, opts ); // eslint-disable-line max-len
+		}
+		return BINARY[ 1 ]( fcn, arr, views, slx, sly, strategyX, strategyY, opts ); // eslint-disable-line max-len
+	}
+	iox = iterationOrder( slx ); // +/-1
+	ioy = iterationOrder( sly ); // +/-1
+	ioz = iterationOrder( sz ); // +/-1
+
+	// Determine whether we can avoid blocked iteration...
+	ordx = strides2order( slx );
+	ordy = strides2order( sly );
+	ordz = strides2order( sz );
+	if ( iox !== 0 && ioy !== 0 && ioz !== 0 && ordx === ordz && ordy === ordz && K <= MAX_DIMS ) { // eslint-disable-line max-len
+		// So long as iteration for each respective array always moves in the same direction (i.e., no mixed sign strides) and the memory layouts are the same, we can leverage cache-optimal (i.e., normal) nested loops without resorting to blocked iteration...
+		if ( hasAccessors( x, y, z ) ) {
+			return ACCESSOR_BINARY[ K ]( fcn, arr, views, slx, sly, ordx === 1, strategyX, strategyY, opts ); // eslint-disable-line max-len
+		}
+		return BINARY[ K ]( fcn, arr, views, slx, sly, ordx === 1, strategyX, strategyY, opts ); // eslint-disable-line max-len
+	}
+	// At this point, we're either dealing with non-contiguous n-dimensional arrays, high dimensional n-dimensional arrays, and/or arrays having differing memory layouts, so our only hope is that we can still perform blocked iteration...
+
+	// Determine whether we can perform blocked iteration...
+	if ( K <= MAX_DIMS ) {
+		if ( hasAccessors( x, y, z ) ) {
+			return BLOCKED_ACCESSOR_BINARY[ K-2 ]( fcn, arr, views, slx, sly, strategyX, strategyY, opts ); // eslint-disable-line max-len
+		}
+		return BLOCKED_BINARY[ K-2 ]( fcn, arr, views, slx, sly, strategyX, strategyY, opts ); // eslint-disable-line max-len
+	}
+	// Fall-through to linear view iteration without regard for how data is stored in memory (i.e., take the slow path)...
+	if ( hasAccessors( x, y, z ) ) {
+		return accessorbinarynd( fcn, arr, views, strategyX, strategyY, opts );
+	}
+	binarynd( fcn, arr, views, strategyX, strategyY, opts );
+}
+
+
+// EXPORTS //
+
+module.exports = binaryReduceStrided1d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/nd.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/nd.js
new file mode 100644
index 000000000000..d51854cff52e
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/nd.js
@@ -0,0 +1,189 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var numel = require( '@stdlib/ndarray/base/numel' );
+var vind2bind = require( '@stdlib/ndarray/base/vind2bind' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// VARIABLES //
+
+var MODE = 'throw';
+
+
+// MAIN //
+
+/**
+* Performs a reduction over two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 3, 2, 2 ];
+* var ysh = [ 3, 2, 2 ];
+* var zsh = [ 3 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 2, 1 ];
+* var sy = [ 4, 2, 1 ];
+* var sz = [ 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binarynd( gdot, [ x, y, z ], views, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ 30.0, 174.0, 446.0 ]
+*/
+function binarynd( fcn, arrays, views, strategyX, strategyY, opts ) {
+	var zbuf;
+	var len;
+	var arr;
+	var sh;
+	var iv;
+	var io;
+	var N;
+	var z;
+	var v;
+	var i;
+	var j;
+
+	N = arrays.length;
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Compute the total number of elements over which to iterate:
+	len = numel( sh );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Iterate based on the linear **view** index, regardless as to how the data is stored in memory...
+	io = zeros( N );
+	for ( i = 0; i < len; i++ ) {
+		for ( j = 0; j < N; j++ ) {
+			arr = arrays[ j ];
+			io[ j ] = vind2bind( sh, arr.strides, iv[ j ], arr.order, i, MODE );
+		}
+		setViewOffsets( views, io );
+		v[ 0 ] = strategyX( views[ 0 ] );
+		v[ 1 ] = strategyY( views[ 1 ] );
+		zbuf[ io[2] ] = fcn( v, opts );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binarynd;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/nd_accessors.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/nd_accessors.js
new file mode 100644
index 000000000000..b92214e4c93c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/nd_accessors.js
@@ -0,0 +1,198 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var numel = require( '@stdlib/ndarray/base/numel' );
+var vind2bind = require( '@stdlib/ndarray/base/vind2bind' );
+var copyIndexed = require( '@stdlib/array/base/copy-indexed' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var setViewOffsets = require( './set_view_offsets.js' );
+var offsets = require( './offsets.js' );
+
+
+// VARIABLES //
+
+var MODE = 'throw';
+
+
+// MAIN //
+
+/**
+* Performs a reduction over two input ndarrays and assigns results to a provided output ndarray.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array reduction function
+* @param {Array<Object>} arrays - ndarrays
+* @param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
+* @param {Function} strategyX - first input ndarray reshape strategy
+* @param {Function} strategyY - second input ndarray reshape strategy
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+* var accessors = require( '@stdlib/array/base/accessors' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+*
+* // Create data buffers:
+* var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var ybuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
+* var zbuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );
+*
+* // Define the array shapes:
+* var xsh = [ 3, 2, 2 ];
+* var ysh = [ 3, 2, 2 ];
+* var zsh = [ 3 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 2, 1 ];
+* var sy = [ 4, 2, 1 ];
+* var sz = [ 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create input ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': accessors( xbuf ).accessors
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': accessors( ybuf ).accessors
+* };
+*
+* // Create an output ndarray-like object:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major',
+*     'accessors': accessors( zbuf ).accessors
+* };
+*
+* // Initialize ndarray-like objects representing sub-array views:
+* var views = [
+*     {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     },
+*     {
+*         'dtype': y.dtype,
+*         'data': y.data,
+*         'shape': [ 2, 2 ],
+*         'strides': [ 2, 1 ],
+*         'offset': y.offset,
+*         'order': y.order
+*     }
+* ];
+*
+* // Define a reshape strategy:
+* function strategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Perform a reduction:
+* binarynd( gdot, [ x, y, z ], views, strategy, strategy, {} );
+*
+* var arr = ndarray2array( z.data, z.shape, z.strides, z.offset, z.order );
+* // returns [ 30.0, 174.0, 446.0 ]
+*/
+function binarynd( fcn, arrays, views, strategyX, strategyY, opts ) {
+	var zbuf;
+	var len;
+	var arr;
+	var set;
+	var sh;
+	var iv;
+	var io;
+	var N;
+	var z;
+	var v;
+	var i;
+	var j;
+
+	N = arrays.length;
+
+	// Resolve the output ndarray and associated shape:
+	z = arrays[ 2 ];
+	sh = z.shape;
+
+	// Compute the total number of elements over which to iterate:
+	len = numel( sh );
+
+	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
+	iv = offsets( arrays );
+
+	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
+	v = copyIndexed( views );
+
+	// Cache a reference to the output ndarray buffer:
+	zbuf = z.data;
+
+	// Cache accessors:
+	set = z.accessors[ 1 ];
+
+	// Iterate based on the linear **view** index, regardless as to how the data is stored in memory...
+	io = zeros( N );
+	for ( i = 0; i < len; i++ ) {
+		for ( j = 0; j < N; j++ ) {
+			arr = arrays[ j ];
+			io[ j ] = vind2bind( sh, arr.strides, iv[ j ], arr.order, i, MODE );
+		}
+		setViewOffsets( views, io );
+		v[ 0 ] = strategyX( views[ 0 ] );
+		v[ 1 ] = strategyY( views[ 1 ] );
+		set( zbuf, io[2], fcn( v, opts ) );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = binarynd;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/offsets.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/offsets.js
new file mode 100644
index 000000000000..a606628f5f3d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/offsets.js
@@ -0,0 +1,42 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MAIN //
+
+/**
+* Resolves index offsets from a list of ndarray-like objects.
+*
+* @private
+* @param {ArrayLikeObject<Object>} arrays - list of ndarray-like objects
+* @returns {NonNegativeIntegerArray} list of offsets
+*/
+function offsets( arrays ) {
+	var out = [];
+	var i;
+	for ( i = 0; i < arrays.length; i++ ) {
+		out.push( arrays[ i ].offset );
+	}
+	return out;
+}
+
+
+// EXPORTS //
+
+module.exports = offsets;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/reshape_strategy.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/reshape_strategy.js
new file mode 100644
index 000000000000..aa8118f8f85a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/reshape_strategy.js
@@ -0,0 +1,260 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var iterationOrder = require( '@stdlib/ndarray/base/iteration-order' );
+var minmaxViewBufferIndex = require( '@stdlib/ndarray/base/minmax-view-buffer-index' ).assign;
+var ndarraylike2object = require( '@stdlib/ndarray/base/ndarraylike2object' );
+var assign = require( '@stdlib/ndarray/base/assign' );
+var ndarraylike2ndarray = require( '@stdlib/ndarray/base/ndarraylike2ndarray' );
+var emptyLike = require( '@stdlib/ndarray/base/empty-like' );
+
+
+// FUNCTIONS //
+
+/**
+* Returns an input ndarray.
+*
+* @private
+* @param {ndarrayLike} x - input ndarray
+* @returns {ndarrayLike} input ndarray
+*/
+function identity( x ) {
+	return x;
+}
+
+/**
+* Broadcasts a zero-dimensional ndarray to a one-dimensional ndarray view containing a single element.
+*
+* @private
+* @param {ndarrayLike} x - input ndarray
+* @returns {ndarrayLike} broadcasted ndarray view
+*/
+function broadcast( x ) {
+	// NOTE: the following properties must be set in the exact same order as in `x` in order to ensure that the returned object has the same hidden shape as the input ndarray-like object...
+	return {
+		'dtype': x.dtype,
+		'data': x.data,
+		'shape': [ 1 ],
+		'strides': [ 0 ],
+		'offset': x.offset,
+		'order': x.order
+	};
+}
+
+/**
+* Returns a function which returns an ndarray view in which the singleton dimensions are removed from an input ndarray having only a single non-singleton dimension.
+*
+* @private
+* @param {ndarrayLike} arr - original ndarray
+* @param {NonNegativeInteger} index - index of the non-singleton dimension
+* @returns {Function} function for returning an ndarray view
+*/
+function squeeze( arr, index ) {
+	var sh = [ arr.shape[ index ] ];
+	var sx = [ arr.strides[ index ] ];
+	return reshape;
+
+	/**
+	* Returns an ndarray view in which the singleton dimensions are removed from an input ndarray having only a single non-singleton dimension.
+	*
+	* @private
+	* @param {ndarrayLike} x - input ndarray
+	* @returns {ndarrayLike} a squeezed ndarray view
+	*/
+	function reshape( x ) {
+		// NOTE: the following properties must be set in the exact same order as in `arr` in order to ensure that the returned object has the same hidden shape as the input ndarray-like object...
+		return {
+			'dtype': x.dtype,
+			'data': x.data,
+			'shape': sh,
+			'strides': sx,
+			'offset': x.offset,
+			'order': x.order
+		};
+	}
+}
+
+/**
+* Returns a function which returns a one-dimensional ndarray view of a contiguous input ndarray having more than one dimension.
+*
+* @private
+* @param {NonNegativeInteger} len - number of elements in an ndarray
+* @param {integer} iox - iteration order
+* @returns {Function} function for returning a one-dimensional ndarray view
+*/
+function contiguous( len, iox ) {
+	var xmmv;
+	var ind;
+	var sh;
+	var sx;
+
+	// Resolve the index of the min/max view buffer element which is the first indexed element...
+	if ( iox === 1 ) {
+		ind = 0;
+	} else {
+		ind = 1;
+	}
+	// Initialize an array for storing the min/max view buffer elements:
+	xmmv = [ 0, 0 ]; // [ min, max ]
+
+	// Initialize the output one-dimensional view's shape and strides:
+	sh = [ len ];
+	sx = [ iox ];
+
+	return reshape;
+
+	/**
+	* Returns a one-dimensional ndarray view of a contiguous input ndarray having more than one dimension.
+	*
+	* @private
+	* @param {ndarrayLike} x - input ndarray
+	* @returns {ndarrayLike} a one-dimensional ndarray view
+	*/
+	function reshape( x ) {
+		// Resolve the minimum and maximum linear indices in the underlying data buffer which are accessible to the input ndarray view:
+		minmaxViewBufferIndex( x.shape, x.strides, x.offset, xmmv );
+
+		// NOTE: the following properties must be set in the exact same order as in `x` in order to ensure that the returned object has the same hidden shape as the input ndarray-like object...
+		return {
+			'dtype': x.dtype,
+			'data': x.data,
+			'shape': sh,
+			'strides': sx,
+			'offset': xmmv[ ind ], // the index of the first indexed element
+			'order': x.order
+		};
+	}
+}
+
+/**
+* Returns a function which copies an input ndarray to a contiguous ndarray workspace.
+*
+* @private
+* @param {NonNegativeInteger} len - number of elements in an ndarray
+* @param {ndarrayLike} workspace - ndarray workspace
+* @returns {Function} function which copies an input ndarray to a contiguous ndarray workspace
+*/
+function copy( len, workspace ) {
+	// NOTE: the following properties must be set in the exact same order as in the input ndarray-like object in order to ensure that the returned object has the same hidden shape...
+	var view = {
+		'dtype': workspace.dtype,
+		'data': workspace.data,
+		'shape': [ len ],
+		'strides': [ 1 ],
+		'offset': workspace.offset,
+		'order': workspace.order
+	};
+	return reshape;
+
+	/**
+	* Copies an input ndarray to a contiguous ndarray workspace and returns a one-dimensional workspace view.
+	*
+	* @private
+	* @param {ndarrayLike} x - input ndarray
+	* @returns {ndarrayLike} one-dimensional workspace view
+	*/
+	function reshape( x ) {
+		assign( [ x, workspace ] );
+		return view;
+	}
+}
+
+
+// MAIN //
+
+/**
+* Returns a function for reshaping input ndarrays which have the same data type, shape, and strides as a provided ndarray.
+*
+* @private
+* @param {ndarrayLike} x - input ndarray
+* @param {string} x.dtype - input ndarray data type
+* @param {Collection} x.data - input ndarray data buffer
+* @param {NonNegativeIntegerArray} x.shape - input ndarray shape
+* @param {IntegerArray} x.strides - input ndarray strides
+* @param {NonNegativeInteger} x.offset - input ndarray index offset
+* @param {string} x.order - input ndarray memory layout
+* @returns {Function} function implementing a reshape strategy
+*/
+function strategy( x ) {
+	var ndims;
+	var xmmv;
+	var len;
+	var iox;
+	var sh;
+	var ns;
+	var i;
+
+	// Resolve the number of array dimensions:
+	sh = x.shape;
+	ndims = sh.length;
+
+	// Check whether the ndarray is zero-dimensional...
+	if ( ndims === 0 ) {
+		return broadcast;
+	}
+	// Check whether the ndarray is already one-dimensional...
+	if ( ndims === 1 ) {
+		return identity;
+	}
+	// Determine the number of singleton dimensions...
+	len = 1; // number of elements
+	ns = 0;  // number of singleton dimensions
+	for ( i = 0; i < ndims; i++ ) {
+		// Check whether the current dimension is a singleton dimension...
+		if ( sh[ i ] === 1 ) {
+			ns += 1;
+		}
+		len *= sh[ i ];
+	}
+	// Determine whether the ndarray has only **one** non-singleton dimension (e.g., ndims=4, shape=[10,1,1,1]) so that we can simply create an ndarray view without the singleton dimensions...
+	if ( ns === ndims-1 ) {
+		// Get the index of the non-singleton dimension...
+		for ( i = 0; i < ndims; i++ ) {
+			if ( sh[ i ] !== 1 ) {
+				break;
+			}
+		}
+		return squeeze( x, i );
+	}
+	iox = iterationOrder( x.strides ); // +/-1
+
+	// Determine whether we can avoid copying data...
+	if ( iox !== 0 ) {
+		// Determine the minimum and maximum linear indices which are accessible by the ndarray view:
+		xmmv = minmaxViewBufferIndex( sh, x.strides, x.offset, [ 0, 0 ] );
+
+		// Determine whether we can ignore shape (and strides) and create a new one-dimensional ndarray view...
+		if ( len === ( xmmv[1]-xmmv[0]+1 ) ) {
+			return contiguous( len, iox );
+		}
+		// The ndarray is non-contiguous, so we cannot directly interpret as a one-dimensional ndarray...
+
+		// Fall-through to copying to a workspace ndarray...
+	}
+	// At this point, we're dealing with a non-contiguous multi-dimensional ndarray, so we need to copy to a contiguous workspace:
+	return copy( len, ndarraylike2object( emptyLike( ndarraylike2ndarray( x ) ) ) ); // eslint-disable-line max-len
+}
+
+
+// EXPORTS //
+
+module.exports = strategy;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/set_view_offsets.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/set_view_offsets.js
new file mode 100644
index 000000000000..a4f910079dcb
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/lib/set_view_offsets.js
@@ -0,0 +1,52 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MAIN //
+
+/**
+* Sets view offsets according to a list of index offsets.
+*
+* ## Notes
+*
+* -   This function skips the third element in the list of index offsets, as that is assumed to correspond to the output ndarray which does not have a corresponding view. Meaning, the list of views is expected to have `N` elements, and the list of index offsets is expected to have `N+1` elements.
+* -   This function mutates the provides view objects.
+*
+* @private
+* @param {Array<Object>} views - list of ndarray-like objects representing ndarray views
+* @param {NonNegativeIntegerArray} offsets - list of index offsets
+* @returns {Array<Object>} updated views
+*/
+function setViewOffsets( views, offsets ) {
+	var i;
+	var j;
+	for ( i = 0, j = 0; i < offsets.length; i++ ) {
+		if ( i === 2 ) { // note: expected to correspond to the output ndarray which does not have a corresponding view
+			continue;
+		}
+		views[ j ].offset = offsets[ i ];
+		j += 1;
+	}
+	return views;
+}
+
+
+// EXPORTS //
+
+module.exports = setViewOffsets;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/package.json b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/package.json
new file mode 100644
index 000000000000..b8c2a21ebc70
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/package.json
@@ -0,0 +1,64 @@
+{
+  "name": "@stdlib/ndarray/base/binary-reduce-strided1d",
+  "version": "0.0.0",
+  "description": "Perform a reduction over a list of specified dimensions in two input ndarrays via a one-dimensional strided array reduction function and assign results to a provided output ndarray.",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "The Stdlib Authors",
+    "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+  },
+  "contributors": [
+    {
+      "name": "The Stdlib Authors",
+      "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+    }
+  ],
+  "main": "./lib",
+  "directories": {
+    "doc": "./docs",
+    "example": "./examples",
+    "lib": "./lib",
+    "test": "./test"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://github.com/stdlib-js/stdlib",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/stdlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "base",
+    "strided",
+    "array",
+    "ndarray",
+    "binary",
+    "reduce",
+    "reduction",
+    "accumulate",
+    "accumulation",
+    "vector"
+  ],
+  "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/test/test.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/test/test.js
new file mode 100644
index 000000000000..d42430daf096
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d/test/test.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var binaryReduceStrided1d = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof binaryReduceStrided1d, 'function', 'main export is a function' );
+	t.end();
+});
+
+// FIXME: add tests